openwhisk

package

v0.0.0-...-39cdaa7 Latest Latest Go to latest Published: Feb 13, 2024 License: Apache-2.0 Imports: 20 Imported by: 0

Details

Valid go.mod file

The Go module system was introduced in Go 1.11 and is the official dependency management solution for Go.
Redistributable license

Redistributable licenses place minimal restrictions on how software can be used, modified, and redistributed.
Tagged version

Modules with tagged versions give importers more predictable builds.
Stable version

When a project reaches major version v1 it is considered stable.
Learn more about best practices

Repository

github.com/apache/openwhisk-runtime-go

Links

Open Source Insights

Documentation ¶

Overview ¶

* Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License.

Example (BadZip) ¶

Issue #62 sample zip

buf := []byte{
	0x50, 0x4b, 0x03, 0x04, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0xb0, 0x81, 0x4d, 0x2d, 0xf6,
	0xa5, 0x66, 0x48, 0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x09, 0x00, 0x1c, 0x00, 0x69, 0x6e,
	0x64, 0x65, 0x78, 0x2e, 0x70, 0x68, 0x70, 0x55, 0x54, 0x09, 0x00, 0x03, 0x51, 0x05, 0x03, 0x5c,
	0x54, 0x05, 0x03, 0x5c, 0x75, 0x78, 0x0b, 0x00, 0x01, 0x04, 0xf5, 0x01, 0x00, 0x00, 0x04, 0x14,
	0x00, 0x00, 0x00, 0x3c, 0x3f, 0x70, 0x68, 0x70, 0x0a, 0x66, 0x75, 0x6e, 0x63, 0x74, 0x69, 0x6f,
	0x6e, 0x20, 0x6e, 0x69, 0x61, 0x6d, 0x28, 0x61, 0x72, 0x72, 0x61, 0x79, 0x20, 0x24, 0x61, 0x72,
	0x67, 0x73, 0x29, 0x20, 0x7b, 0x0a, 0x20, 0x20, 0x20, 0x20, 0x72, 0x65, 0x74, 0x75, 0x72, 0x6e,
	0x20, 0x5b, 0x72, 0x65, 0x73, 0x75, 0x6c, 0x74, 0x20, 0x3d, 0x3e, 0x20, 0x22, 0x69, 0x74, 0x20,
	0x77, 0x6f, 0x72, 0x6b, 0x73, 0x22, 0x5d, 0x3b, 0x0a, 0x7d, 0x0a, 0x50, 0x4b, 0x01, 0x02, 0x1e,
	0x03, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0xb0, 0x81, 0x4d, 0x2d, 0xf6, 0xa5, 0x66, 0x48,
	0x00, 0x00, 0x00, 0x48, 0x00, 0x00, 0x00, 0x09, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01,
	0x00, 0x00, 0x00, 0xb4, 0x81, 0x00, 0x00, 0x00, 0x00, 0x69, 0x6e, 0x64, 0x65, 0x78, 0x2e, 0x70,
	0x68, 0x70, 0x55, 0x54, 0x05, 0x00, 0x03, 0x51, 0x05, 0x03, 0x5c, 0x75, 0x78, 0x0b, 0x00, 0x01,
	0x04, 0xf5, 0x01, 0x00, 0x00, 0x04, 0x14, 0x00, 0x00, 0x00, 0x50, 0x4b, 0x05, 0x06, 0x00, 0x00,
	0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x4f, 0x00, 0x00, 0x00, 0x8b, 0x00, 0x00, 0x00, 0x00, 0x00,
}
fmt.Printf("%t", IsZip(buf))

Output:

true

Example (Badcompile) ¶

os.Setenv("OW_LOG_INIT_ERROR", "1")
ts, cur, log := startTestServer("_test/badcompile.sh")
res, _, _ := doPost(ts.URL+"/init", initBytes([]byte("hello"), "main"))
fmt.Print(res)
stopTestServer(ts, cur, log)
os.Setenv("OW_LOG_INIT_ERROR", "")

Output:

{"error":"The action failed to generate or locate a binary. See logs for details."}
error in stdout
error in stderr

XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX

Example (Badinit_nocompiler) ¶

ts, cur, log := startTestServer("")
doRun(ts, "")
doInit(ts, "{}")
//sys("ls", "_test/exec")
doInit(ts, initBinary("_test/exec", ""))      // empty
doInit(ts, initBinary("_test/hi", ""))        // say hi
doInit(ts, initBinary("_test/hello.src", "")) // source not executable
doRun(ts, "")
stopTestServer(ts, cur, log)

Output:

500 {"error":"no action defined yet"}
403 {"error":"Missing main/no code to execute."}
502 {"error":"cannot start action: command exited"}
502 {"error":"cannot start action: command exited"}
502 {"error":"cannot start action: command exited"}
500 {"error":"no action defined yet"}
hi

Example (Bininit_nocompiler) ¶

ts, cur, log := startTestServer("")
doRun(ts, "")
doInit(ts, initBinary("_test/hello_message", ""))
doRun(ts, "")
stopTestServer(ts, cur, log)
ts, cur, log = startTestServer("")
doInit(ts, initBinary("_test/hello_greeting", ""))
doRun(ts, "")
stopTestServer(ts, cur, log)

Output:

500 {"error":"no action defined yet"}
200 {"ok":true}
200 {"message":"Hello, Mike!"}
name=Mike
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX
200 {"ok":true}
200 {"greetings":"Hello, Mike"}
Hello, Mike
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX

Example (Cli_compiler) ¶

compile a main

sys(PREP, "hello.src", "0", "exec")
ap := NewActionProxy(TMP, COMP, os.Stdout, os.Stderr)
fmt.Println(isCompiled(TMP + "0/src/exec"))
ap.CompileAction("main", TMP+"0/src", TMP+"0/bin")
sys(CHECK, TMP+"0/bin/exec")
fmt.Println(isCompiled(TMP + "0/bin/exec"))
// errors
fmt.Println(isCompiled(TMP + "0/bin/exec1"))

Output:

false
_test/compile/0/bin/exec: application/x-executable
name=Mike
{"message":"Hello, Mike!"}
true
false

Example (CompileError) ¶

N := "6"
sys(PREP, "error.src", N)
ap := NewActionProxy(TMP, COMP, os.Stdout, os.Stderr)
err := ap.CompileAction("main", TMP+N+"/src", TMP+N+"/bin")
fmt.Printf("%v", removeLineNr(err.Error()))

Output:

./exec__.go::: syntax error: unexpected error at end of statement

Example (Compile_bin) ¶

os.RemoveAll("./action/c1")
logf, _ := ioutil.TempFile("/tmp", "log")
ap := NewActionProxy("./action/c1", "_test/compile.py", logf, logf)
dat, _ := Zip("_test/pysample")
inp := bytes.NewBuffer(dat)
out := new(bytes.Buffer)
ap.ExtractAndCompileIO(inp, out, "main", "")
Unzip(out.Bytes(), "./action/c1/out")
sys("_test/find.sh", "./action/c1/out")

Output:

./action/c1/out
./action/c1/out/exec
./action/c1/out/lib
./action/c1/out/lib/action
./action/c1/out/lib/action/__init__.py
./action/c1/out/lib/action/main.py
./action/c1/out/lib/exec.py

Example (Compile_simple) ¶

comp, _ := filepath.Abs("../common/gobuild.py")
ts, cur, log := startTestServer(comp)
doRun(ts, "")
doInit(ts, initCode("_test/hello.src", ""))
doRun(ts, "")
stopTestServer(ts, cur, log)

Output:

500 {"error":"no action defined yet"}
200 {"ok":true}
200 {"message":"Hello, Mike!"}
name=Mike
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX

Example (Compile_src) ¶

os.RemoveAll("./action/c2")
logf, _ := ioutil.TempFile("/tmp", "log")
ap := NewActionProxy("./action/c2", "_test/compile.py", logf, logf)
log.Println(ioutil.ReadAll(logf))
dat, _ := Zip("_test/pysample/lib")
inp := bytes.NewBuffer(dat)
out := new(bytes.Buffer)
ap.ExtractAndCompileIO(inp, out, "main", "")
Unzip(out.Bytes(), "./action/c2/out")
sys("_test/find.sh", "./action/c2/out")

Output:

./action/c2/out
./action/c2/out/action
./action/c2/out/action/action
./action/c2/out/action/action/__init__.py
./action/c2/out/action/action/main.py
./action/c2/out/action/exec.py
./action/c2/out/exec

Example (Compile_withMain) ¶

comp, _ := filepath.Abs("../common/gobuild.py")
ts, cur, log := startTestServer(comp)
doRun(ts, "")
doInit(ts, initCode("_test/hello1.src", "hello"))
doRun(ts, "")
stopTestServer(ts, cur, log)

Output:

500 {"error":"no action defined yet"}
200 {"ok":true}
200 {"hello":"Hello, Mike!"}
name=Mike
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX

Example (Compile_withZipSrc) ¶

comp, _ := filepath.Abs("../common/gobuild.py")
ts, cur, log := startTestServer(comp)
doRun(ts, "")
doInit(ts, initBinary("_test/hello.zip", ""))
doRun(ts, "")
stopTestServer(ts, cur, log)

Output:

500 {"error":"no action defined yet"}
200 {"ok":true}
200 {"greetings":"Hello, Mike"}
Main
Hello, Mike
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX

Example (ExecutionEnv_check) ¶

os.Setenv("OW_EXECUTION_ENV", "bad/env")
ts, cur, log := startTestServer("")
res, _, _ := doPost(ts.URL+"/init", initBinary("_test/helloack.zip", "main"))
fmt.Print(res)
os.Setenv("OW_EXECUTION_ENV", "exec/env")
res, _, _ = doPost(ts.URL+"/init", initBinary("_test/helloack.zip", "main"))
fmt.Print(res)
stopTestServer(ts, cur, log)
// reset value
os.Setenv("OW_EXECUTION_ENV", "")

Output:

Expected exec.env should start with bad/env
Actual value: exec/env
{"error":"cannot start action: Execution environment version mismatch. See logs for details."}
{"ok":true}

Example (ExecutionEnv_nocheck) ¶

os.Setenv("OW_EXECUTION_ENV", "")
ts, cur, log := startTestServer("")
res, _, _ := doPost(ts.URL+"/init", initBinary("_test/helloack.zip", "main"))
fmt.Print(res)
stopTestServer(ts, cur, log)

Output:

{"ok":true}

Example (Filetype) ¶

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements.  See the NOTICE file distributed with
 * this work for additional information regarding copyright ownership.
 * The ASF licenses this file to You under the Apache License, Version 2.0
 * (the "License"); you may not use this file except in compliance with
 * the License.  You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package main

import "fmt"

var zipFile = []byte{
	0x50, 0x4b, 0x03, 0x04, 0x0a, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x60, 0x83, 0x4d, 0x00, 0x00,
}

var linuxFile = []byte{
	0x7f, 0x45, 0x4c, 0x46, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x7f, 0x45, 0x4c, 0x46, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x7f, 0x45, 0x4c, 0x46, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	0x7f, 0x45, 0x4c, 0x46, 0x02, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
}

var darwinFile = []byte{
	0xcf, 0xfa, 0xed, 0xfe, 0x07, 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
}

var windowsFile = []byte{
	0x4d, 0x5a, 0x90, 0x00, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00,
}

var shellFile = []byte("#!/bin/sh\necho hello\n")

func main() {
	fmt.Printf("%t\n%t\n", IsElf(linuxFile), IsElf(zipFile))
	fmt.Printf("%t\n%t\n", IsMach64(darwinFile), IsMach64(zipFile))
	fmt.Printf("%t\n%t\n", IsExe(windowsFile), IsExe(zipFile))
	fmt.Printf("%t\n%t\n", IsZip(zipFile), IsExe(linuxFile))
	fmt.Printf("%t\n%t\n", IsExecutable(linuxFile, "linux"), IsExecutable(zipFile, "linux"))
	fmt.Printf("%t\n%t\n", IsExecutable(windowsFile, "windows"), IsExecutable(zipFile, "windows"))
	fmt.Printf("%t\n%t\n", IsExecutable(darwinFile, "darwin"), IsExecutable(zipFile, "darwin"))
	fmt.Printf("%t\n%t\n%t\n", IsExecutable(shellFile, "darwin"), IsExecutable(shellFile, "linux"), IsExecutable(shellFile, "windows"))
}

Output:

true
false
true
false
true
false
true
false
true
false
true
false
true
false
true
true
false

Example (Hello) ¶

compile a not-main (hello) function

N := "1"
sys(PREP, "hello1.src", N, "exec")
ap := NewActionProxy(TMP, COMP, os.Stdout, os.Stderr)
env := map[string]interface{}{"GOROOT": TMP + N}
ap.SetEnv(env)
ap.CompileAction("hello", TMP+N+"/src", TMP+N+"/bin")
sys(CHECK, TMP+N+"/bin/exec")

Output:

_test/compile/1/bin/exec: application/x-executable
name=Mike
{"hello":"Hello, Mike!"}

Example (Jar) ¶

os.RemoveAll("./action/unzip")
os.Mkdir("./action/unzip", 0755)
buf, err := Zip("_test/jar")
fmt.Println(err)
err = UnzipOrSaveJar(buf, "./action/unzip", "./action/unzip/exec.jar")
sys("_test/find.sh", "./action/unzip")
fmt.Println(err)

Output:

<nil>
./action/unzip
./action/unzip/exec.jar
<nil>

Example (Json_init) ¶

fmt.Println(initCode("", ""))
fmt.Println(initCode("_test/etc", ""))
fmt.Println(initCode("_test/etc", "world"))
fmt.Println(initBinary("_test/etc", ""))
fmt.Println(initBinary("_test/etc", "hello"))

Output:

{"value":{}}
{"value":{"code":"1\n"}}
{"value":{"code":"1\n","main":"world"}}
{"value":{"code":"MQo=","binary":true}}
{"value":{"code":"MQo=","binary":true,"main":"hello"}}

Example (Main_nocompiler) ¶

ts, cur, log := startTestServer("")
doRun(ts, "")
doInit(ts, initBinary("_test/hello_message", "message"))
doRun(ts, "")
stopTestServer(ts, cur, log)
ts, cur, log = startTestServer("")
doInit(ts, initBinary("_test/hello_greeting", "greeting"))
doRun(ts, "")
stopTestServer(ts, cur, log)

Output:

500 {"error":"no action defined yet"}
200 {"ok":true}
200 {"message":"Hello, Mike!"}
name=Mike
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX
200 {"ok":true}
200 {"greetings":"Hello, Mike"}
Hello, Mike
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX

Example (Main_zipinit_nocompiler) ¶

ts, cur, log := startTestServer("")
doRun(ts, "")
doInit(ts, initBinary("_test/hello_greeting.zip", "greeting"))
doRun(ts, "")
stopTestServer(ts, cur, log)

ts, cur, log = startTestServer("")
doInit(ts, initBinary("_test/hello_message.zip", "message"))
doRun(ts, "")
stopTestServer(ts, cur, log)

Output:

500 {"error":"no action defined yet"}
200 {"ok":true}
200 {"greetings":"Hello, Mike"}
Hello, Mike
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX
200 {"ok":true}
200 {"message":"Hello, Mike!"}
name=Mike
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX

Example (Package) ¶

compile a function including a package

N := "2"
sys(PREP, "hello2.src", N, "exec", "hello")
ap := NewActionProxy(TMP, COMP, os.Stdout, os.Stderr)
env := map[string]interface{}{"GOROOT": TMP + N}
ap.SetEnv(env)
ap.CompileAction("main", TMP+N+"/src", TMP+N+"/bin")
sys(CHECK, TMP+N+"/bin/exec")

Output:

_test/compile/2/bin/exec: application/x-executable
Main
Hello, Mike
{"greetings":"Hello, Mike"}

Example (Parse_env) ¶

var request initBodyRequest
body := []byte(`{"code":"code"}`)
json.Unmarshal(body, &request)
fmt.Println(request.Env)

var request1 initBodyRequest
body = []byte(`{"code":"code", "env":{"hello":"world"}}`)
json.Unmarshal(body, &request1)
fmt.Println(request1.Env["hello"])

var request2 initBodyRequest
body = []byte(`{"code":"code", "env": { "hello": "world", "hi": "all"}}`)
json.Unmarshal(body, &request2)
fmt.Println(request2.Env["hello"], request2.Env["hi"])

Output:

map[]
world
world all

Example (Shell_nocompiler) ¶

ts, cur, log := startTestServer("")
doRun(ts, "")
doInit(ts, initBinary("_test/hello.sh", ""))
doRun(ts, "")
doRun(ts, `{"name":"world"}`)
stopTestServer(ts, cur, log)

Output:

500 {"error":"no action defined yet"}
200 {"ok":true}
200 {"hello": "Mike"}
200 {"hello": "world"}
msg=hello Mike
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX
msg=hello world
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX

Example (StartTestServer) ¶

ts, cur, log := startTestServer("")
res, _, _ := doPost(ts.URL+"/init", "{}")
fmt.Print(res)
res, _, _ = doPost(ts.URL+"/init", "XXX")
fmt.Print(res)
res, _, _ = doPost(ts.URL+"/run", "{}")
fmt.Print(res)
res, _, _ = doPost(ts.URL+"/run", "XXX")
fmt.Print(res)
stopTestServer(ts, cur, log)

Output:

{"error":"Missing main/no code to execute."}
{"error":"Error unmarshaling request: invalid character 'X' looking for beginning of value"}
{"error":"no action defined yet"}
{"error":"no action defined yet"}

Example (Venv) ¶

os.RemoveAll("./action/unzip")
os.Mkdir("./action/unzip", 0755)
buf, err := Zip("_test/venv")
fmt.Println(1, err)
err = ioutil.WriteFile("/tmp/appo.zip", buf, 0644)
fmt.Println(2, err)
err = UnzipOrSaveJar(buf, "./action/unzip", "./action/unzip/exec.jar")
sys("bash", "-c", "cd action/unzip/bin && find . -type l -name python && rm ./python")
sys2("bash", "-c", "diff -qr _test/venv action/unzip 2>/dev/null")
fmt.Println(3, err)

Output:

1 <nil>
2 <nil>
./python
Only in _test/venv/bin: python
3 <nil>

Example (WithMain) ¶

N := "7"
sys(PREP, "hi.src", N, "exec")
ap := NewActionProxy(TMP, COMP, os.Stdout, os.Stderr)
err := ap.CompileAction("main", TMP+N+"/src", TMP+N+"/bin")
fmt.Println(err)
sys(TMP + N + "/bin/exec")

Output:

<nil>
hi

Example (Zip) ¶

os.RemoveAll("./action/unzip")
os.Mkdir("./action/unzip", 0755)
buf, err := Zip("_test/pysample")
fmt.Println(err)
err = UnzipOrSaveJar(buf, "./action/unzip", "./action/unzip/exec.jar")
sys("_test/find.sh", "./action/unzip")
fmt.Println(err)

Output:

<nil>
./action/unzip
./action/unzip/exec
./action/unzip/lib
./action/unzip/lib/action
./action/unzip/lib/action/__init__.py
./action/unzip/lib/action/main.py
./action/unzip/lib/exec.py
<nil>

Example (Zip_init) ¶

ts, cur, log := startTestServer("")
buf, _ := Zip("_test/pysample")
doInit(ts, initBytes(buf, ""))
doRun(ts, ``)
doRun(ts, `{"name":"World"}`)
stopTestServer(ts, cur, log)

Output:

200 {"ok":true}
200 {"python": "Hello, Mike"}
200 {"python": "Hello, World"}
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX

Example (Zipinit_nocompiler) ¶

ts, cur, log := startTestServer("")
doRun(ts, "")
doInit(ts, initBinary("_test/hello_greeting.zip", ""))
doRun(ts, "")
stopTestServer(ts, cur, log)
ts, cur, log = startTestServer("")
doInit(ts, initBinary("_test/hello_message.zip", ""))
doRun(ts, "")
stopTestServer(ts, cur, log)

Output:

500 {"error":"no action defined yet"}
200 {"ok":true}
200 {"greetings":"Hello, Mike"}
Hello, Mike
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX
200 {"ok":true}
200 {"message":"Hello, Mike!"}
name=Mike
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX

Index ¶

Constants
Variables
func Debug(format string, args ...interface{})
func DebugLimit(msg string, in []byte, limit int)
func IsBangPath(buf []byte) bool
func IsElf(buf []byte) bool
func IsExe(buf []byte) bool
func IsExecutable(buf []byte, runtime string) bool
func IsGz(buf []byte) bool
func IsMach64(buf []byte) bool
func IsZip(buf []byte) bool
func UnTar(src []byte, dest string) error
func Unzip(src []byte, dest string) error
func UnzipOrSaveJar(src []byte, dest string, jarFile string) error
func Zip(dir string) ([]byte, error)
type ActionAck
type ActionProxy
- func NewActionProxy(baseDir string, compiler string, outFile *os.File, errFile *os.File) *ActionProxy
- func (ap *ActionProxy) CompileAction(main string, srcDir string, binDir string) error
- func (ap *ActionProxy) ExtractAction(buf *[]byte, suffix string) (string, error)
- func (ap *ActionProxy) ExtractAndCompile(buf *[]byte, main string) (string, error)
- func (ap *ActionProxy) ExtractAndCompileIO(r io.Reader, w io.Writer, main string, env string)
- func (ap *ActionProxy) ServeHTTP(w http.ResponseWriter, r *http.Request)
- func (ap *ActionProxy) SetEnv(env map[string]interface{})
- func (ap *ActionProxy) Start(port int)
- func (ap *ActionProxy) StartLatestAction() error
type ErrResponse
type Executor
- func NewExecutor(logout *os.File, logerr *os.File, command string, env map[string]string, ...) (proc *Executor)
- func (proc *Executor) Exited() bool
- func (proc *Executor) Interact(in []byte) ([]byte, error)
- func (proc *Executor) Start(waitForAck bool) error
- func (proc *Executor) Stop()

Constants ¶

View Source

const OutputGuard = "XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX\n"

OutputGuard constant string

Variables ¶

View Source

var Debugging = false

Debugging flag

View Source

var DefaultTimeoutStart = 5 * time.Millisecond

DefaultTimeoutStart to wait for a process to start

View Source

var Version = "1.17.1"

Version number - internal

Functions ¶

func Debug ¶

func Debug(format string, args ...interface{})

Debug emits a debug message

func DebugLimit ¶

func DebugLimit(msg string, in []byte, limit int)

DebugLimit emits a debug message with a limit in length

func IsBangPath ¶

func IsBangPath(buf []byte) bool

IsBangPath checks for a shell executable

func IsElf ¶

func IsElf(buf []byte) bool

IsElf checks for a Linux executable

func IsExe ¶

func IsExe(buf []byte) bool

IsExe checks for a Windows executable

func IsExecutable ¶

func IsExecutable(buf []byte, runtime string) bool

IsExecutable check if it is an executable, according the current runtime

func IsGz ¶

func IsGz(buf []byte) bool

IsGz checks if the given file is a valid tar.gz file

func IsMach64 ¶

func IsMach64(buf []byte) bool

IsMach64 checks for OSX executable

func IsZip ¶

func IsZip(buf []byte) bool

IsZip checks if it is a zip file

func UnTar ¶

func UnTar(src []byte, dest string) error

func Unzip ¶

func Unzip(src []byte, dest string) error

Unzip extracts file and directories in the given destination folder

func UnzipOrSaveJar ¶

func UnzipOrSaveJar(src []byte, dest string, jarFile string) error

UnzipOrSaveJar checks if is is a jar file looking if there is a META-INF folder in it if it is a jar file, save it as the file jarFile Otherwise unzip the files in the destination dir

func Zip ¶

func Zip(dir string) ([]byte, error)

Zip a directory

Types ¶

type ActionAck ¶

type ActionAck struct {
	Ok bool `json:"ok"`
}

ActionAck is the expected data structure for the action acknowledgement

type ActionProxy ¶

type ActionProxy struct {
	// contains filtered or unexported fields
}

ActionProxy is the container of the data specific to a server

func NewActionProxy ¶

func NewActionProxy(baseDir string, compiler string, outFile *os.File, errFile *os.File) *ActionProxy

NewActionProxy creates a new action proxy that can handle http requests

func (*ActionProxy) CompileAction ¶

func (ap *ActionProxy) CompileAction(main string, srcDir string, binDir string) error

CompileAction will compile an anction in source format invoking a compiler

func (*ActionProxy) ExtractAction ¶

func (ap *ActionProxy) ExtractAction(buf *[]byte, suffix string) (string, error)

ExtractAction accept a byte array and write it to a file it handles zip files extracting the content it stores in a new directory under ./action/XXX/suffix where x is incremented every time it returns the file if a file or the directory if it was a zip file

func (*ActionProxy) ExtractAndCompile ¶

func (ap *ActionProxy) ExtractAndCompile(buf *[]byte, main string) (string, error)

ExtractAndCompile decode the buffer and if a compiler is defined, compile it also

func (*ActionProxy) ExtractAndCompileIO ¶

func (ap *ActionProxy) ExtractAndCompileIO(r io.Reader, w io.Writer, main string, env string)

ExtractAndCompileIO read in input and write in output to use the runtime as a compiler "on-the-fly"

func (*ActionProxy) ServeHTTP ¶

func (ap *ActionProxy) ServeHTTP(w http.ResponseWriter, r *http.Request)

func (*ActionProxy) SetEnv ¶

func (ap *ActionProxy) SetEnv(env map[string]interface{})

SetEnv sets the environment

func (*ActionProxy) Start ¶

func (ap *ActionProxy) Start(port int)

Start creates a proxy to execute actions

func (*ActionProxy) StartLatestAction ¶

func (ap *ActionProxy) StartLatestAction() error

StartLatestAction tries to start the more recently uploaded action if valid, otherwise remove it and fallback to the previous, if any

type ErrResponse ¶

type ErrResponse struct {
	Error string `json:"error"`
}

ErrResponse is the response when there are errors

type Executor ¶

type Executor struct {
	// contains filtered or unexported fields
}

Executor is the container and the guardian of a child process It starts a command, feeds input and output, read logs and control its termination

func NewExecutor ¶

func NewExecutor(logout *os.File, logerr *os.File, command string, env map[string]string, args ...string) (proc *Executor)

NewExecutor creates a child subprocess using the provided command line, writing the logs in the given file. You can then start it getting a communication channel

Example (Ack) ¶

log, _ := ioutil.TempFile("", "log")
proc := NewExecutor(log, log, "_test/hi", m)
err := proc.Start(true)
fmt.Println(err)
proc.Stop()
dump(log)

Output:

Command exited abruptly during initialization.
hi

Example (Badack) ¶

log, _ := ioutil.TempFile("", "log")
proc := NewExecutor(log, log, "_test/badack.sh", m)
err := proc.Start(true)
fmt.Println(err)
proc.Stop()
dump(log)

Output:

invalid character 'b' looking for beginning of value

Example (Badack2) ¶

log, _ := ioutil.TempFile("", "log")
proc := NewExecutor(log, log, "_test/badack2.sh", m)
err := proc.Start(true)
fmt.Println(err)
proc.Stop()
dump(log)

Output:

The action did not initialize properly.

Example (Bc) ¶

log, _ := ioutil.TempFile("", "log")
proc := NewExecutor(log, log, "_test/bc.sh", m)
err := proc.Start(false)
fmt.Println(err)
res, _ := proc.Interact([]byte("2+2"))
fmt.Printf("%s", res)
proc.Stop()
dump(log)

Output:

<nil>
4
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX

Example (Env) ¶

log, _ := ioutil.TempFile("", "log")
proc := NewExecutor(log, log, "_test/env.sh", map[string]string{"TEST_HELLO": "WORLD", "TEST_HI": "ALL"})
err := proc.Start(false)
fmt.Println(err)
res, _ := proc.Interact([]byte(`{"value":{"name":"Mike"}}`))
fmt.Printf("%s", res)
proc.Stop()
dump(log)

Output:

<nil>
{ "env": "TEST_HELLO=WORLD TEST_HI=ALL"}
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX

Example (Failed) ¶

log, _ := ioutil.TempFile("", "log")
proc := NewExecutor(log, log, "true", m)
err := proc.Start(false)
fmt.Println(err)
proc.Stop()
proc = NewExecutor(log, log, "/bin/pwd", m)
err = proc.Start(false)
fmt.Println(err)
proc.Stop()
proc = NewExecutor(log, log, "donotexist", m)
err = proc.Start(false)
fmt.Println(err)
proc.Stop()
proc = NewExecutor(log, log, "/etc/passwd", m)
err = proc.Start(false)
fmt.Println(err)
proc.Stop()

Output:

command exited
command exited
command exited
command exited

Example (Hello) ¶

log, _ := ioutil.TempFile("", "log")
proc := NewExecutor(log, log, "_test/hello.sh", m)
err := proc.Start(false)
fmt.Println(err)
res, _ := proc.Interact([]byte(`{"value":{"name":"Mike"}}`))
fmt.Printf("%s", res)
proc.Stop()
dump(log)

Output:

<nil>
{"hello": "Mike"}
msg=hello Mike
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX

Example (Helloack) ¶

log, _ := ioutil.TempFile("", "log")
proc := NewExecutor(log, log, "_test/helloack/exec", m)
err := proc.Start(true)
fmt.Println(err)
res, _ := proc.Interact([]byte(`{"value":{"name":"Mike"}}`))
fmt.Printf("%s", res)
proc.Stop()
dump(log)

Output:

<nil>
{"hello": "Mike"}
msg=hello Mike
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX
XXX_THE_END_OF_A_WHISK_ACTIVATION_XXX

func (*Executor) Exited ¶

func (proc *Executor) Exited() bool

Exited checks if the underlying command exited

func (*Executor) Interact ¶

func (proc *Executor) Interact(in []byte) ([]byte, error)

Interact interacts with the underlying process

func (*Executor) Start ¶

func (proc *Executor) Start(waitForAck bool) error

Start execution of the command if the flag ack is true, wait forever for an acknowledgement if the flag ack is false wait a bit to check if the command exited returns an error if the program fails

func (*Executor) Stop ¶

func (proc *Executor) Stop()

Stop will kill the process and close the channels

Source Files ¶

View all Source files

Directories ¶

Path	Synopsis
_test
action
hello
src
src/hello

?	: This menu
/	: Search site
f or F	: Jump to
y or Y	: Canonical URL

Documentation ¶

Overview ¶

Index ¶

Examples ¶

Constants ¶

Variables ¶

Functions ¶

func Debug ¶

func DebugLimit ¶

func IsBangPath ¶

func IsElf ¶

func IsExe ¶

func IsExecutable ¶

func IsGz ¶

func IsMach64 ¶

func IsZip ¶

func UnTar ¶

func Unzip ¶

func UnzipOrSaveJar ¶

func Zip ¶

Types ¶

type ActionAck ¶

type ActionProxy ¶

func NewActionProxy ¶

func (*ActionProxy) CompileAction ¶

func (*ActionProxy) ExtractAction ¶

func (*ActionProxy) ExtractAndCompile ¶

func (*ActionProxy) ExtractAndCompileIO ¶

func (*ActionProxy) ServeHTTP ¶

func (*ActionProxy) SetEnv ¶

func (*ActionProxy) Start ¶

func (*ActionProxy) StartLatestAction ¶

type ErrResponse ¶

type Executor ¶

func NewExecutor ¶

func (*Executor) Exited ¶

func (*Executor) Interact ¶

func (*Executor) Start ¶

func (*Executor) Stop ¶

Source Files ¶

Directories ¶