func CreateDefaultECProfiles(ctxt string, mon string, clusterId uuid.UUID) (bool, error) {
sessionCopy := db.GetDatastore().Copy()
defer sessionCopy.Close()
var cluster models.Cluster
coll := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_STORAGE_CLUSTERS)
if err := coll.Find(bson.M{"clusterid": clusterId}).One(&cluster); err != nil {
logger.Get().Error("%s-Error getting cluster details for %v. error: %v", ctxt, clusterId, err)
return false, err
}
var cmdMap map[string]string = map[string]string{
"4+2": fmt.Sprintf("ceph osd erasure-code-profile set k4m2 plugin=jerasure k=4 m=2 --cluster %s", cluster.Name),
"6+3": fmt.Sprintf("ceph osd erasure-code-profile set k6m3 plugin=jerasure k=6 m=3 --cluster %s", cluster.Name),
"8+4": fmt.Sprintf("ceph osd erasure-code-profile set k8m4 plugin=jerasure k=8 m=4 --cluster %s", cluster.Name),
}
for k, v := range cmdMap {
ok, _, err := cephapi_backend.ExecCmd(mon, clusterId, v, ctxt)
if err != nil || !ok {
logger.Get().Error("%s-Error creating EC profile for %s. error: %v", ctxt, k, err)
continue
} else {
logger.Get().Debug("%s-Added EC profile for %s", ctxt, k)
}
}
return true, nil
}
func (manager *Manager) Remove(id uuid.UUID) {
delete(manager.tasks, id)
sessionCopy := db.GetDatastore().Copy()
defer sessionCopy.Close()
coll := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_TASKS)
_ = coll.Remove(bson.M{"id": id})
}
func GetRandomMon(clusterId uuid.UUID) (*models.Node, error) {
sessionCopy := db.GetDatastore().Copy()
defer sessionCopy.Close()
var mons models.Nodes
var clusterNodes models.Nodes
coll := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_STORAGE_NODES)
if err := coll.Find(bson.M{"clusterid": clusterId}).All(&clusterNodes); err != nil {
return nil, err
}
for _, clusterNode := range clusterNodes {
for k, v := range clusterNode.Options {
if k == "mon" && v == "Y" {
mons = append(mons, clusterNode)
}
}
}
if len(mons) <= 0 {
return nil, errors.New(fmt.Sprintf("No mons available for cluster: %v", clusterId))
}
// Pick a random mon from the list
var monNodeId uuid.UUID
if len(mons) == 1 {
monNodeId = mons[0].NodeId
} else {
randomIndex := utils.RandomNum(0, len(mons)-1)
monNodeId = mons[randomIndex].NodeId
}
var monnode models.Node
coll = sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_STORAGE_NODES)
if err := coll.Find(bson.M{"nodeid": monNodeId}).One(&monnode); err != nil {
return nil, err
}
return &monnode, nil
}
func updateRBDStats(ctxt string, cluster models.Cluster, monName string) (map[string]map[string]string, []RBDStats, error) {
var err_str string
var rbdStats []RBDStats
sessionCopy := db.GetDatastore().Copy()
defer sessionCopy.Close()
collection := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_STORAGE)
var pools []models.Storage
if err := collection.Find(bson.M{"clusterid": cluster.ClusterId}).All(&pools); err != nil {
logger.Get().Error("%s - Failed to fetch rbd stats for cluster %v.Error %v", ctxt, cluster.Name, err)
return nil, rbdStats, err
}
metrics := make(map[string]map[string]string)
currentTimeStamp := strconv.FormatInt(time.Now().Unix(), 10)
monitoringConfig := conf.SystemConfig.TimeSeriesDBConfig
for _, pool := range pools {
var statistics RBDStats
metric_name := fmt.Sprintf("%s.%s.%s.%s.", monitoringConfig.CollectionName, strings.Replace(cluster.Name, ".", "_", -1), strings.Replace(pool.Name, ".", "_", -1), models.COLL_NAME_BLOCK_DEVICES)
response, isSuccess := getStatsFromCalamariApi(ctxt,
monName,
cluster.ClusterId,
map[string]string{"clusterName": cluster.Name, "poolName": pool.Name},
skyring_monitoring.BLOCK_DEVICE_UTILIZATION)
if !isSuccess {
/*
Already generically handled in above getStatsFromCalamariApi function.
So just a process next item.
*/
continue
}
if err := json.Unmarshal([]byte(response), &statistics); err != nil {
err_str = fmt.Sprintf("%s. Failed to fetch rbd stats from pool %v, cluster %v.Could not unmarshal %v.Error %v", err_str, pool.Name, cluster.Name, response, err)
continue
}
rbdColl := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_BLOCK_DEVICES)
for _, rbdStat := range statistics.RBDs {
metric_name = fmt.Sprintf("%s%s.", metric_name, strings.Replace(rbdStat.Name, ".", "_", -1))
var percent_used float64
if rbdStat.Total > 0 {
percent_used = float64(rbdStat.Used*100) / float64(rbdStat.Total)
}
if err := rbdColl.Update(bson.M{"clusterid": cluster.ClusterId, "name": rbdStat.Name, "storageid": pool.StorageId}, bson.M{"$set": bson.M{"usage": models.Utilization{
Used: int64(rbdStat.Used),
Total: int64(rbdStat.Total),
PercentUsed: percent_used,
UpdatedAt: time.Now().String()}}}); err != nil {
err_str = fmt.Sprintf("%s.Unable to update rbd stats of rbd %v from mon %v of pool %v, cluster %v.Error: %v",
err_str, rbdStat.Name, monName, pool.Name, cluster.Name, err)
}
metrics[metric_name+skyring_monitoring.USED_SPACE] = map[string]string{currentTimeStamp: fmt.Sprintf("%v", rbdStat.Used)}
metrics[metric_name+skyring_monitoring.TOTAL_SPACE] = map[string]string{currentTimeStamp: fmt.Sprintf("%v", rbdStat.Total)}
metrics[metric_name+skyring_monitoring.PERCENT_USED] = map[string]string{currentTimeStamp: fmt.Sprintf("%v", percent_used)}
}
rbdStats = append(rbdStats, statistics)
}
return metrics, rbdStats, fmt.Errorf("%v", err_str)
}
func PopulateClusterStatus(bootstrapNode string, clusterId uuid.UUID, ctxt string) error {
out, err := cephapi_backend.GetClusterStatus(bootstrapNode, clusterId, "", ctxt)
if err != nil {
return fmt.Errorf(
"%s-Error getting status of cluster: %v. error: %v",
ctxt,
clusterId,
err)
}
var status models.ClusterStatus
if val, ok := cluster_status_map[out]; ok {
status = val
} else {
status = models.CLUSTER_STATUS_UNKNOWN
}
// Update the status of the cluster
sessionCopy := db.GetDatastore().Copy()
defer sessionCopy.Close()
coll := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_STORAGE_CLUSTERS)
if err := coll.Update(
bson.M{"clusterid": clusterId},
bson.M{"$set": bson.M{"status": status}}); err != nil {
return fmt.Errorf(
"%s-Failed updating the status of cluster: %v. error: %v",
ctxt,
clusterId,
err)
}
return nil
}
func (a *App) About(w http.ResponseWriter, r *http.Request) {
ctxt, err := GetContext(r)
if err != nil {
logger.Get().Error("Error Getting the context. error: %v", err)
}
var syscapabilities conf.SystemCapabilities
sessionCopy := db.GetDatastore().Copy()
defer sessionCopy.Close()
coll := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_SYSTEM_CAPABILITIES)
if err := coll.Find(nil).One(&syscapabilities); err != nil {
HttpResponse(w, http.StatusBadRequest, fmt.Sprintf("Error in retrieving System Capabilities detail. error: %v", err))
logger.Get().Error("%s-Error in retrieving System Capabilities detail. error: %v", ctxt, err)
return
}
storage_provider_details := make(map[string]string)
for key, val := range syscapabilities.StorageProviderDetails {
storage_provider_details[strings.Title(key)] = val
delete(syscapabilities.StorageProviderDetails, key)
}
syscapabilities.StorageProviderDetails = storage_provider_details
if err := json.NewEncoder(w).Encode(syscapabilities); err != nil {
logger.Get().Error("%s-Error encoding data: %v", ctxt, err)
HttpResponse(w, http.StatusInternalServerError, err.Error())
}
}
func PopulateClusterDetails(bootstrapNode string, ctxt string) (*uuid.UUID, string, error) {
out, err := cephapi_backend.GetCluster(bootstrapNode, ctxt)
if err != nil {
return nil, "", fmt.Errorf("%s-Error getting cluster details. error: %v", ctxt, err)
}
var cluster models.Cluster = models.Cluster{
ClusterId: out.Id,
Name: out.Name,
Type: bigfin_conf.ProviderName,
}
cluster.MonitoringInterval = monitoring.DefaultClusterMonitoringInterval
cluster.Monitoring = models.MonitoringState{
Plugins: utils.GetProviderSpecificDefaultThresholdValues(),
StaleNodes: []string{},
}
cluster.CompatVersion = fmt.Sprintf("%f", bigfin_conf.ProviderConfig.Provider.CompatVersion)
cluster.AutoExpand = true
// Persist the cluster details
sessionCopy := db.GetDatastore().Copy()
defer sessionCopy.Close()
coll := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_STORAGE_CLUSTERS)
if err := coll.Insert(cluster); err != nil {
return nil, "", fmt.Errorf("%s-Error persisting the cluster. error: %v", ctxt, err)
}
return &out.Id, out.Name, nil
}
func NewLdapAuthProvider(config io.Reader) (*Authorizer, error) {
if config == nil {
errStr := "missing configuration file for Ldap Auth provider"
logger.Get().Error(errStr)
return nil, fmt.Errorf(errStr)
}
userDao := skyring.GetDbProvider().UserInterface()
session := db.GetDatastore()
c := session.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_LDAP)
ldapDao := models.Directory{}
err := c.Find(bson.M{}).One(&ldapDao)
if err != nil {
logger.Get().Info("Failed to open ldap db collection:%s", err)
}
//Create the Provider
if provider, err := NewAuthorizer(userDao, ldapDao); err != nil {
logger.Get().Error("Unable to initialize the authorizer for Ldapauthprovider. error: %v", err)
panic(err)
} else {
return &provider, nil
}
}
func (a *App) getSubTasks(rw http.ResponseWriter, req *http.Request) {
ctxt, err := GetContext(req)
if err != nil {
logger.Get().Error("Error Getting the context. error: %v", err)
}
vars := mux.Vars(req)
taskId, err := uuid.Parse(vars["taskid"])
if err != nil {
logger.Get().Error("%s-Unable to Parse the Id: %s. error: %v", ctxt, vars["taskId"], err)
rw.WriteHeader(http.StatusBadRequest)
bytes, _ := json.Marshal(APIError{Error: err.Error()})
rw.Write(bytes)
return
}
sessionCopy := db.GetDatastore().Copy()
defer sessionCopy.Close()
coll := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_TASKS)
var tasks []models.AppTask
if err := coll.Find(bson.M{"parentid": *taskId}).All(&tasks); err != nil {
logger.Get().Error("%s-Unable to get tasks. error: %v", ctxt, err)
if err == mgo.ErrNotFound {
HttpResponse(rw, http.StatusNotFound, err.Error())
} else {
HttpResponse(rw, http.StatusInternalServerError, err.Error())
}
return
}
if len(tasks) == 0 {
json.NewEncoder(rw).Encode([]models.AppTask{})
} else {
json.NewEncoder(rw).Encode(tasks)
}
}
func PopulateClusterNetworkDetails(bootstrapNode string, clusterId uuid.UUID, ctxt string) error {
out, err := cephapi_backend.GetClusterNetworks(bootstrapNode, clusterId, ctxt)
if err != nil {
return fmt.Errorf(
"%s-Error getting network details of cluster: %v. error: %v",
ctxt,
clusterId,
err)
}
// Update the cluster network details
sessionCopy := db.GetDatastore().Copy()
defer sessionCopy.Close()
coll := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_STORAGE_CLUSTERS)
if err := coll.Update(
bson.M{"clusterid": clusterId},
bson.M{"$set": bson.M{
"networks.public": out.Public,
"networks.cluster": out.Cluster}}); err != nil {
return fmt.Errorf(
"%s-Error updating network details for cluster: %v. error: %v",
ctxt,
clusterId,
err)
}
return nil
}
func SyncNodeUtilizations(params map[string]interface{}) {
ctxt, ctxtOk := params["ctxt"].(string)
if !ctxtOk {
logger.Get().Error("Failed to fetch context")
return
}
sessionCopy := db.GetDatastore().Copy()
defer sessionCopy.Close()
coll := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_STORAGE_NODES)
var nodes []models.Node
if err := coll.Find(bson.M{"state": models.NODE_STATE_ACTIVE}).All(&nodes); err != nil {
if err == mgo.ErrNotFound {
return
}
logger.Get().Warning("%s - Failed to fetch nodes in active state.Error %v", ctxt, err)
}
time_stamp_str := strconv.FormatInt(time.Now().Unix(), 10)
var nodeNames []string
for _, node := range nodes {
if node.State == models.NODE_STATE_ACTIVE {
nodeNames = append(nodeNames, node.Hostname)
}
}
if len(nodeNames) == 0 {
return
}
for _, node := range nodes {
go SyncNodeUtilization(ctxt, node, time_stamp_str)
}
go ComputeSystemSummary(make(map[string]interface{}))
}
func checkAndUpdateAutoExpand(t *task.Task, clusterId uuid.UUID, ctxt string) {
sessionCopy := db.GetDatastore().Copy()
defer sessionCopy.Close()
coll := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_STORAGE_LOGICAL_UNITS)
var slus []models.StorageLogicalUnit
if err := coll.Find(bson.M{"clusterid": clusterId}).All(&slus); err != nil {
logger.Get().Error(
"%s-Error getting SLUs of cluster: %v for colocation check. error: %v",
ctxt,
clusterId,
err)
return
}
for _, slu := range slus {
journalDet := slu.Options["journal"].(map[string]interface{})
if slu.Options["device"] == journalDet["journaldisk"].(string) {
coll1 := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_STORAGE_CLUSTERS)
if err := coll1.Update(
bson.M{"clusterid": clusterId},
bson.M{"$set": bson.M{"autoexpand": false}}); err != nil {
logger.Get().Error(
"%s-Error setting autoexpand flag for cluster: %v. error: %v",
ctxt,
clusterId,
err)
return
}
t.UpdateStatus("Disabled auto expand for cluster")
break
}
}
return
}
func sync_cluster_status(ctxt string, cluster models.Cluster, provider *Provider) (bool, error) {
var result models.RpcResponse
vars := make(map[string]string)
vars["cluster-id"] = cluster.ClusterId.String()
err = provider.Client.Call(
fmt.Sprintf("%s.%s", provider.Name, sync_functions["cluster_status"]),
models.RpcRequest{RpcRequestVars: vars, RpcRequestData: []byte{}, RpcRequestContext: ctxt},
&result)
if err != nil || result.Status.StatusCode != http.StatusOK {
logger.Get().Error("%s-Error getting status for cluster: %s. error:%v", ctxt, cluster.Name, err)
return false, err
}
clusterStatus, err := strconv.Atoi(string(result.Data.Result))
if err != nil {
logger.Get().Error("%s-Error getting status for cluster: %s. error:%v", ctxt, cluster.Name, err)
return false, err
}
// Set the cluster status
sessionCopy := db.GetDatastore().Copy()
defer sessionCopy.Close()
coll := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_STORAGE_CLUSTERS)
logger.Get().Info("%s-Updating the status of the cluster: %s to %d", ctxt, cluster.Name, clusterStatus)
if err := coll.Update(bson.M{"clusterid": cluster.ClusterId}, bson.M{"$set": bson.M{"status": clusterStatus}}); err != nil {
logger.Get().Error("%s-Error updating status for cluster: %s. error:%v", ctxt, cluster.Name, err)
return false, err
}
return true, nil
}
func AuditLog(ctxt string, event models.AppEvent, dbprovider dbprovider.DbInterface) error {
sessionCopy := db.GetDatastore().Copy()
defer sessionCopy.Close()
if event.ClusterName == "" {
coll := sessionCopy.DB(
conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_STORAGE_CLUSTERS)
var cluster models.Cluster
if err := coll.Find(bson.M{"clusterid": event.ClusterId}).One(&cluster); err == nil {
event.ClusterName = cluster.Name
}
}
event.Context = ctxt
if event.Notify {
subject, body, err := getMailDetails(event)
if err != nil {
logger.Get().Error("%s-Could not get mail details for event: %s", ctxt, event.Name)
} else {
if err = notifier.MailNotify(subject, body, dbprovider, ctxt); err == nil {
event.Notified = true
} else {
logger.Get().Error("%s-Could not send mail for event: %s", ctxt, event.Name)
}
}
}
coll := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_APP_EVENTS)
if err := coll.Insert(event); err != nil {
logger.Get().Error("%s-Error adding the app event: %v", ctxt, err)
return err
}
return nil
}
func (a *App) GET_ClusterBlockDevices(w http.ResponseWriter, r *http.Request) {
ctxt, err := GetContext(r)
if err != nil {
logger.Get().Error("Error Getting the context. error: %v", err)
}
vars := mux.Vars(r)
cluster_id_str := vars["cluster-id"]
cluster_id, err := uuid.Parse(cluster_id_str)
if err != nil {
logger.Get().Error("%s - Error parsing the cluster id: %s. error: %v", ctxt, cluster_id_str, err)
HttpResponse(w, http.StatusBadRequest, fmt.Sprintf("Error parsing the cluster id: %s", cluster_id_str))
return
}
sessionCopy := db.GetDatastore().Copy()
defer sessionCopy.Close()
collection := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_BLOCK_DEVICES)
var blkDevices []models.BlockDevice
if err := collection.Find(bson.M{"clusterid": *cluster_id}).All(&blkDevices); err != nil {
if err == mgo.ErrNotFound {
HttpResponse(w, http.StatusNotFound, err.Error())
} else {
HttpResponse(w, http.StatusInternalServerError, err.Error())
}
logger.Get().Error("%s - Error getting the block devices list for cluster: %v. error: %v", ctxt, *cluster_id, err)
return
}
if len(blkDevices) == 0 {
json.NewEncoder(w).Encode([]models.BlockDevice{})
} else {
json.NewEncoder(w).Encode(blkDevices)
}
}
// RULES FOR DERIVING THE PG NUM
// if no of osds <= 5 then
// no of PGs = 128
// if no of osds > 5 and <= 10 then
// no of PGs = 512
// if no of osds > 10 and <= 50 then
// no of PGs = 4096
// if no of osds > 50 then
// no of PGs = (Avg Target PGs per OSD * No of OSDs * Data Percentage) / Replica Count
// -- where
// Data Percentage = Target Allocation Size / Max Allocation Size
// -- where
// Target Allocation Size - provided in request
// Max Allocation Size = ((Average OSD Size * No of OSDs) / Replica Count) * Max Utilization Factor
// -- where Max Utilization Factor is set as 0.8
// Finally round this value of next 2's power
func DerivePgNum(clusterId uuid.UUID, size string, replicaCount int, profile string) uint {
// Get the no of OSDs in the cluster
sessionCopy := db.GetDatastore().Copy()
defer sessionCopy.Close()
coll := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_STORAGE_LOGICAL_UNITS)
var slus []models.StorageLogicalUnit
if err := coll.Find(bson.M{"clusterid": clusterId, "type": models.CEPH_OSD, "storageprofile": profile}).All(&slus); err != nil {
return uint(DEFAULT_PG_NUM)
}
osdsNum := len(slus)
// Calculate the pgnum value
if osdsNum <= 5 {
return uint(DEFAULT_PG_NUM)
}
if osdsNum <= 10 {
return uint(512)
}
if osdsNum <= 50 {
return uint(4096)
}
avgOsdSize := avg_osd_size(slus) / 1024
maxAllocSize := (avgOsdSize * float64(len(slus)) / float64(replicaCount)) * float64(MAX_UTILIZATION_PCNT) / 100
pcntData := float64(utils.SizeFromStr(size)) / float64(maxAllocSize)
pgnum := float64(float64(TARGET_PGS_PER_OSD)*float64(len(slus))*pcntData) / float64(replicaCount)
derivedPgNum := utils.NextTwosPower(uint(pgnum))
if derivedPgNum < uint(osdsNum) {
// Consider next 2's power value
newPgNum := osdsNum / replicaCount
derivedPgNum = utils.NextTwosPower(uint(newPgNum))
}
return derivedPgNum
}
func GetEventById(w http.ResponseWriter, r *http.Request) {
ctxt, err := GetContext(r)
if err != nil {
logger.Get().Error("Error Getting the context. error: %v", err)
}
vars := mux.Vars(r)
event_id_str := vars["event-id"]
event_id, err := uuid.Parse(event_id_str)
if err != nil {
logger.Get().Error("%s-Error parsing event id: %s", ctxt, event_id_str)
HttpResponse(w, http.StatusBadRequest, fmt.Sprintf("Error parsing event id: %s", event_id_str))
return
}
sessionCopy := db.GetDatastore().Copy()
defer sessionCopy.Close()
collection := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_APP_EVENTS)
var event models.AppEvent
if err := collection.Find(bson.M{"eventid": *event_id}).One(&event); err == mgo.ErrNotFound {
HttpResponse(w, http.StatusNotFound, "Event not found")
logger.Get().Error("%s-Event: %v not found. error: %v", ctxt, *event_id, err)
return
} else if err != nil {
logger.Get().Error("%s-Error getting the event detail for %v. error: %v", ctxt, *event_id, err)
HttpResponse(w, http.StatusBadRequest, "Event finding the record")
return
} else {
json.NewEncoder(w).Encode(event)
}
}
func GetSystem() (system models.System, err error) {
sessionCopy := db.GetDatastore().Copy()
defer sessionCopy.Close()
collection := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_SKYRING_UTILIZATION)
err = collection.Find(nil).One(&system)
return system, err
}
func fetchThresholdEvents(selectCriteria bson.M, utilizationType string) ([]models.ThresholdEvent, error) {
var tEventsInDb []models.ThresholdEvent
sessionCopy := db.GetDatastore().Copy()
defer sessionCopy.Close()
coll := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_THRESHOLD_BREACHES)
err := coll.Find(selectCriteria).All(&tEventsInDb)
return tEventsInDb, err
}
func GetClusters() (models.Clusters, error) {
sessionCopy := db.GetDatastore().Copy()
defer sessionCopy.Close()
collection := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_STORAGE_CLUSTERS)
var clusters models.Clusters
err := collection.Find(nil).All(&clusters)
return clusters, err
}
func GetCluster(cluster_id *uuid.UUID) (cluster models.Cluster, err error) {
sessionCopy := db.GetDatastore().Copy()
defer sessionCopy.Close()
collection := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_STORAGE_CLUSTERS)
if err := collection.Find(bson.M{"clusterid": *cluster_id}).One(&cluster); err != nil {
return cluster, err
}
return cluster, nil
}
func FailStillCreatingClusters(ctxt string) {
sessionCopy := db.GetDatastore().Copy()
defer sessionCopy.Close()
collection := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_STORAGE_CLUSTERS)
if _, err := collection.UpdateAll(bson.M{"state": models.CLUSTER_STATE_CREATING}, bson.M{"$set": bson.M{"state": models.CLUSTER_STATE_FAILED,
"status": models.CLUSTER_STATUS_ERROR}}); err != nil {
logger.Get().Debug("%s-%v", ctxt, err.Error())
}
}
func getOsds(clusterId uuid.UUID) (slus []models.StorageLogicalUnit, err error) {
sessionCopy := db.GetDatastore().Copy()
defer sessionCopy.Close()
coll := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_STORAGE_LOGICAL_UNITS)
if err := coll.Find(bson.M{"clusterid": clusterId}).Sort("name").All(&slus); err != nil {
return nil, fmt.Errorf("Error getting the slus for cluster: %v. error: %v", clusterId, err)
}
return slus, nil
}
func getEntity(clusterId uuid.UUID, resourceName string, collectionName string, entity interface{}) error {
sessionCopy := db.GetDatastore().Copy()
defer sessionCopy.Close()
collection := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(collectionName)
if err := collection.Find(bson.M{"clusterid": clusterId, "name": resourceName}).One(entity); err != nil {
return err
}
return nil
}
func UpdateDb(selectCriteria bson.M, update bson.M, collectionName string, ctxt string) {
sessionCopy := db.GetDatastore().Copy()
defer sessionCopy.Close()
coll := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(collectionName)
if err := coll.Update(selectCriteria, bson.M{"$set": update}); err != nil {
logger.Get().Error("%s - Failed to perform the update for select criteria %v and update %v. Error %v", ctxt, selectCriteria, update, err)
}
}
func getClustersByType(clusterType string) (clusters []models.Cluster, err error) {
sessionCopy := db.GetDatastore().Copy()
defer sessionCopy.Close()
collection := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_STORAGE_CLUSTERS)
if err := collection.Find(bson.M{"type": clusterType}).All(&clusters); err != nil {
return clusters, err
}
return clusters, nil
}
func GetClusterSummaries(selectCriteria bson.M) ([]models.ClusterSummary, error) {
var clustersSummary []models.ClusterSummary
sessionCopy := db.GetDatastore().Copy()
defer sessionCopy.Close()
collection := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_CLUSTER_SUMMARY)
err := collection.Find(selectCriteria).All(&clustersSummary)
return clustersSummary, err
}
func GetClusters(selectCriteria bson.M) ([]models.Cluster, error) {
var clusters []models.Cluster
sessionCopy := db.GetDatastore().Copy()
defer sessionCopy.Close()
collection := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_STORAGE_CLUSTERS)
err := collection.Find(selectCriteria).All(&clusters)
return clusters, err
}
func initializeAbout(ctxt string) {
if len(conf.SystemConfig.SysCapabilities.StorageProviderDetails) != 0 {
sessionCopy := db.GetDatastore().Copy()
defer sessionCopy.Close()
coll := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_SYSTEM_CAPABILITIES)
if _, err := coll.Upsert(bson.M{"productname": conf.SystemConfig.SysCapabilities.ProductName}, conf.SystemConfig.SysCapabilities); err != nil {
logger.Get().Error(fmt.Sprintf("%s-Error adding System_capabilities details . error: %v", ctxt, err))
}
}
}
func Update_node_state_byId(ctxt string, nodeId uuid.UUID, state models.NodeState) error {
sessionCopy := db.GetDatastore().Copy()
defer sessionCopy.Close()
coll := sessionCopy.DB(conf.SystemConfig.DBConfig.Database).C(models.COLL_NAME_STORAGE_NODES)
if err := coll.Update(bson.M{"nodeid": nodeId}, bson.M{"$set": bson.M{"state": state}}); err != nil {
logger.Get().Error("%s-Error updating the node state: %s", ctxt, err)
return err
}
return nil
}
