Exemple #1
0
//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
}
Exemple #2
0
//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}
}
Exemple #4
0
						  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,