func generatePath(resourcePath string, body string) string {
var curSchema = schema.GetSchemaByPath(resourcePath)
path := resourcePath
if _, ok := curSchema.SyncKeyTemplate(); ok {
var data map[string]interface{}
err := json.Unmarshal(([]byte)(body), &data)
if err != nil {
log.Error(fmt.Sprintf("Error %v during unmarshaling data %v", err, data))
} else {
path, err = curSchema.GenerateCustomPath(data)
if err != nil {
path = resourcePath
log.Error(fmt.Sprintf("%v", err))
}
}
}
path = configPrefix + path
log.Info("Generated path: %s", path)
return path
}
//MonitoringUpdate updates the state in the db based on the sync event
func MonitoringUpdate(response *gohan_sync.Event, server *Server) error {
dataStore := server.db
schemaPath := "/" + strings.TrimPrefix(response.Key, monitoringPrefix)
var curSchema = schema.GetSchemaByPath(schemaPath)
if curSchema == nil || !curSchema.StateVersioning() {
log.Debug("Monitoring update on unexpected path '%s'", schemaPath)
return nil
}
resourceID := curSchema.GetResourceIDFromPath(schemaPath)
tx, err := dataStore.Begin()
if err != nil {
return err
}
defer tx.Close()
err = tx.SetIsolationLevel(transaction.GetIsolationLevel(curSchema, MonitoringUpdateEventName))
if err != nil {
return err
}
curResource, err := tx.Fetch(curSchema, transaction.IDFilter(resourceID))
if err != nil {
return err
}
resourceState, err := tx.StateFetch(curSchema, transaction.IDFilter(resourceID))
if err != nil {
return err
}
if resourceState.ConfigVersion != resourceState.StateVersion {
return nil
}
var ok bool
monitoringVersion, ok := response.Data["version"].(float64)
if !ok {
return fmt.Errorf("No version in monitoring information")
}
if resourceState.ConfigVersion != int64(monitoringVersion) {
return nil
}
resourceState.Monitoring, ok = response.Data["monitoring"].(string)
if !ok {
return fmt.Errorf("No monitoring in monitoring information")
}
environmentManager := extension.GetManager()
environment, haveEnvironment := environmentManager.GetEnvironment(curSchema.ID)
context := map[string]interface{}{}
context["resource"] = curResource.Data()
context["schema"] = curSchema
context["monitoring"] = resourceState.Monitoring
context["transaction"] = tx
if haveEnvironment {
if err := extension.HandleEvent(context, environment, "pre_monitoring_update_in_transaction"); err != nil {
return err
}
}
err = tx.StateUpdate(curResource, &resourceState)
if err != nil {
return err
}
if haveEnvironment {
if err := extension.HandleEvent(context, environment, "post_monitoring_update_in_transaction"); err != nil {
return err
}
}
return tx.Commit()
}
//StateUpdate updates the state in the db based on the sync event
func StateUpdate(response *gohan_sync.Event, server *Server) error {
dataStore := server.db
schemaPath := "/" + strings.TrimPrefix(response.Key, statePrefix)
var curSchema = schema.GetSchemaByPath(schemaPath)
if curSchema == nil || !curSchema.StateVersioning() {
log.Debug("State update on unexpected path '%s'", schemaPath)
return nil
}
resourceID := curSchema.GetResourceIDFromPath(schemaPath)
tx, err := dataStore.Begin()
if err != nil {
return err
}
defer tx.Close()
err = tx.SetIsolationLevel(transaction.GetIsolationLevel(curSchema, StateUpdateEventName))
if err != nil {
return err
}
curResource, err := tx.Fetch(curSchema, transaction.IDFilter(resourceID))
if err != nil {
return err
}
resourceState, err := tx.StateFetch(curSchema, transaction.IDFilter(resourceID))
if err != nil {
return err
}
if resourceState.StateVersion == resourceState.ConfigVersion {
return nil
}
stateVersion, ok := response.Data["version"].(float64)
if !ok {
return fmt.Errorf("No version in state information")
}
oldStateVersion := resourceState.StateVersion
resourceState.StateVersion = int64(stateVersion)
if resourceState.StateVersion < oldStateVersion {
return nil
}
if newError, ok := response.Data["error"].(string); ok {
resourceState.Error = newError
}
if newState, ok := response.Data["state"].(string); ok {
resourceState.State = newState
}
environmentManager := extension.GetManager()
environment, haveEnvironment := environmentManager.GetEnvironment(curSchema.ID)
context := map[string]interface{}{}
if haveEnvironment {
serviceAuthorization, _ := server.keystoneIdentity.GetServiceAuthorization()
context["catalog"] = serviceAuthorization.Catalog()
context["auth_token"] = serviceAuthorization.AuthToken()
context["resource"] = curResource.Data()
context["schema"] = curSchema
context["state"] = response.Data
context["config_version"] = resourceState.ConfigVersion
context["transaction"] = tx
if err := extension.HandleEvent(context, environment, "pre_state_update_in_transaction"); err != nil {
return err
}
}
err = tx.StateUpdate(curResource, &resourceState)
if err != nil {
return err
}
if haveEnvironment {
if err := extension.HandleEvent(context, environment, "post_state_update_in_transaction"); err != nil {
return err
}
}
return tx.Commit()
}
