Beispiel #1
0
func init() {

	gohanscript.RegisterStmtParser("split",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"value", "sep")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var value string
				ivalue := stmt.Arg("value", context)
				if ivalue != nil {
					value = ivalue.(string)
				}
				var sep string
				isep := stmt.Arg("sep", context)
				if isep != nil {
					sep = isep.(string)
				}

				result1,
					err :=
					lib.Split(
						value, sep)

				return result1, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("Split",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			value := args[0].(string)
			sep := args[1].(string)

			result1,
				err :=
				lib.Split(
					value, sep)
			return []interface{}{
				result1,
				err}

		})

	gohanscript.RegisterStmtParser("join",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"value", "sep")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var value []interface{}
				ivalue := stmt.Arg("value", context)
				if ivalue != nil {
					value = ivalue.([]interface{})
				}
				var sep string
				isep := stmt.Arg("sep", context)
				if isep != nil {
					sep = isep.(string)
				}

				result1,
					err :=
					lib.Join(
						value, sep)

				return result1, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("Join",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			value := args[0].([]interface{})
			sep := args[0].(string)

			result1,
				err :=
				lib.Join(
					value, sep)
			return []interface{}{
				result1,
				err}

		})

}
Beispiel #2
0
func init() {

	gohanscript.RegisterStmtParser("fetch_content",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var path string
				ipath := stmt.Arg("path", context)
				if ipath != nil {
					path = ipath.(string)
				}

				result1,
					err :=
					lib.FetchContent(
						path)

				return result1, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("FetchContent",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			path, _ := args[0].(string)

			result1,
				err :=
				lib.FetchContent(
					path)
			return []interface{}{
				result1,
				err}

		})

	gohanscript.RegisterStmtParser("save_content",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var path string
				ipath := stmt.Arg("path", context)
				if ipath != nil {
					path = ipath.(string)
				}
				var data interface{}
				idata := stmt.Arg("data", context)
				if idata != nil {
					data = idata.(interface{})
				}

				err :=
					lib.SaveContent(
						path, data)

				return nil, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("SaveContent",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			path, _ := args[0].(string)
			data, _ := args[0].(interface{})

			err :=
				lib.SaveContent(
					path, data)
			return []interface{}{
				err}

		})

}
Beispiel #3
0
func init() {

	gohanscript.RegisterStmtParser("http_get",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var url string
				iurl := stmt.Arg("url", context)
				if iurl != nil {
					url = iurl.(string)
				}
				var headers map[string]interface{}
				iheaders := stmt.Arg("headers", context)
				if iheaders != nil {
					headers = iheaders.(map[string]interface{})
				}

				result1,
					err :=
					lib.HTTPGet(
						url, headers)

				return result1, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("HTTPGet",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			url, _ := args[0].(string)
			headers, _ := args[0].(map[string]interface{})

			result1,
				err :=
				lib.HTTPGet(
					url, headers)
			return []interface{}{
				result1,
				err}

		})

	gohanscript.RegisterStmtParser("http_post",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var url string
				iurl := stmt.Arg("url", context)
				if iurl != nil {
					url = iurl.(string)
				}
				var headers map[string]interface{}
				iheaders := stmt.Arg("headers", context)
				if iheaders != nil {
					headers = iheaders.(map[string]interface{})
				}
				var postData map[string]interface{}
				ipostData := stmt.Arg("post_data", context)
				if ipostData != nil {
					postData = ipostData.(map[string]interface{})
				}

				result1,
					err :=
					lib.HTTPPost(
						url, headers, postData)

				return result1, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("HTTPPost",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			url, _ := args[0].(string)
			headers, _ := args[0].(map[string]interface{})
			postData, _ := args[0].(map[string]interface{})

			result1,
				err :=
				lib.HTTPPost(
					url, headers, postData)
			return []interface{}{
				result1,
				err}

		})

	gohanscript.RegisterStmtParser("http_put",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var url string
				iurl := stmt.Arg("url", context)
				if iurl != nil {
					url = iurl.(string)
				}
				var headers map[string]interface{}
				iheaders := stmt.Arg("headers", context)
				if iheaders != nil {
					headers = iheaders.(map[string]interface{})
				}
				var postData map[string]interface{}
				ipostData := stmt.Arg("post_data", context)
				if ipostData != nil {
					postData = ipostData.(map[string]interface{})
				}

				result1,
					err :=
					lib.HTTPPut(
						url, headers, postData)

				return result1, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("HTTPPut",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			url, _ := args[0].(string)
			headers, _ := args[0].(map[string]interface{})
			postData, _ := args[0].(map[string]interface{})

			result1,
				err :=
				lib.HTTPPut(
					url, headers, postData)
			return []interface{}{
				result1,
				err}

		})

	gohanscript.RegisterStmtParser("http_patch",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var url string
				iurl := stmt.Arg("url", context)
				if iurl != nil {
					url = iurl.(string)
				}
				var headers map[string]interface{}
				iheaders := stmt.Arg("headers", context)
				if iheaders != nil {
					headers = iheaders.(map[string]interface{})
				}
				var postData map[string]interface{}
				ipostData := stmt.Arg("post_data", context)
				if ipostData != nil {
					postData = ipostData.(map[string]interface{})
				}

				result1,
					err :=
					lib.HTTPPatch(
						url, headers, postData)

				return result1, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("HTTPPatch",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			url, _ := args[0].(string)
			headers, _ := args[0].(map[string]interface{})
			postData, _ := args[0].(map[string]interface{})

			result1,
				err :=
				lib.HTTPPatch(
					url, headers, postData)
			return []interface{}{
				result1,
				err}

		})

	gohanscript.RegisterStmtParser("http_delete",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var url string
				iurl := stmt.Arg("url", context)
				if iurl != nil {
					url = iurl.(string)
				}
				var headers map[string]interface{}
				iheaders := stmt.Arg("headers", context)
				if iheaders != nil {
					headers = iheaders.(map[string]interface{})
				}

				result1,
					err :=
					lib.HTTPDelete(
						url, headers)

				return result1, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("HTTPDelete",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			url, _ := args[0].(string)
			headers, _ := args[0].(map[string]interface{})

			result1,
				err :=
				lib.HTTPDelete(
					url, headers)
			return []interface{}{
				result1,
				err}

		})

	gohanscript.RegisterStmtParser("http_request",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var url string
				iurl := stmt.Arg("url", context)
				if iurl != nil {
					url = iurl.(string)
				}
				var method string
				imethod := stmt.Arg("method", context)
				if imethod != nil {
					method = imethod.(string)
				}
				var headers map[string]interface{}
				iheaders := stmt.Arg("headers", context)
				if iheaders != nil {
					headers = iheaders.(map[string]interface{})
				}
				var postData map[string]interface{}
				ipostData := stmt.Arg("post_data", context)
				if ipostData != nil {
					postData = ipostData.(map[string]interface{})
				}

				result1,
					err :=
					lib.HTTPRequest(
						url, method, headers, postData)

				return result1, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("HTTPRequest",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			url, _ := args[0].(string)
			method, _ := args[0].(string)
			headers, _ := args[0].(map[string]interface{})
			postData, _ := args[0].(map[string]interface{})

			result1,
				err :=
				lib.HTTPRequest(
					url, method, headers, postData)
			return []interface{}{
				result1,
				err}

		})

}
Beispiel #4
0
func init() {

	gohanscript.RegisterStmtParser("make_queue",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"workers")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var workers int
				iworkers := stmt.Arg("workers", context)
				if iworkers != nil {
					workers = iworkers.(int)
				}

				result1 :=
					lib.MakeQueue(
						workers)

				return result1, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("MakeQueue",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			workers := args[0].(int)

			result1 :=
				lib.MakeQueue(
					workers)
			return []interface{}{
				result1}

		})

	gohanscript.RegisterStmtParser("wait_queue",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"queue")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var queue *job.Queue
				iqueue := stmt.Arg("queue", context)
				if iqueue != nil {
					queue = iqueue.(*job.Queue)
				}

				lib.WaitQueue(
					queue)
				return nil, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("WaitQueue",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			queue := args[0].(*job.Queue)

			lib.WaitQueue(
				queue)
			return nil

		})

	gohanscript.RegisterStmtParser("stop",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"queue")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var queue *job.Queue
				iqueue := stmt.Arg("queue", context)
				if iqueue != nil {
					queue = iqueue.(*job.Queue)
				}

				lib.Stop(
					queue)
				return nil, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("Stop",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			queue := args[0].(*job.Queue)

			lib.Stop(
				queue)
			return nil

		})

	gohanscript.RegisterStmtParser("force_stop",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"queue")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var queue *job.Queue
				iqueue := stmt.Arg("queue", context)
				if iqueue != nil {
					queue = iqueue.(*job.Queue)
				}

				lib.ForceStop(
					queue)
				return nil, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("ForceStop",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			queue := args[0].(*job.Queue)

			lib.ForceStop(
				queue)
			return nil

		})

}
Beispiel #5
0
func init() {

	gohanscript.RegisterStmtParser("make_map",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				result1 :=
					lib.MakeMap()

				return result1, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("MakeMap",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			result1 :=
				lib.MakeMap()
			return []interface{}{
				result1}

		})

	gohanscript.RegisterStmtParser("map_set",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var m cmap.ConcurrentMap
				im := stmt.Arg("m", context)
				if im != nil {
					m = im.(cmap.ConcurrentMap)
				}
				var key string
				ikey := stmt.Arg("key", context)
				if ikey != nil {
					key = ikey.(string)
				}
				var value interface{}
				ivalue := stmt.Arg("value", context)
				if ivalue != nil {
					value = ivalue.(interface{})
				}

				lib.MapSet(
					m, key, value)
				return nil, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("MapSet",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			m, _ := args[0].(cmap.ConcurrentMap)
			key, _ := args[0].(string)
			value, _ := args[0].(interface{})

			lib.MapSet(
				m, key, value)
			return nil

		})

	gohanscript.RegisterStmtParser("map_get",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var m cmap.ConcurrentMap
				im := stmt.Arg("m", context)
				if im != nil {
					m = im.(cmap.ConcurrentMap)
				}
				var key string
				ikey := stmt.Arg("key", context)
				if ikey != nil {
					key = ikey.(string)
				}

				result1 :=
					lib.MapGet(
						m, key)

				return result1, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("MapGet",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			m, _ := args[0].(cmap.ConcurrentMap)
			key, _ := args[0].(string)

			result1 :=
				lib.MapGet(
					m, key)
			return []interface{}{
				result1}

		})

	gohanscript.RegisterStmtParser("map_has",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var m cmap.ConcurrentMap
				im := stmt.Arg("m", context)
				if im != nil {
					m = im.(cmap.ConcurrentMap)
				}
				var key string
				ikey := stmt.Arg("key", context)
				if ikey != nil {
					key = ikey.(string)
				}

				result1 :=
					lib.MapHas(
						m, key)

				return result1, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("MapHas",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			m, _ := args[0].(cmap.ConcurrentMap)
			key, _ := args[0].(string)

			result1 :=
				lib.MapHas(
					m, key)
			return []interface{}{
				result1}

		})

	gohanscript.RegisterStmtParser("map_remove",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var m cmap.ConcurrentMap
				im := stmt.Arg("m", context)
				if im != nil {
					m = im.(cmap.ConcurrentMap)
				}
				var key string
				ikey := stmt.Arg("key", context)
				if ikey != nil {
					key = ikey.(string)
				}

				lib.MapRemove(
					m, key)
				return nil, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("MapRemove",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			m, _ := args[0].(cmap.ConcurrentMap)
			key, _ := args[0].(string)

			lib.MapRemove(
				m, key)
			return nil

		})

	gohanscript.RegisterStmtParser("make_counter",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var value int
				ivalue := stmt.Arg("value", context)
				if ivalue != nil {
					value = ivalue.(int)
				}

				result1 :=
					lib.MakeCounter(
						value)

				return result1, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("MakeCounter",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			value, _ := args[0].(int)

			result1 :=
				lib.MakeCounter(
					value)
			return []interface{}{
				result1}

		})

	gohanscript.RegisterStmtParser("counter_add",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var counter *util.Counter
				icounter := stmt.Arg("counter", context)
				if icounter != nil {
					counter = icounter.(*util.Counter)
				}
				var value int
				ivalue := stmt.Arg("value", context)
				if ivalue != nil {
					value = ivalue.(int)
				}

				lib.CounterAdd(
					counter, value)
				return nil, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("CounterAdd",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			counter, _ := args[0].(*util.Counter)
			value, _ := args[0].(int)

			lib.CounterAdd(
				counter, value)
			return nil

		})

	gohanscript.RegisterStmtParser("counter_value",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var counter *util.Counter
				icounter := stmt.Arg("counter", context)
				if icounter != nil {
					counter = icounter.(*util.Counter)
				}

				result1 :=
					lib.CounterValue(
						counter)

				return result1, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("CounterValue",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			counter, _ := args[0].(*util.Counter)

			result1 :=
				lib.CounterValue(
					counter)
			return []interface{}{
				result1}

		})

}
Beispiel #6
0
func init() {

	gohanscript.RegisterStmtParser("uuid",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				result1 :=
					lib.UUID()

				return result1, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("UUID",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			result1 :=
				lib.UUID()
			return []interface{}{
				result1}

		})

	gohanscript.RegisterStmtParser("format_uuid",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var uuid string
				iuuid := stmt.Arg("uuid", context)
				if iuuid != nil {
					uuid = iuuid.(string)
				}

				result1,
					err :=
					lib.FormatUUID(
						uuid)

				return result1, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("FormatUUID",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			uuid, _ := args[0].(string)

			result1,
				err :=
				lib.FormatUUID(
					uuid)
			return []interface{}{
				result1,
				err}

		})

	gohanscript.RegisterStmtParser("env",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				result1 :=
					lib.Env()

				return result1, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("Env",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			result1 :=
				lib.Env()
			return []interface{}{
				result1}

		})

	gohanscript.RegisterStmtParser("normalize_map",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var data map[string]interface{}
				idata := stmt.Arg("data", context)
				if idata != nil {
					data = idata.(map[string]interface{})
				}

				result1 :=
					lib.NormalizeMap(
						data)

				return result1, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("NormalizeMap",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			data, _ := args[0].(map[string]interface{})

			result1 :=
				lib.NormalizeMap(
					data)
			return []interface{}{
				result1}

		})

}
func init() {

	gohanscript.RegisterStmtParser("get_test_server_url",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"server")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var server *httptest.Server
				iserver := stmt.Arg("server", context)
				if iserver != nil {
					server = iserver.(*httptest.Server)
				}

				result1 :=
					lib.GetTestServerURL(
						server)

				return result1, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("GetTestServerURL",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			server := args[0].(*httptest.Server)

			result1 :=
				lib.GetTestServerURL(
					server)
			return []interface{}{
				result1}

		})

	gohanscript.RegisterStmtParser("stop_test_server",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"server")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var server *httptest.Server
				iserver := stmt.Arg("server", context)
				if iserver != nil {
					server = iserver.(*httptest.Server)
				}

				lib.StopTestServer(
					server)
				return nil, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("StopTestServer",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			server := args[0].(*httptest.Server)

			lib.StopTestServer(
				server)
			return nil

		})

	gohanscript.RegisterStmtParser("gohan_server",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"config_file", "test")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var configFile string
				iconfigFile := stmt.Arg("config_file", context)
				if iconfigFile != nil {
					configFile = iconfigFile.(string)
				}
				var test bool
				itest := stmt.Arg("test", context)
				if itest != nil {
					test = itest.(bool)
				}

				result1,
					err :=
					lib.GohanServer(
						configFile, test)

				return result1, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("GohanServer",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			configFile := args[0].(string)
			test := args[0].(bool)

			result1,
				err :=
				lib.GohanServer(
					configFile, test)
			return []interface{}{
				result1,
				err}

		})

}
Beispiel #8
0
func init() {

	gohanscript.RegisterStmtParser("gohan_schema",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var schemaID string
				ischemaID := stmt.Arg("schema_id", context)
				if ischemaID != nil {
					schemaID = ischemaID.(string)
				}

				result1,
					err :=
					lib.GohanSchema(
						schemaID)

				return result1, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("GohanSchema",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			schemaID, _ := args[0].(string)

			result1,
				err :=
				lib.GohanSchema(
					schemaID)
			return []interface{}{
				result1,
				err}

		})

	gohanscript.RegisterStmtParser("gohan_schemas",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				result1 :=
					lib.GohanSchemas()

				return result1, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("GohanSchemas",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			result1 :=
				lib.GohanSchemas()
			return []interface{}{
				result1}

		})

	gohanscript.RegisterStmtParser("gohan_policies",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				result1 :=
					lib.GohanPolicies()

				return result1, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("GohanPolicies",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			result1 :=
				lib.GohanPolicies()
			return []interface{}{
				result1}

		})

	gohanscript.RegisterStmtParser("read_config",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var path string
				ipath := stmt.Arg("path", context)
				if ipath != nil {
					path = ipath.(string)
				}

				err :=
					lib.ReadConfig(
						path)

				return nil, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("ReadConfig",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			path, _ := args[0].(string)

			err :=
				lib.ReadConfig(
					path)
			return []interface{}{
				err}

		})

	gohanscript.RegisterStmtParser("get_config",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var key string
				ikey := stmt.Arg("key", context)
				if ikey != nil {
					key = ikey.(string)
				}
				var defaultValue interface{}
				idefaultValue := stmt.Arg("default_value", context)
				if idefaultValue != nil {
					defaultValue = idefaultValue.(interface{})
				}

				result1 :=
					lib.GetConfig(
						key, defaultValue)

				return result1, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("GetConfig",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			key, _ := args[0].(string)
			defaultValue, _ := args[0].(interface{})

			result1 :=
				lib.GetConfig(
					key, defaultValue)
			return []interface{}{
				result1}

		})

	gohanscript.RegisterStmtParser("gohan_load_schema",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var src string
				isrc := stmt.Arg("src", context)
				if isrc != nil {
					src = isrc.(string)
				}

				result1,
					err :=
					lib.GohanLoadSchema(
						src)

				return result1, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("GohanLoadSchema",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			src, _ := args[0].(string)

			result1,
				err :=
				lib.GohanLoadSchema(
					src)
			return []interface{}{
				result1,
				err}

		})

	gohanscript.RegisterStmtParser("connect_db",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var dbType string
				idbType := stmt.Arg("db_type", context)
				if idbType != nil {
					dbType = idbType.(string)
				}
				var connection string
				iconnection := stmt.Arg("connection", context)
				if iconnection != nil {
					connection = iconnection.(string)
				}
				var maxOpenConn int
				imaxOpenConn := stmt.Arg("max_open_conn", context)
				if imaxOpenConn != nil {
					maxOpenConn = imaxOpenConn.(int)
				}

				result1,
					err :=
					lib.ConnectDB(
						dbType, connection, maxOpenConn)

				return result1, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("ConnectDB",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			dbType, _ := args[0].(string)
			connection, _ := args[0].(string)
			maxOpenConn, _ := args[0].(int)

			result1,
				err :=
				lib.ConnectDB(
					dbType, connection, maxOpenConn)
			return []interface{}{
				result1,
				err}

		})

	gohanscript.RegisterStmtParser("init_db",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var dbType string
				idbType := stmt.Arg("db_type", context)
				if idbType != nil {
					dbType = idbType.(string)
				}
				var connection string
				iconnection := stmt.Arg("connection", context)
				if iconnection != nil {
					connection = iconnection.(string)
				}
				var dropOnCreate bool
				idropOnCreate := stmt.Arg("drop_on_create", context)
				if idropOnCreate != nil {
					dropOnCreate = idropOnCreate.(bool)
				}
				var cascade bool
				icascade := stmt.Arg("cascade", context)
				if icascade != nil {
					cascade = icascade.(bool)
				}

				err :=
					lib.InitDB(
						dbType, connection, dropOnCreate, cascade)

				return nil, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("InitDB",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			dbType, _ := args[0].(string)
			connection, _ := args[0].(string)
			dropOnCreate, _ := args[0].(bool)
			cascade, _ := args[0].(bool)

			err :=
				lib.InitDB(
					dbType, connection, dropOnCreate, cascade)
			return []interface{}{
				err}

		})

	gohanscript.RegisterStmtParser("db_begin",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var connection db.DB
				iconnection := stmt.Arg("connection", context)
				if iconnection != nil {
					connection = iconnection.(db.DB)
				}

				result1,
					err :=
					lib.DBBegin(
						connection)

				return result1, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("DBBegin",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			connection, _ := args[0].(db.DB)

			result1,
				err :=
				lib.DBBegin(
					connection)
			return []interface{}{
				result1,
				err}

		})

	gohanscript.RegisterStmtParser("db_commit",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var tx transaction.Transaction
				itx := stmt.Arg("tx", context)
				if itx != nil {
					tx = itx.(transaction.Transaction)
				}

				err :=
					lib.DBCommit(
						tx)

				return nil, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("DBCommit",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			tx, _ := args[0].(transaction.Transaction)

			err :=
				lib.DBCommit(
					tx)
			return []interface{}{
				err}

		})

	gohanscript.RegisterStmtParser("db_close",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var tx transaction.Transaction
				itx := stmt.Arg("tx", context)
				if itx != nil {
					tx = itx.(transaction.Transaction)
				}

				err :=
					lib.DBClose(
						tx)

				return nil, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("DBClose",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			tx, _ := args[0].(transaction.Transaction)

			err :=
				lib.DBClose(
					tx)
			return []interface{}{
				err}

		})

	gohanscript.RegisterStmtParser("db_get",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var tx transaction.Transaction
				itx := stmt.Arg("tx", context)
				if itx != nil {
					tx = itx.(transaction.Transaction)
				}
				var schemaID string
				ischemaID := stmt.Arg("schema_id", context)
				if ischemaID != nil {
					schemaID = ischemaID.(string)
				}
				var id string
				iid := stmt.Arg("id", context)
				if iid != nil {
					id = iid.(string)
				}
				var tenantID string
				itenantID := stmt.Arg("tenant_id", context)
				if itenantID != nil {
					tenantID = itenantID.(string)
				}

				result1,
					err :=
					lib.DBGet(
						tx, schemaID, id, tenantID)

				return result1, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("DBGet",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			tx, _ := args[0].(transaction.Transaction)
			schemaID, _ := args[0].(string)
			id, _ := args[0].(string)
			tenantID, _ := args[0].(string)

			result1,
				err :=
				lib.DBGet(
					tx, schemaID, id, tenantID)
			return []interface{}{
				result1,
				err}

		})

	gohanscript.RegisterStmtParser("db_create",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var tx transaction.Transaction
				itx := stmt.Arg("tx", context)
				if itx != nil {
					tx = itx.(transaction.Transaction)
				}
				var schemaID string
				ischemaID := stmt.Arg("schema_id", context)
				if ischemaID != nil {
					schemaID = ischemaID.(string)
				}
				var data map[string]interface{}
				idata := stmt.Arg("data", context)
				if idata != nil {
					data = idata.(map[string]interface{})
				}

				err :=
					lib.DBCreate(
						tx, schemaID, data)

				return nil, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("DBCreate",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			tx, _ := args[0].(transaction.Transaction)
			schemaID, _ := args[0].(string)
			data, _ := args[0].(map[string]interface{})

			err :=
				lib.DBCreate(
					tx, schemaID, data)
			return []interface{}{
				err}

		})

	gohanscript.RegisterStmtParser("db_list",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var tx transaction.Transaction
				itx := stmt.Arg("tx", context)
				if itx != nil {
					tx = itx.(transaction.Transaction)
				}
				var schemaID string
				ischemaID := stmt.Arg("schema_id", context)
				if ischemaID != nil {
					schemaID = ischemaID.(string)
				}
				var filter map[string]interface{}
				ifilter := stmt.Arg("filter", context)
				if ifilter != nil {
					filter = ifilter.(map[string]interface{})
				}

				result1,
					err :=
					lib.DBList(
						tx, schemaID, filter)

				return result1, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("DBList",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			tx, _ := args[0].(transaction.Transaction)
			schemaID, _ := args[0].(string)
			filter, _ := args[0].(map[string]interface{})

			result1,
				err :=
				lib.DBList(
					tx, schemaID, filter)
			return []interface{}{
				result1,
				err}

		})

	gohanscript.RegisterStmtParser("db_update",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var tx transaction.Transaction
				itx := stmt.Arg("tx", context)
				if itx != nil {
					tx = itx.(transaction.Transaction)
				}
				var schemaID string
				ischemaID := stmt.Arg("schema_id", context)
				if ischemaID != nil {
					schemaID = ischemaID.(string)
				}
				var data map[string]interface{}
				idata := stmt.Arg("data", context)
				if idata != nil {
					data = idata.(map[string]interface{})
				}

				err :=
					lib.DBUpdate(
						tx, schemaID, data)

				return nil, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("DBUpdate",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			tx, _ := args[0].(transaction.Transaction)
			schemaID, _ := args[0].(string)
			data, _ := args[0].(map[string]interface{})

			err :=
				lib.DBUpdate(
					tx, schemaID, data)
			return []interface{}{
				err}

		})

	gohanscript.RegisterStmtParser("db_delete",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var tx transaction.Transaction
				itx := stmt.Arg("tx", context)
				if itx != nil {
					tx = itx.(transaction.Transaction)
				}
				var schemaID string
				ischemaID := stmt.Arg("schema_id", context)
				if ischemaID != nil {
					schemaID = ischemaID.(string)
				}
				var id string
				iid := stmt.Arg("id", context)
				if iid != nil {
					id = iid.(string)
				}

				err :=
					lib.DBDelete(
						tx, schemaID, id)

				return nil, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("DBDelete",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			tx, _ := args[0].(transaction.Transaction)
			schemaID, _ := args[0].(string)
			id, _ := args[0].(string)

			err :=
				lib.DBDelete(
					tx, schemaID, id)
			return []interface{}{
				err}

		})

	gohanscript.RegisterStmtParser("db_query",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var tx transaction.Transaction
				itx := stmt.Arg("tx", context)
				if itx != nil {
					tx = itx.(transaction.Transaction)
				}
				var schemaID string
				ischemaID := stmt.Arg("schema_id", context)
				if ischemaID != nil {
					schemaID = ischemaID.(string)
				}
				var sql string
				isql := stmt.Arg("sql", context)
				if isql != nil {
					sql = isql.(string)
				}
				var arguments []interface{}
				iarguments := stmt.Arg("arguments", context)
				if iarguments != nil {
					arguments = iarguments.([]interface{})
				}

				result1,
					err :=
					lib.DBQuery(
						tx, schemaID, sql, arguments)

				return result1, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("DBQuery",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			tx, _ := args[0].(transaction.Transaction)
			schemaID, _ := args[0].(string)
			sql, _ := args[0].(string)
			arguments, _ := args[0].([]interface{})

			result1,
				err :=
				lib.DBQuery(
					tx, schemaID, sql, arguments)
			return []interface{}{
				result1,
				err}

		})

	gohanscript.RegisterStmtParser("db_exec",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var tx transaction.Transaction
				itx := stmt.Arg("tx", context)
				if itx != nil {
					tx = itx.(transaction.Transaction)
				}
				var sql string
				isql := stmt.Arg("sql", context)
				if isql != nil {
					sql = isql.(string)
				}
				var arguments []interface{}
				iarguments := stmt.Arg("arguments", context)
				if iarguments != nil {
					arguments = iarguments.([]interface{})
				}

				err :=
					lib.DBExec(
						tx, sql, arguments)

				return nil, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("DBExec",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			tx, _ := args[0].(transaction.Transaction)
			sql, _ := args[0].(string)
			arguments, _ := args[0].([]interface{})

			err :=
				lib.DBExec(
					tx, sql, arguments)
			return []interface{}{
				err}

		})

	gohanscript.RegisterStmtParser("db_column",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var schemaID string
				ischemaID := stmt.Arg("schema_id", context)
				if ischemaID != nil {
					schemaID = ischemaID.(string)
				}
				var join bool
				ijoin := stmt.Arg("join", context)
				if ijoin != nil {
					join = ijoin.(bool)
				}

				result1,
					err :=
					lib.DBColumn(
						schemaID, join)

				return result1, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("DBColumn",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			schemaID, _ := args[0].(string)
			join, _ := args[0].(bool)

			result1,
				err :=
				lib.DBColumn(
					schemaID, join)
			return []interface{}{
				result1,
				err}

		})

	gohanscript.RegisterStmtParser("error",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var code int
				icode := stmt.Arg("code", context)
				if icode != nil {
					code = icode.(int)
				}
				var name string
				iname := stmt.Arg("name", context)
				if iname != nil {
					name = iname.(string)
				}
				var message string
				imessage := stmt.Arg("message", context)
				if imessage != nil {
					message = imessage.(string)
				}

				err :=
					lib.Error(
						code, name, message)

				return nil, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("Error",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			code, _ := args[0].(int)
			name, _ := args[0].(string)
			message, _ := args[1].(string)

			err :=
				lib.Error(
					code, name, message)
			return []interface{}{
				err}

		})

}
Beispiel #9
0
func init() {

	gohanscript.RegisterStmtParser("ip_to_int",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"ip")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var ip string
				iip := stmt.Arg("ip", context)
				if iip != nil {
					ip = iip.(string)
				}

				result1 :=
					lib.IPToInt(
						ip)

				return result1, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("IPToInt",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			ip := args[0].(string)

			result1 :=
				lib.IPToInt(
					ip)
			return []interface{}{
				result1}

		})

	gohanscript.RegisterStmtParser("int_to_ip",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"value")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var value int
				ivalue := stmt.Arg("value", context)
				if ivalue != nil {
					value = ivalue.(int)
				}

				result1 :=
					lib.IntToIP(
						value)

				return result1, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("IntToIP",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			value := args[0].(int)

			result1 :=
				lib.IntToIP(
					value)
			return []interface{}{
				result1}

		})

	gohanscript.RegisterStmtParser("ip_add",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"ip", "value")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var ip string
				iip := stmt.Arg("ip", context)
				if iip != nil {
					ip = iip.(string)
				}
				var value int
				ivalue := stmt.Arg("value", context)
				if ivalue != nil {
					value = ivalue.(int)
				}

				result1 :=
					lib.IPAdd(
						ip, value)

				return result1, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("IPAdd",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			ip := args[0].(string)
			value := args[0].(int)

			result1 :=
				lib.IPAdd(
					ip, value)
			return []interface{}{
				result1}

		})

	gohanscript.RegisterStmtParser("parse_cidr",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"cidr")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var cidr string
				icidr := stmt.Arg("cidr", context)
				if icidr != nil {
					cidr = icidr.(string)
				}

				result1,
					result2,
					result3 :=
					lib.ParseCidr(
						cidr)

				return []interface{}{
					result1,
					result2,
					result3}, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("ParseCidr",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			cidr := args[0].(string)

			result1,
				result2,
				result3 :=
				lib.ParseCidr(
					cidr)
			return []interface{}{
				result1,
				result2,
				result3}

		})

	gohanscript.RegisterStmtParser("float_to_int",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"value")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var value float64
				ivalue := stmt.Arg("value", context)
				if ivalue != nil {
					value = ivalue.(float64)
				}

				result1 :=
					lib.FloatToInt(
						value)

				return result1, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("FloatToInt",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			value := args[0].(float64)

			result1 :=
				lib.FloatToInt(
					value)
			return []interface{}{
				result1}

		})

}
func init() {

	gohanscript.RegisterStmtParser("get_openstack_client",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"auth_url", "user_name", "password", "domain_name", "tenant_name", "version")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var authURL string
				iauthURL := stmt.Arg("auth_url", context)
				if iauthURL != nil {
					authURL = iauthURL.(string)
				}
				var userName string
				iuserName := stmt.Arg("user_name", context)
				if iuserName != nil {
					userName = iuserName.(string)
				}
				var password string
				ipassword := stmt.Arg("password", context)
				if ipassword != nil {
					password = ipassword.(string)
				}
				var domainName string
				idomainName := stmt.Arg("domain_name", context)
				if idomainName != nil {
					domainName = idomainName.(string)
				}
				var tenantName string
				itenantName := stmt.Arg("tenant_name", context)
				if itenantName != nil {
					tenantName = itenantName.(string)
				}
				var version string
				iversion := stmt.Arg("version", context)
				if iversion != nil {
					version = iversion.(string)
				}

				result1,
					err :=
					lib.GetOpenstackClient(
						authURL, userName, password, domainName, tenantName, version)

				return result1, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("GetOpenstackClient",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			authURL := args[0].(string)
			userName := args[1].(string)
			password := args[2].(string)
			domainName := args[3].(string)
			tenantName := args[4].(string)
			version := args[5].(string)

			result1,
				err :=
				lib.GetOpenstackClient(
					authURL, userName, password, domainName, tenantName, version)
			return []interface{}{
				result1,
				err}

		})

	gohanscript.RegisterStmtParser("openstack_token",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"client")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var client *gophercloud.ServiceClient
				iclient := stmt.Arg("client", context)
				if iclient != nil {
					client = iclient.(*gophercloud.ServiceClient)
				}

				result1 :=
					lib.OpenstackToken(
						client)

				return result1, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("OpenstackToken",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			client := args[0].(*gophercloud.ServiceClient)

			result1 :=
				lib.OpenstackToken(
					client)
			return []interface{}{
				result1}

		})

	gohanscript.RegisterStmtParser("openstack_get",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"client", "url")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var client *gophercloud.ServiceClient
				iclient := stmt.Arg("client", context)
				if iclient != nil {
					client = iclient.(*gophercloud.ServiceClient)
				}
				var url string
				iurl := stmt.Arg("url", context)
				if iurl != nil {
					url = iurl.(string)
				}

				result1,
					err :=
					lib.OpenstackGet(
						client, url)

				return result1, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("OpenstackGet",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			client := args[0].(*gophercloud.ServiceClient)
			url := args[0].(string)

			result1,
				err :=
				lib.OpenstackGet(
					client, url)
			return []interface{}{
				result1,
				err}

		})

	gohanscript.RegisterStmtParser("openstack_ensure",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"client", "url", "post_url", "data")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var client *gophercloud.ServiceClient
				iclient := stmt.Arg("client", context)
				if iclient != nil {
					client = iclient.(*gophercloud.ServiceClient)
				}
				var url string
				iurl := stmt.Arg("url", context)
				if iurl != nil {
					url = iurl.(string)
				}
				var postURL string
				ipostURL := stmt.Arg("post_url", context)
				if ipostURL != nil {
					postURL = ipostURL.(string)
				}
				var data interface{}
				idata := stmt.Arg("data", context)
				if idata != nil {
					data = idata.(interface{})
				}

				result1,
					err :=
					lib.OpenstackEnsure(
						client, url, postURL, data)

				return result1, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("OpenstackEnsure",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			client := args[0].(*gophercloud.ServiceClient)
			url := args[0].(string)
			postURL := args[0].(string)
			data := args[0].(interface{})

			result1,
				err :=
				lib.OpenstackEnsure(
					client, url, postURL, data)
			return []interface{}{
				result1,
				err}

		})

	gohanscript.RegisterStmtParser("openstack_put",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"client", "url", "data")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var client *gophercloud.ServiceClient
				iclient := stmt.Arg("client", context)
				if iclient != nil {
					client = iclient.(*gophercloud.ServiceClient)
				}
				var url string
				iurl := stmt.Arg("url", context)
				if iurl != nil {
					url = iurl.(string)
				}
				var data interface{}
				idata := stmt.Arg("data", context)
				if idata != nil {
					data = idata.(interface{})
				}

				result1,
					err :=
					lib.OpenstackPut(
						client, url, data)

				return result1, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("OpenstackPut",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			client := args[0].(*gophercloud.ServiceClient)
			url := args[0].(string)
			data := args[0].(interface{})

			result1,
				err :=
				lib.OpenstackPut(
					client, url, data)
			return []interface{}{
				result1,
				err}

		})

	gohanscript.RegisterStmtParser("openstack_post",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"client", "url", "data")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var client *gophercloud.ServiceClient
				iclient := stmt.Arg("client", context)
				if iclient != nil {
					client = iclient.(*gophercloud.ServiceClient)
				}
				var url string
				iurl := stmt.Arg("url", context)
				if iurl != nil {
					url = iurl.(string)
				}
				var data interface{}
				idata := stmt.Arg("data", context)
				if idata != nil {
					data = idata.(interface{})
				}

				result1,
					err :=
					lib.OpenstackPost(
						client, url, data)

				return result1, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("OpenstackPost",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			client := args[0].(*gophercloud.ServiceClient)
			url := args[0].(string)
			data := args[0].(interface{})

			result1,
				err :=
				lib.OpenstackPost(
					client, url, data)
			return []interface{}{
				result1,
				err}

		})

	gohanscript.RegisterStmtParser("openstack_delete",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"client", "url")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var client *gophercloud.ServiceClient
				iclient := stmt.Arg("client", context)
				if iclient != nil {
					client = iclient.(*gophercloud.ServiceClient)
				}
				var url string
				iurl := stmt.Arg("url", context)
				if iurl != nil {
					url = iurl.(string)
				}

				result1,
					err :=
					lib.OpenstackDelete(
						client, url)

				return result1, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("OpenstackDelete",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			client := args[0].(*gophercloud.ServiceClient)
			url := args[0].(string)

			result1,
				err :=
				lib.OpenstackDelete(
					client, url)
			return []interface{}{
				result1,
				err}

		})

	gohanscript.RegisterStmtParser("openstack_endpoint",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"client", "endpoint_type", "name", "region", "availability")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var client *gophercloud.ServiceClient
				iclient := stmt.Arg("client", context)
				if iclient != nil {
					client = iclient.(*gophercloud.ServiceClient)
				}
				var endpointType string
				iendpointType := stmt.Arg("endpoint_type", context)
				if iendpointType != nil {
					endpointType = iendpointType.(string)
				}
				var name string
				iname := stmt.Arg("name", context)
				if iname != nil {
					name = iname.(string)
				}
				var region string
				iregion := stmt.Arg("region", context)
				if iregion != nil {
					region = iregion.(string)
				}
				var availability string
				iavailability := stmt.Arg("availability", context)
				if iavailability != nil {
					availability = iavailability.(string)
				}

				result1,
					err :=
					lib.OpenstackEndpoint(
						client, endpointType, name, region, availability)

				return result1, err

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("OpenstackEndpoint",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			client := args[0].(*gophercloud.ServiceClient)
			endpointType := args[0].(string)
			name := args[1].(string)
			region := args[2].(string)
			availability := args[3].(string)

			result1,
				err :=
				lib.OpenstackEndpoint(
					client, endpointType, name, region, availability)
			return []interface{}{
				result1,
				err}

		})

}
Beispiel #11
0
func init() {

	gohanscript.RegisterStmtParser("add_int",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var a int
				ia := stmt.Arg("a", context)
				if ia != nil {
					a = ia.(int)
				}
				var b int
				ib := stmt.Arg("b", context)
				if ib != nil {
					b = ib.(int)
				}

				result1 :=
					lib.AddInt(
						a, b)

				return result1, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("AddInt",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			a, _ := args[0].(int)
			b, _ := args[1].(int)

			result1 :=
				lib.AddInt(
					a, b)
			return []interface{}{
				result1}

		})

	gohanscript.RegisterStmtParser("sub_int",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var a int
				ia := stmt.Arg("a", context)
				if ia != nil {
					a = ia.(int)
				}
				var b int
				ib := stmt.Arg("b", context)
				if ib != nil {
					b = ib.(int)
				}

				result1 :=
					lib.SubInt(
						a, b)

				return result1, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("SubInt",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			a, _ := args[0].(int)
			b, _ := args[1].(int)

			result1 :=
				lib.SubInt(
					a, b)
			return []interface{}{
				result1}

		})

	gohanscript.RegisterStmtParser("mul_int",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var a int
				ia := stmt.Arg("a", context)
				if ia != nil {
					a = ia.(int)
				}
				var b int
				ib := stmt.Arg("b", context)
				if ib != nil {
					b = ib.(int)
				}

				result1 :=
					lib.MulInt(
						a, b)

				return result1, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("MulInt",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			a, _ := args[0].(int)
			b, _ := args[1].(int)

			result1 :=
				lib.MulInt(
					a, b)
			return []interface{}{
				result1}

		})

	gohanscript.RegisterStmtParser("div_int",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			return func(context *gohanscript.Context) (interface{}, error) {

				var a int
				ia := stmt.Arg("a", context)
				if ia != nil {
					a = ia.(int)
				}
				var b int
				ib := stmt.Arg("b", context)
				if ib != nil {
					b = ib.(int)
				}

				result1 :=
					lib.DivInt(
						a, b)

				return result1, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("DivInt",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			a, _ := args[0].(int)
			b, _ := args[1].(int)

			result1 :=
				lib.DivInt(
					a, b)
			return []interface{}{
				result1}

		})

}
Beispiel #12
0
func init() {

	gohanscript.RegisterStmtParser("append",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"list", "value")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var list []interface{}
				ilist := stmt.Arg("list", context)
				if ilist != nil {
					list = ilist.([]interface{})
				}
				var value interface{}
				ivalue := stmt.Arg("value", context)
				if ivalue != nil {
					value = ivalue.(interface{})
				}

				result1 :=
					lib.Append(
						list, value)

				return result1, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("Append",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			list := args[0].([]interface{})
			value := args[0].(interface{})

			result1 :=
				lib.Append(
					list, value)
			return []interface{}{
				result1}

		})

	gohanscript.RegisterStmtParser("contains",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"list", "value")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var list []interface{}
				ilist := stmt.Arg("list", context)
				if ilist != nil {
					list = ilist.([]interface{})
				}
				var value interface{}
				ivalue := stmt.Arg("value", context)
				if ivalue != nil {
					value = ivalue.(interface{})
				}

				result1 :=
					lib.Contains(
						list, value)

				return result1, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("Contains",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			list := args[0].([]interface{})
			value := args[0].(interface{})

			result1 :=
				lib.Contains(
					list, value)
			return []interface{}{
				result1}

		})

	gohanscript.RegisterStmtParser("size",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"list")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var list []interface{}
				ilist := stmt.Arg("list", context)
				if ilist != nil {
					list = ilist.([]interface{})
				}

				result1 :=
					lib.Size(
						list)

				return result1, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("Size",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			list := args[0].([]interface{})

			result1 :=
				lib.Size(
					list)
			return []interface{}{
				result1}

		})

	gohanscript.RegisterStmtParser("shift",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"list")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var list []interface{}
				ilist := stmt.Arg("list", context)
				if ilist != nil {
					list = ilist.([]interface{})
				}

				result1,
					result2 :=
					lib.Shift(
						list)

				return []interface{}{
					result1,
					result2}, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("Shift",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			list := args[0].([]interface{})

			result1,
				result2 :=
				lib.Shift(
					list)
			return []interface{}{
				result1,
				result2}

		})

	gohanscript.RegisterStmtParser("unshift",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"list", "value")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var list []interface{}
				ilist := stmt.Arg("list", context)
				if ilist != nil {
					list = ilist.([]interface{})
				}
				var value interface{}
				ivalue := stmt.Arg("value", context)
				if ivalue != nil {
					value = ivalue.(interface{})
				}

				result1 :=
					lib.Unshift(
						list, value)

				return result1, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("Unshift",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			list := args[0].([]interface{})
			value := args[0].(interface{})

			result1 :=
				lib.Unshift(
					list, value)
			return []interface{}{
				result1}

		})

	gohanscript.RegisterStmtParser("copy",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"list")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var list []interface{}
				ilist := stmt.Arg("list", context)
				if ilist != nil {
					list = ilist.([]interface{})
				}

				result1 :=
					lib.Copy(
						list)

				return result1, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("Copy",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			list := args[0].([]interface{})

			result1 :=
				lib.Copy(
					list)
			return []interface{}{
				result1}

		})

	gohanscript.RegisterStmtParser("delete",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"list", "index")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var list []interface{}
				ilist := stmt.Arg("list", context)
				if ilist != nil {
					list = ilist.([]interface{})
				}
				var index int
				iindex := stmt.Arg("index", context)
				if iindex != nil {
					index = iindex.(int)
				}

				result1 :=
					lib.Delete(
						list, index)

				return result1, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("Delete",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			list := args[0].([]interface{})
			index := args[0].(int)

			result1 :=
				lib.Delete(
					list, index)
			return []interface{}{
				result1}

		})

	gohanscript.RegisterStmtParser("first",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"list")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var list []interface{}
				ilist := stmt.Arg("list", context)
				if ilist != nil {
					list = ilist.([]interface{})
				}

				result1 :=
					lib.First(
						list)

				return result1, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("First",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			list := args[0].([]interface{})

			result1 :=
				lib.First(
					list)
			return []interface{}{
				result1}

		})

	gohanscript.RegisterStmtParser("last",
		func(stmt *gohanscript.Stmt) (func(*gohanscript.Context) (interface{}, error), error) {
			stmtErr := stmt.HasArgs(
				"list")
			if stmtErr != nil {
				return nil, stmtErr
			}
			return func(context *gohanscript.Context) (interface{}, error) {

				var list []interface{}
				ilist := stmt.Arg("list", context)
				if ilist != nil {
					list = ilist.([]interface{})
				}

				result1 :=
					lib.Last(
						list)

				return result1, nil

			}, nil
		})
	gohanscript.RegisterMiniGoFunc("Last",
		func(vm *gohanscript.VM, args []interface{}) []interface{} {

			list := args[0].([]interface{})

			result1 :=
				lib.Last(
					list)
			return []interface{}{
				result1}

		})

}