//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}
}
context.networks = gohan_db_list(context.transaction, 'network', {});
gohan_db_delete(context.transaction, 'network', 'test1');
context.networks2 = gohan_db_list(context.transaction, 'network', {});
});`,
"path": ".*",
})
Expect(err).ToNot(HaveOccurred())
extensions := []*schema.Extension{extension}
env := otto.NewEnvironment(testDB, &middleware.FakeIdentity{})
env.LoadExtensionsForPath(extensions, "test_path")
context := map[string]interface{}{
"id": "test",
"transaction": tx,
}
Expect(env.HandleEvent("test_event", context)).To(Succeed())
Expect(context["network"]).ToNot(BeNil())
Expect(context["networks"]).ToNot(BeNil())
})
})
Context("When given no transaction", func() {
It("Correctly handles CRUD operations", func() {
tx, err := testDB.Begin()
defer tx.Commit()
extension, err := schema.NewExtension(map[string]interface{}{
"id": "test_extension",
"code": `
gohan_register_handler("test_event", function(context){
gohan_db_create(context.transaction,