func (p *ClusterService) CreateUserCluster(cluster entity.Cluster, x_auth_token string) (newCluster *entity.Cluster, errorCode string, err error) { // generate ObjectId cluster.ObjectId = bson.NewObjectId() userId := cluster.UserId if len(userId) == 0 { err = errors.New("user_id not provided") errorCode = COMMON_ERROR_INVALIDATE logrus.Errorf("create cluster [%v] error is %v", cluster, err) return } user, err := GetUserById(userId, x_auth_token) if err != nil { logrus.Errorf("get user by id err is %v", err) errorCode = CLUSTER_ERROR_CALL_USERMGMT return nil, errorCode, err } cluster.TenantId = user.TenantId cluster.Owner = user.Username // set created_time and updated_time cluster.TimeCreate = dao.GetCurrentTime() cluster.TimeUpdate = cluster.TimeCreate cluster.Status = CLUSTER_STATUS_DEPLOYING // insert bson to mongodb err = dao.HandleInsert(p.collectionName, cluster) if err != nil { errorCode = CLUSTER_ERROR_CALL_MONGODB logrus.Errorf("create cluster [%v] to bson error is %v", cluster, err) return } //add records of hosts in db for i := 0; i < cluster.Instances; i++ { host := entity.Host{} host.ClusterId = cluster.ObjectId.Hex() host.ClusterName = cluster.Name host.Status = HOST_STATUS_DEPLOYING host.UserId = cluster.UserId host.TimeCreate = dao.GetCurrentTime() host.TimeUpdate = host.TimeCreate _, _, err := GetHostService().Create(host, x_auth_token) if err != nil { logrus.Errorf("insert host to db error is [%v]", err) } } if IsDeploymentEnabled() { //call deployment go CreateCluster(cluster, x_auth_token) } newCluster = &cluster return }
func (p *HostService) UpdateById(objectId string, host entity.Host, x_auth_token string) (created bool, errorCode string, err error) { logrus.Infof("start to update host [%v]", host) // do authorize first if authorized := GetAuthService().Authorize("update_host", x_auth_token, objectId, p.collectionName); !authorized { err = errors.New("required opertion is not authorized!") errorCode = COMMON_ERROR_UNAUTHORIZED logrus.Errorf("update host with objectId [%v] error is %v", objectId, err) return } if !bson.IsObjectIdHex(objectId) { err = errors.New("invalide ObjectId.") errorCode = COMMON_ERROR_INVALIDATE return } // FIXING // hostquery, _, _ := p.QueryById(objectId, x_auth_token) var selector = bson.M{} selector["_id"] = bson.ObjectIdHex(objectId) host.ObjectId = bson.ObjectIdHex(objectId) host.TimeUpdate = dao.GetCurrentTime() logrus.Infof("start to change host") err = dao.HandleUpdateByQueryPartial(p.collectionName, selector, &host) // created, err = dao.HandleUpdateOne(&host, dao.QueryStruct{p.collectionName, selector, 0, 0, ""}) if err != nil { logrus.Errorf("update host [%v] error is %v", host, err) errorCode = HOST_ERROR_UPDATE } created = true return }
func (p *UserService) createAndInsertUser(userName string, password string, email string, tenanId string, roleId string, company string) (userId string, err error) { // var jsondocument interface{} currentUser, erro := p.getAllUserByName(userName) if erro != nil { logrus.Error("get all user by username err is %v", erro) return "", erro } if len(currentUser) != 0 { logrus.Infoln("user already exist! username:"******"create user error %v", err) return } userId = user.ObjectId.Hex() return }
// CreateAndInsertTenant creat the tenant and insert to collection according // by tenantname and desc. func (p *TenantService) createAndInsertTenant(tenantName string, desc string) (tenantId string, err error) { tenant, erro := p.getTenantByName(tenantName) if erro == nil { logrus.Infoln("tenant already exist! tenantname: ", tenantName) tenantId = tenant.ObjectId.Hex() return } currentTime := dao.GetCurrentTime() objectId := bson.NewObjectId() newTenant := entity.Tenant{ ObjectId: objectId, Tenantname: tenantName, Description: desc, TimeCreate: currentTime, TimeUpdate: currentTime, } err = dao.HandleInsert(p.collectionName, &newTenant) if err != nil { logrus.Error("create tenant error %v", err) return } tenantId = newTenant.ObjectId.Hex() return }
// CreateAndInsertRole creat and insert the role items according to the given // rolename and desc. func (p *RoleService) createAndInsertRole(roleName string, desc string) (roleId string, err error) { role := &entity.Role{} role, err = p.getRoleByName(roleName) if err == nil { logrus.Infoln("role already exist! roleName: ", roleName) roleId = role.ObjectId.Hex() return } currentTime := dao.GetCurrentTime() objectId := bson.NewObjectId() role = &entity.Role{ ObjectId: objectId, Rolename: roleName, Description: desc, TimeCreate: currentTime, TimeUpdate: currentTime, } err = dao.HandleInsert(p.collectionName, role) if err != nil { logrus.Warnln("create role error %v", err) return } roleId = role.ObjectId.Hex() return }
func (p *UserService) UserChangePassword(token string, id string, password string, newpassword string, confirm_newpassword string) (created bool, errorCode string, err error) { code, err := GetTokenService().TokenValidate(token) if err != nil { return false, code, err } if authorized := GetAuthService().Authorize("change_password", token, id, p.userCollectionName); !authorized { logrus.Errorln("required opertion is not allowed!") return false, COMMON_ERROR_UNAUTHORIZED, errors.New("Required opertion is not authorized!") } user, err := p.GetUserByUserId(id) if err != nil { logrus.Errorln("user does exist %v", err) return false, COMMON_ERROR_INTERNAL, errors.New("User does not exist!") } pwdEncry := HashString(password) if !strings.EqualFold(pwdEncry, user.Password) { logrus.Errorln("incorrect password!") return false, USER_ERROR_WRONGPW, errors.New("Incorrect password!") } if !strings.EqualFold(newpassword, confirm_newpassword) { logrus.Errorln("inconsistence new password!") return false, USER_ERROR_WRONGPW, errors.New("Inconsistent new password!") } newpasswordEncry := HashString(newpassword) user.Password = newpasswordEncry user.TimeUpdate = dao.GetCurrentTime() // userDoc := ConvertToBson(*user) selector := bson.M{} selector["_id"] = bson.ObjectIdHex(id) queryStruct := dao.QueryStruct{ CollectionName: p.userCollectionName, Selector: selector, Skip: 0, Limit: 0, Sort: ""} created, err = dao.HandleUpdateOne(user, queryStruct) if err != nil { logrus.Error("update user password error! %v", err) return created, USER_ERROR_UPDATE, err } return created, "", nil }
func (p *ProviderService) Create(provider entity.IaaSProvider, token string) (newProvider entity.IaaSProvider, errorCode string, err error) { logrus.Infof("create provider [%v]", provider) errorCode, err = TokenValidation(token) if err != nil { logrus.Errorf("token validation failed for provider creation [%v]", err) return } // do authorize first if authorized := GetAuthService().Authorize("create_provider", token, "", p.collectionName); !authorized { err = errors.New("required opertion is not authorized!") errorCode = COMMON_ERROR_UNAUTHORIZED logrus.Errorf("create provider [%v] error is %v", provider, err) return } userId := provider.UserId if len(userId) == 0 { err = errors.New("user_id not provided") errorCode = COMMON_ERROR_INVALIDATE logrus.Errorf("create provider [%v] error is %v", provider, err) return } user, err := GetUserById(userId, token) if err != nil { logrus.Errorf("get user by id err is %v", err) errorCode = COMMON_ERROR_INTERNAL return newProvider, errorCode, err } provider.ObjectId = bson.NewObjectId() provider.TenantId = user.TenantId // set created_time and updated_time provider.TimeCreate = dao.GetCurrentTime() provider.TimeUpdate = provider.TimeCreate err = dao.HandleInsert(p.collectionName, provider) if err != nil { errorCode = PROVIDER_ERROR_CREATE logrus.Errorf("create provider [%v] to bson error is %v", provider, err) return } newProvider = provider return }
func (p *UserService) UserUpdate(token string, newuser entity.User, userId string) (created bool, id string, errorCode string, err error) { code, err := GetTokenService().TokenValidate(token) if err != nil { return false, userId, code, err } if authorized := GetAuthService().Authorize("update_user", token, userId, p.userCollectionName); !authorized { logrus.Errorln("required opertion is not allowed!") return false, userId, COMMON_ERROR_UNAUTHORIZED, errors.New("Required opertion is not authorized!") } if !bson.IsObjectIdHex(userId) { logrus.Errorf("invalid user id format for user update %v", userId) return false, "", COMMON_ERROR_INVALIDATE, errors.New("Invalid object Id for user update") } selector := bson.M{} selector["_id"] = bson.ObjectIdHex(userId) queryStruct := dao.QueryStruct{ CollectionName: p.userCollectionName, Selector: selector, Skip: 0, Limit: 0, Sort: ""} user := new(entity.User) err = dao.HandleQueryOne(user, queryStruct) if err != nil { logrus.Errorf("get user by id error %v", err) return false, "", USER_ERROR_UPDATE, err } if len(newuser.Company) > 0 { user.Company = newuser.Company } if len(newuser.Email) > 0 { user.Email = newuser.Email } user.TimeUpdate = dao.GetCurrentTime() created, err = dao.HandleUpdateOne(user, queryStruct) return created, userId, "", nil }
func (p *HostService) Create(host entity.Host, x_auth_token string) (newHost entity.Host, errorCode string, err error) { logrus.Infof("start to create host [%v]", host) // do authorize first if authorized := GetAuthService().Authorize("create_host", x_auth_token, "", p.collectionName); !authorized { err = errors.New("required opertion is not authorized!") errorCode = COMMON_ERROR_UNAUTHORIZED logrus.Errorf("create host [%v] error is %v", host, err) return } // generate ObjectId host.ObjectId = bson.NewObjectId() token, err := GetTokenById(x_auth_token) if err != nil { errorCode = HOST_ERROR_CREATE logrus.Errorf("get token failed when create host [%v], error is %v", host, err) return } // set token_id and user_id from token host.TenantId = token.Tenant.Id host.UserId = token.User.Id // set created_time and updated_time host.TimeCreate = dao.GetCurrentTime() host.TimeUpdate = host.TimeCreate // insert bson to mongodb err = dao.HandleInsert(p.collectionName, host) if err != nil { errorCode = HOST_ERROR_CREATE logrus.Errorf("insert host [%v] to db error is %v", host, err) return } newHost = host return }
func (p *HostService) UpdateStatusById(objectId string, status string, x_auth_token string) (created bool, errorCode string, err error) { logrus.Infof("start to update host by objectId [%v] status to %v", objectId, status) // do authorize first if authorized := GetAuthService().Authorize("update_host", x_auth_token, objectId, p.collectionName); !authorized { err = errors.New("required opertion is not authorized!") errorCode = COMMON_ERROR_UNAUTHORIZED logrus.Errorf("update host with objectId [%v] status to [%v] failed, error is %v", objectId, status, err) return } // validate objectId if !bson.IsObjectIdHex(objectId) { err = errors.New("invalide ObjectId.") errorCode = COMMON_ERROR_INVALIDATE return } host, _, err := p.QueryById(objectId, x_auth_token) if err != nil { logrus.Errorf("get host by objeceId [%v] failed, error is %v", objectId, err) return } if host.Status == status { logrus.Infof("this host [%v] is already in state [%v]", host, status) return false, "", nil } var selector = bson.M{} selector["_id"] = bson.ObjectIdHex(objectId) change := bson.M{"status": status, "time_update": dao.GetCurrentTime()} err = dao.HandleUpdateByQueryPartial(p.collectionName, selector, change) if err != nil { logrus.Errorf("update host with objectId [%v] status to [%v] failed, error is %v", objectId, status, err) created = false return } created = true return }
// CheckAndGenerateToken check the token and creat the new token. func (p *TokenService) checkAndGenerateToken(user string, passwd string, tenant string, needPasswd bool) (result string, err error) { //get user by name userobjAll, err := GetUserService().getAllUserByName(user) if err != nil { logrus.Errorf("get user by username err is %v", err) return result, err } if len(userobjAll) == 0 { logrus.Errorln("user does not exist! username:"******"user does not exit!") } userobj := userobjAll[0] //get tenant by name tenantobj, err := GetTenantService().getTenantByTenantId(tenant) if err != nil { logrus.Errorln("tenant does not exist! name:", tenant) return result, errors.New("tenant does not exist!") } tenantid := tenantobj.ObjectId.Hex() tenantname := tenantobj.Tenantname userid := userobj.ObjectId.Hex() password := userobj.Password role := userobj.RoleId if needPasswd { encryPassword := HashString(passwd) if !strings.EqualFold(encryPassword, password) { logrus.Errorln("invalid password!") return result, errors.New("invalid password!") } } //get role roleobj, err := GetRoleService().getRoleByRoleId(role) if err != nil { logrus.Errorln("role does not exist! rolename:", role) return result, errors.New("role does not exist!") } roleid := roleobj.ObjectId.Hex() time := common.UTIL.Props.GetString("expiration_time", "21600") newtime, err := strconv.ParseInt(strings.TrimSpace(time), 10, 64) if err != nil { logrus.Warnln("invalid expire time configured %v", err) newtime = int64(21600) } expireTime := GenerateExpireTime(newtime) currentTime := dao.GetCurrentTime() userpart := entity.UserPart{Id: userid, Username: user} tenantpart := entity.TenantPart{Id: tenantid, Tenantname: tenantname} rolepart := entity.RolePart{Id: roleid, Rolename: roleobj.Rolename} objectId := bson.NewObjectId() newtoken := entity.Token{ ObjectId: objectId, Expire: expireTime, User: userpart, Tenant: tenantpart, Role: rolepart, TimeCreate: currentTime, TimeUpdate: currentTime, } err = dao.HandleInsert(p.collectionName, &newtoken) result = newtoken.ObjectId.Hex() if err != nil { logrus.Errorf("save token err is %v", err) return result, err } return }
//terminate specified hosts of a cluster func (p *ClusterService) TerminateHosts(clusterId string, hostIds []string, x_auth_token string) (errorCode string, err error) { logrus.Infof("start to decrease cluster hosts [%v]", hostIds) if !bson.IsObjectIdHex(clusterId) { err = errors.New("Invalid cluster_id") errorCode = COMMON_ERROR_INVALIDATE return } if len(hostIds) == 0 { errorCode = COMMON_ERROR_INVALIDATE err = errors.New("Empty array of host id") return errorCode, err } //query cluster by clusterId cluster := entity.Cluster{} clusterSelector := bson.M{} clusterSelector["_id"] = bson.ObjectIdHex(clusterId) err = dao.HandleQueryOne(&cluster, dao.QueryStruct{p.collectionName, clusterSelector, 0, 0, ""}) _, currentHosts, errorCode, err := GetHostService().QueryHosts(clusterId, 0, 0, HOST_STATUS_RUNNING, x_auth_token) if err != nil { logrus.Errorf("get host by clusterId[%v] error [%v]", clusterId, err) return errorCode, err } if !deletable(currentHosts, hostIds) { logrus.Errorf("cluster's running node should not less than 5 nodes!") return CLUSTER_ERROR_DELETE_NODE_NUM, errors.New("cluster's running node should not less than 5 nodes!") } hosts := []entity.Host{} originStatus := make(map[string]string) directDeletedHosts := 0 for _, hostId := range hostIds { //query host host, errorCode, err := GetHostService().QueryById(hostId, x_auth_token) if err != nil { return errorCode, err } //no host name means current host has not been created by docker-machine if len(strings.TrimSpace(host.HostName)) <= 0 { logrus.Warnf("host has no hostname, will be terminated directly, hostid: %s", hostId) _, _, err := GetHostService().UpdateStatusById(hostId, HOST_STATUS_TERMINATED, x_auth_token) if err != nil { logrus.Warnf("set no hostname host[%s] status to termianted error %v", hostId, err) } directDeletedHosts++ continue } hosts = append(hosts, host) //protect master node if host.IsMasterNode { return HOST_ERROR_DELETE_MASTER, errors.New("Cannot delete master node") } originStatus[host.ObjectId.Hex()] = host.Status //call API to terminate host(master node cannot be deleted now) _, errorCode, err = GetHostService().UpdateStatusById(hostId, HOST_STATUS_TERMINATING, x_auth_token) if err != nil { logrus.Errorf("terminate host error is %s,%v", errorCode, err) continue } } if directDeletedHosts > 0 { logrus.Infof("update cluster instances - %d", directDeletedHosts) newvalue := cluster.Instances - directDeletedHosts selector := bson.M{} selector["_id"] = cluster.ObjectId change := bson.M{"instances": newvalue, "time_update": dao.GetCurrentTime()} erro := dao.HandleUpdateByQueryPartial(p.collectionName, selector, change) if erro != nil { logrus.Errorf("update cluster with objectId [%v] instances to [%d] failed, error is %v", clusterId, newvalue, erro) } } if len(hosts) <= 0 { logrus.Infof("no valid hosts will be deleted!") return } if IsDeploymentEnabled() { //call deployment module to delete nodes go DeleteNodes(cluster, hosts, originStatus, x_auth_token) } return }
func (p *ClusterService) DeleteById(clusterId string, x_auth_token string) (errorCode string, err error) { logrus.Infof("start to delete Cluster with id [%v]", clusterId) // do authorize first if authorized := GetAuthService().Authorize("delete_cluster", x_auth_token, clusterId, p.collectionName); !authorized { err = errors.New("required opertion is not authorized!") errorCode = COMMON_ERROR_UNAUTHORIZED logrus.Errorf("authorize failure when deleting cluster with id [%v] , error is %v", clusterId, err) return errorCode, err } if !bson.IsObjectIdHex(clusterId) { err = errors.New("Invalid cluster id.") errorCode = COMMON_ERROR_INVALIDATE return errorCode, err } //query cluster cluster, errorCode, err := p.QueryById(clusterId, x_auth_token) if err != nil { logrus.Errorf("query cluster error is %v", err) return errorCode, err } //check status switch cluster.Status { case CLUSTER_STATUS_DEPLOYING, CLUSTER_STATUS_TERMINATING, CLUSTER_STATUS_TERMINATED: logrus.Errorf("Cannot operate on a %s cluster", cluster.Status) return CLUSTER_ERROR_INVALID_STATUS, errors.New("Cannot operate on a " + cluster.Status + " cluster") case CLUSTER_STATUS_RUNNING, CLUSTER_STATUS_FAILED: //query all hosts var total int total, hosts, errorCode, err := GetHostService().QueryHosts(clusterId, 0, 0, "unterminated", x_auth_token) if err != nil { logrus.Errorf("query hosts in cluster %s error is %v", clusterId, err) return errorCode, err } successNode := 0 directDeletedHosts := 0 //set status of all hosts TERMINATING for _, host := range hosts { //no host name means current host has not been created by docker-machine if len(strings.TrimSpace(host.HostName)) <= 0 { hostId := host.ObjectId.Hex() logrus.Warnf("cluster[%s] host [%s] has no hostname, will be terminated directly", cluster.Name, hostId) _, _, err := GetHostService().UpdateStatusById(hostId, HOST_STATUS_TERMINATED, x_auth_token) if err != nil { logrus.Warnf("set no hostname host status to termianted error %v", err) } directDeletedHosts++ continue } //deploying and terminating host is not allowed to be terminated if host.Status == HOST_STATUS_DEPLOYING || host.Status == HOST_STATUS_TERMINATING { logrus.Errorf("status of host [%v] is [%s], cluster can not be deleted!", host.HostName, host.Status) return CLUSTER_ERROR_DELETE_NOT_ALLOWED, errors.New("cannot delete cluster because not all nodes are ready") } //set host status to termianting _, _, err = GetHostService().UpdateStatusById(host.ObjectId.Hex(), HOST_STATUS_TERMINATING, x_auth_token) if err != nil { logrus.Warnf("delete host [objectId=%v] error is %v", host.ObjectId.Hex(), err) } else { successNode++ } } logrus.Infof("Cluster %s has %d hosts, %d successfully terminating", cluster.Name, total, successNode) selector := bson.M{} selector["_id"] = cluster.ObjectId change := bson.M{"status": CLUSTER_STATUS_TERMINATING, "time_update": dao.GetCurrentTime()} if directDeletedHosts > 0 { logrus.Infof("update cluster instances - %d", directDeletedHosts) newvalue := cluster.Instances - directDeletedHosts change["instances"] = newvalue } logrus.Debugf("update cluster status and instance bson[%v]", change) erro := dao.HandleUpdateByQueryPartial(p.collectionName, selector, change) if erro != nil { logrus.Errorf("update cluster with objectId [%v] failed, error is %v", clusterId, erro) } if IsDeploymentEnabled() { //call deployment module API go DeleteCluster(cluster, x_auth_token) } default: logrus.Errorf("Unknown cluster status %s", cluster.Status) return CLUSTER_ERROR_INVALID_STATUS, errors.New("Unknown cluster status " + cluster.Status) } return }
func (p *ClusterService) CreateMgmtCluster(cluster entity.Cluster, x_auth_token string) (newCluster *entity.Cluster, errorCode string, err error) { //check if mgmt cluster already exist //only 1 allowed in database query := bson.M{} query["type"] = "mgmt" n, _, _, err := p.queryByQuery(query, 0, 0, "", x_auth_token, false) if n > 0 { return nil, CLUSTER_ERROR_CALL_MONGODB, errors.New("mgmt cluster already exist") } if cluster.Name == "" { cluster.Name = "Management" } token, err := GetTokenById(x_auth_token) if err != nil { logrus.Errorf("get token by id error is %v", err) errorCode = CLUSTER_ERROR_CALL_USERMGMT return nil, errorCode, err } if cluster.UserId == "" { cluster.UserId = token.User.Id } if cluster.Owner == "" { cluster.Owner = token.User.Username } if cluster.Details == "" { cluster.Details = "Cluster to manage other clusters" } cluster.TimeCreate = dao.GetCurrentTime() cluster.TimeUpdate = cluster.TimeCreate cluster.Status = CLUSTER_STATUS_DEPLOYING // insert bson to mongodb err = dao.HandleInsert(p.collectionName, cluster) if err != nil { errorCode = CLUSTER_ERROR_CALL_MONGODB logrus.Errorf("create cluster [%v] to bson error is %v", cluster, err) return } for i := 0; i < cluster.Instances; i++ { host := entity.Host{} host.ClusterId = cluster.ObjectId.Hex() host.ClusterName = cluster.Name host.Status = HOST_STATUS_DEPLOYING host.UserId = cluster.UserId host.TimeCreate = dao.GetCurrentTime() host.TimeUpdate = host.TimeCreate _, _, err := GetHostService().Create(host, x_auth_token) if err != nil { logrus.Errorf("insert host to db error is [%v]", err) } } newCluster = &cluster return }
//call dcos deployment module to add nodes func AddNodes(cluster entity.Cluster, createNumber int, hosts []entity.Host, x_auth_token string) (err error) { request := new(dcosentity.AddNodeRequest) request.UserName = cluster.Owner request.ClusterName = cluster.Name request.CreateNumber = createNumber request.ExistedNumber = cluster.Instances request.ProviderInfo = getProvider(cluster.UserId, x_auth_token) //create hosts _, currentHosts, _, err := GetHostService().QueryHosts(cluster.ObjectId.Hex(), 0, 0, "unterminated", x_auth_token) if err != nil { logrus.Errorf("get current hosts by clusterId error %v", err) removeAddedNodes(hosts, x_auth_token) return err } request.ConsulServer, request.DnsServers, request.SwarmMaster = getNodeInfo(currentHosts) logrus.Debugf("add node request is %v", request) //call //dcos deployment module returns newly-created nodes info var servers *[]dcosentity.Server servers, err = SendAddNodesRequest(request) if err != nil { logrus.Errorf("send request to dcos deploy error is %v", err) removeAddedNodes(hosts, x_auth_token) return } ok_count := len(*servers) logrus.Infof("try to add %d nodes, %d success", createNumber, ok_count) //update newly-created hosts for i, server := range *servers { host := hosts[i] id := host.ObjectId.Hex() host.HostName = server.Hostname host.Status = HOST_STATUS_RUNNING host.IP = server.IpAddress host.PrivateIp = server.PrivateIpAddress host.IsMasterNode = server.IsMaster host.IsSlaveNode = server.IsSlave host.IsSwarmMaster = server.IsSwarmMaster host.TimeUpdate = dao.GetCurrentTime() _, _, err := GetHostService().UpdateById(id, host, x_auth_token) if err != nil { logrus.Errorf("update host error is [%v] \n", err) } } //update status of failed nodes for i := ok_count; i < createNumber; i++ { _, _, err := GetHostService().UpdateStatusById(hosts[i].ObjectId.Hex(), HOST_STATUS_FAILED, x_auth_token) if err != nil { logrus.Errorf("update host error is [%v] \n", err) } } //update cluster nodes number and status logrus.Infoln("update cluster number and status") cluster.Instances = cluster.Instances + len(hosts) cluster.Status = CLUSTER_STATUS_RUNNING GetClusterService().UpdateCluster(cluster, x_auth_token) // //update cluster status // logrus.Infoln("set cluster status to RUNNING") // GetClusterService().UpdateStatusById(cluster.ObjectId.Hex(), CLUSTER_STATUS_RUNNING, x_auth_token) return }