//Run extension on sync
func runExtensionOnSync(server *Server, response *gohan_sync.Event, env extension.Environment) {
	lockKey := lockPath + response.Key
	err := server.sync.Lock(lockKey, false)
	if err != nil {
		return
	}
	defer func() {
		server.sync.Unlock(lockKey)
	}()
	tx, err := server.db.Begin()
	defer tx.Close()
	context := map[string]interface{}{
		"transaction": tx,
		"action":      response.Action,
		"data":        response.Data,
		"key":         response.Key,
	}
	if err != nil {
		return
	}
	if err := env.HandleEvent("notification", context); err != nil {
		log.Warning(fmt.Sprintf("extension error: %s", err))
		return
	}
	err = tx.Commit()
	if err != nil {
		log.Error(fmt.Sprintf("commit error : %s", err))
		return
	}
	return
}

//Run extension on sync
func runExtensionOnSync(server *Server, response *gohan_sync.Event, env extension.Environment) {
	context := map[string]interface{}{
		"action": response.Action,
		"data":   response.Data,
		"key":    response.Key,
	}
	if err := env.HandleEvent("notification", context); err != nil {
		log.Warning(fmt.Sprintf("extension error: %s", err))
		return
	}
	return
}

func handleEvent(context middleware.Context, environment extension.Environment, event string) error {
	if err := environment.HandleEvent(event, context); err != nil {
		return fmt.Errorf("extension error: %s", err)
	}
	exceptionInfoRaw, ok := context["exception"]
	if !ok {
		return nil
	}
	exceptionInfo, ok := exceptionInfoRaw.(map[string]interface{})
	if !ok {
		return fmt.Errorf("extension returned invalid error information")
	}
	exceptionMessage := context["exception_message"]
	return ExtensionError{fmt.Errorf("%v", exceptionMessage), exceptionInfo}
}

				Expect(context).To(HaveKeyWithValue("resp", HaveKeyWithValue("status", "err")))
				Expect(context).To(HaveKeyWithValue("resp", HaveKey("error")))
			})
		})
	})

	Describe("Using gohan database manipulation builtins", func() {
		var (
			adminAuth     schema.Authorization
			memberAuth    schema.Authorization
			auth          schema.Authorization
			context       middleware.Context
			schemaID      string
			path          string
			action        string
			currentSchema *schema.Schema
			extensions    []*schema.Extension
			env           extension.Environment
			events        map[string]string

			network1 map[string]interface{}
			network2 map[string]interface{}
			subnet1  map[string]interface{}
		)

		BeforeEach(func() {
			adminAuth = schema.NewAuthorization(adminTenantID, "admin", adminTokenID, []string{"admin"}, nil)
			memberAuth = schema.NewAuthorization(memberTenantID, "member", memberTokenID, []string{"_member_"}, nil)
			auth = adminAuth

			context = middleware.Context{}