hostfunctions

package

v0.0.0-...-d76bbf2 Latest Latest Go to latest Published: Mar 24, 2023 License: MIT Imports: 21 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/bots-garden/capsule

Documentation ¶

Index ¶

Variables
func DeleteRequestParams(reqId uint32)
func FunctionName(ctx context.Context, module api.Module, ...)
func GetHeadersStringFromHeadersRequest(c *fiber.Ctx) string
func InitCouchBaseCluster()
func InitRedisCli()
func StoreRequestParams(c *fiber.Ctx) uint32
type WasmRequestParam
- func GetRequestParams(reqId uint32) (WasmRequestParam, error)

Constants ¶

This section is empty.

Variables ¶

View Source

var CouchBaseQuery = api.GoModuleFunc(func(ctx context.Context, module api.Module, stack []uint64) {

	InitCouchBaseCluster()

	queryPosition := uint32(stack[0])
	queryLength := uint32(stack[1])

	queryStr := memory.ReadStringFromMemory(ctx, module, queryPosition, queryLength)

	queryResults, err := getCouchBaseCluster().Query(queryStr, nil)

	var stringResultFromHost = ""
	var records []map[string]interface{}
	var record interface{}

	if err != nil {
		log.Fatalf("%v", err)
	}

	for queryResults.Next() {
		err := queryResults.Row(&record)
		if err != nil {
			panic(err)
		}
		records = append(records, record.(map[string]interface{}))
	}
	jsonStringArray, _ := json.Marshal(records)

	if err != nil {
		stringResultFromHost = commons.CreateStringError(err.Error(), 0)

	} else {
		stringResultFromHost = string(jsonStringArray)
		if len(stringResultFromHost) == 0 {
			stringResultFromHost = "empty"
		}
	}

	positionReturnBuffer := uint32(stack[2])
	lengthReturnBuffer := uint32(stack[3])

	memory.WriteStringToMemory(stringResultFromHost, ctx, module, positionReturnBuffer, lengthReturnBuffer)

	stack[0] = 0
})

CouchBaseQuery : The wasm module will call this function like this: `func CouchBaseQuery(query string) (string, error)`

View Source

var GetEnv = api.GoModuleFunc(func(ctx context.Context, module api.Module, stack []uint64) {

	positionVariableName := uint32(stack[0])
	lengthVariableName := uint32(stack[1])

	variableName := memory.ReadStringFromMemory(ctx, module, positionVariableName, lengthVariableName)

	var stringResultFromHost = ""
	variableValue := os.Getenv(variableName)

	if variableValue == "" {
		stringResultFromHost = commons.CreateStringError(variableName+" is empty", 0)
	} else {
		stringResultFromHost = variableValue
	}

	positionReturnBuffer := uint32(stack[2])
	lengthReturnBuffer := uint32(stack[3])

	memory.WriteStringToMemory(stringResultFromHost, ctx, module, positionReturnBuffer, lengthReturnBuffer)

	stack[0] = 0

})

GetEnv : The wasm module will call this function like this: `func GetEnv(param string) (string, error)`

View Source

var GetExitCode = api.GoModuleFunc(func(ctx context.Context, module api.Module, stack []uint64) {
	exitCode := strconv.Itoa(commons.GetExitCode())

	retBuffPtrPos := uint32(stack[0])
	retBuffSize := uint32(stack[1])
	memory.WriteStringToMemory(exitCode, ctx, module, retBuffPtrPos, retBuffSize)
	stack[0] = 0
})

View Source

var GetExitError = api.GoModuleFunc(func(ctx context.Context, module api.Module, stack []uint64) {
	exitError := commons.GetExitError()
	retBuffPtrPos := uint32(stack[0])
	retBuffSize := uint32(stack[1])
	memory.WriteStringToMemory(exitError, ctx, module, retBuffPtrPos, retBuffSize)
	stack[0] = 0
})

View Source

var GetHostInformation = api.GoModuleFunc(func(ctx context.Context, module api.Module, stack []uint64) {

	message := HostInformation

	positionReturnBuffer := uint32(stack[0])
	lengthReturnBuffer := uint32(stack[1])

	memory.WriteStringToMemory(message, ctx, module, positionReturnBuffer, lengthReturnBuffer)

	stack[0] = 0
})

GetHostInformation returns information about the host

View Source

var HostInformation = ""

HostInformation updated in `services/http/http.go`

View Source

var Http = api.GoModuleFunc(func(ctx context.Context, module api.Module, stack []uint64) {

	positionUrl := uint32(stack[0])
	lengthUrl := uint32(stack[1])
	urlStr := memory.ReadStringFromMemory(ctx, module, positionUrl, lengthUrl)

	positionMethod := uint32(stack[2])
	lengthMethod := uint32(stack[3])
	methodStr := memory.ReadStringFromMemory(ctx, module, positionMethod, lengthMethod)

	positionHeaders := uint32(stack[4])
	lengthHeaders := uint32(stack[5])

	headersStr := memory.ReadStringFromMemory(ctx, module, positionHeaders, lengthHeaders)
	headersSlice := commons.CreateSliceFromString(headersStr, commons.StrSeparator)
	headersMap := commons.CreateMapFromSlice(headersSlice, commons.FieldSeparator)

	positionBody := uint32(stack[6])
	lengthBody := uint32(stack[7])
	bodyStr := memory.ReadStringFromMemory(ctx, module, positionBody, lengthBody)

	var stringResultFromHost = ""
	client := resty.New()

	for key, value := range headersMap {
		client.SetHeader(key, value)
	}

	switch what := methodStr; what {
	case "GET":

		resp, err := client.R().EnableTrace().Get(urlStr)
		if err != nil {
			stringResultFromHost = commons.CreateStringError(err.Error(), 0)

		} else {
			stringResultFromHost = resp.String()
		}

	case "POST":

		resp, err := client.R().EnableTrace().SetBody(bodyStr).Post(urlStr)
		if err != nil {
			stringResultFromHost = commons.CreateStringError(err.Error(), 0)

		} else {
			stringResultFromHost = resp.String()
		}

	default:
		stringResultFromHost = commons.CreateStringError("🔴"+methodStr+" is not yet implemented: 🚧 wip", 0)
	}

	positionReturnBuffer := uint32(stack[8])
	lengthReturnBuffer := uint32(stack[9])

	memory.WriteStringToMemory(stringResultFromHost, ctx, module, positionReturnBuffer, lengthReturnBuffer)

	stack[0] = 0
})

View Source

var LogString = api.GoModuleFunc(func(ctx context.Context, module api.Module, stack []uint64) {

	position := uint32(stack[0])
	length := uint32(stack[1])

	buffer, ok := module.Memory().Read(position, length)
	if !ok {
		log.Panicf("🟥 Memory.Read(%d, %d) out of range", position, length)
	}

	fmt.Println(string(buffer))

	stack[0] = 0
})

LogString : print a string to the console

View Source

var MemoryGet = api.GoModuleFunc(func(ctx context.Context, module api.Module, stack []uint64) {

	keyPosition := uint32(stack[0])
	keyLength := uint32(stack[1])
	keyStr := memory.ReadStringFromMemory(ctx, module, keyPosition, keyLength)

	valueStr := memoryMap[keyStr]

	var stringResultFromHost = ""

	if len(valueStr) == 0 {
		stringResultFromHost = commons.CreateStringError("key does not exist", 0)

	} else {
		stringResultFromHost = valueStr
	}

	positionReturnBuffer := uint32(stack[2])
	lengthReturnBuffer := uint32(stack[3])

	memory.WriteStringToMemory(stringResultFromHost, ctx, module, positionReturnBuffer, lengthReturnBuffer)

	stack[0] = 0

})

View Source

var MemoryKeys = api.GoModuleFunc(func(ctx context.Context, module api.Module, stack []uint64) {
	var keys []string
	for key, _ := range memoryMap {
		keys = append(keys, key)
	}
	stringResultFromHost := commons.CreateStringFromSlice(keys, commons.StrSeparator)

	positionReturnBuffer := uint32(stack[0])
	lengthReturnBuffer := uint32(stack[1])

	memory.WriteStringToMemory(stringResultFromHost, ctx, module, positionReturnBuffer, lengthReturnBuffer)

	stack[0] = 0

})

View Source

var MemorySet = api.GoModuleFunc(func(ctx context.Context, module api.Module, stack []uint64) {
	keyPosition := uint32(stack[0])
	keyLength := uint32(stack[1])
	keyStr := memory.ReadStringFromMemory(ctx, module, keyPosition, keyLength)

	valuePosition := uint32(stack[2])
	valueLength := uint32(stack[3])
	valueStr := memory.ReadStringFromMemory(ctx, module, valuePosition, valueLength)

	memoryMap[keyStr] = valueStr

	stringResultFromHost := "[OK](" + keyStr + ":" + valueStr + ")"

	positionReturnBuffer := uint32(stack[4])
	lengthReturnBuffer := uint32(stack[5])

	memory.WriteStringToMemory(stringResultFromHost, ctx, module, positionReturnBuffer, lengthReturnBuffer)

	stack[0] = 0

})

View Source

var MqttConnectPublish = api.GoModuleFunc(func(ctx context.Context, module api.Module, stack []uint64) {

	var stringResultFromHost = ""

	mqttSrvOffset := uint32(stack[0])
	mqttSrvByteCount := uint32(stack[1])

	mqttSrv := memory.ReadStringFromMemory(ctx, module, mqttSrvOffset, mqttSrvByteCount)

	clientIdPtrOffset := uint32(stack[2])
	clientIdByteCount := uint32(stack[3])

	mqttClientId := memory.ReadStringFromMemory(ctx, module, clientIdPtrOffset, clientIdByteCount)

	opts := mqtt.NewClientOptions()
	opts.AddBroker(fmt.Sprintf("tcp://%s", mqttSrv))
	opts.SetClientID(mqttClientId)
	mqttClient := mqtt.NewClient(opts)
	token := mqttClient.Connect()
	token.Wait()
	errConn := token.Error()
	defer mqttClient.Disconnect(250)

	if errConn != nil {
		fmt.Println("1️⃣😡", errConn.Error())
		stringResultFromHost = commons.CreateStringError(errConn.Error(), 0)

	} else {
		topicOffset := uint32(stack[4])
		topicByteCount := uint32(stack[5])

		topic := memory.ReadStringFromMemory(ctx, module, topicOffset, topicByteCount)

		dataOffset := uint32(stack[6])
		dataByteCount := uint32(stack[7])

		data := memory.ReadStringFromMemory(ctx, module, dataOffset, dataByteCount)

		token := mqttClient.Publish(topic, 0, false, data)
		token.Wait()

		errPub := token.Error()

		if errPub != nil {

			stringResultFromHost = commons.CreateStringError(errPub.Error(), 0)

		} else {
			stringResultFromHost = "[OK](" + topic + ":" + data + ")"
		}
	}
	retBuffPtrPos := uint32(stack[8])
	retBuffSize := uint32(stack[9])

	memory.WriteStringToMemory(stringResultFromHost, ctx, module, retBuffPtrPos, retBuffSize)

	stack[0] = 0

})

MqttConnectPublish : only if context is cli or http

View Source

var MqttGetClientId = api.GoModuleFunc(func(ctx context.Context, module api.Module, stack []uint64) {
	server := mqttconn.GetCapsuleMqttClientId()
	retBuffPtrPos := uint32(stack[0])
	retBuffSize := uint32(stack[1])
	memory.WriteStringToMemory(server, ctx, module, retBuffPtrPos, retBuffSize)
	stack[0] = 0
})

View Source

var MqttGetServer = api.GoModuleFunc(func(ctx context.Context, module api.Module, stack []uint64) {
	server := mqttconn.GetCapsuleMqttServer()
	retBuffPtrPos := uint32(stack[0])
	retBuffSize := uint32(stack[1])
	memory.WriteStringToMemory(server, ctx, module, retBuffPtrPos, retBuffSize)
	stack[0] = 0
})

View Source

var MqttGetTopic = api.GoModuleFunc(func(ctx context.Context, module api.Module, stack []uint64) {
	topic := mqttconn.GetCapsuleMqttTopic()
	retBuffPtrPos := uint32(stack[0])
	retBuffSize := uint32(stack[1])
	memory.WriteStringToMemory(topic, ctx, module, retBuffPtrPos, retBuffSize)
	stack[0] = 0
})

MqttGetTopic return the MQTT Topic of the capsule launcher

View Source

var MqttPublish = api.GoModuleFunc(func(ctx context.Context, module api.Module, stack []uint64) {

	mqttClient, errConn := mqttconn.GetCapsuleMqttConn()

	var stringResultFromHost = ""

	if errConn != nil {

		stringResultFromHost = commons.CreateStringError(errConn.Error(), 0)

	} else {

		topicOffset := uint32(stack[0])
		topicByteCount := uint32(stack[1])

		topic := memory.ReadStringFromMemory(ctx, module, topicOffset, topicByteCount)

		dataOffset := uint32(stack[2])
		dataByteCount := uint32(stack[3])

		data := memory.ReadStringFromMemory(ctx, module, dataOffset, dataByteCount)

		token := mqttClient.Publish(topic, 0, false, data)
		token.Wait()

		errPub := token.Error()

		if errPub != nil {

			stringResultFromHost = commons.CreateStringError(errPub.Error(), 0)

		} else {
			stringResultFromHost = "[OK](" + topic + ":" + data + ")"
		}
	}
	retBuffPtrPos := uint32(stack[4])
	retBuffSize := uint32(stack[5])

	memory.WriteStringToMemory(stringResultFromHost, ctx, module, retBuffPtrPos, retBuffSize)

	stack[0] = 0
})

MqttPublish : only if context is mqtt

View Source

var NatsConnectPublish = api.GoModuleFunc(func(ctx context.Context, module api.Module, stack []uint64) {

	var stringResultFromHost = ""

	natsSrvOffset := uint32(stack[0])
	natsSrvByteCount := uint32(stack[1])
	natsSrv := memory.ReadStringFromMemory(ctx, module, natsSrvOffset, natsSrvByteCount)

	natscn, errConn := nats.Connect(natsSrv)
	defer natscn.Close()

	if errConn != nil {

		stringResultFromHost = commons.CreateStringError(errConn.Error(), 0)

	} else {
		subjectOffset := uint32(stack[2])
		subjectByteCount := uint32(stack[3])
		subject := memory.ReadStringFromMemory(ctx, module, subjectOffset, subjectByteCount)

		dataOffset := uint32(stack[4])
		dataByteCount := uint32(stack[5])
		data := memory.ReadStringFromMemory(ctx, module, dataOffset, dataByteCount)

		errPub := natscn.Publish(subject, []byte(data))

		if errPub != nil {

			stringResultFromHost = commons.CreateStringError(errPub.Error(), 0)

		} else {
			stringResultFromHost = "[OK](" + subject + ":" + data + ")"
		}
	}

	retBuffPtrPos := uint32(stack[6])
	retBuffSize := uint32(stack[7])

	memory.WriteStringToMemory(stringResultFromHost, ctx, module, retBuffPtrPos, retBuffSize)

	stack[0] = 0

})

NatsConnectPublish : only if context is cli or http

View Source

var NatsConnectRequest = api.GoModuleFunc(func(ctx context.Context, module api.Module, stack []uint64) {

	var stringResultFromHost = ""

	natsSrvOffset := uint32(stack[0])
	natsSrvByteCount := uint32(stack[1])
	natsSrv := memory.ReadStringFromMemory(ctx, module, natsSrvOffset, natsSrvByteCount)

	natscn, errConn := nats.Connect(natsSrv)
	defer natscn.Close()

	if errConn != nil {

		stringResultFromHost = commons.CreateStringError(errConn.Error(), 0)

	} else {

		subjectOffset := uint32(stack[2])
		subjectByteCount := uint32(stack[3])
		subject := memory.ReadStringFromMemory(ctx, module, subjectOffset, subjectByteCount)

		dataOffset := uint32(stack[4])
		dataByteCount := uint32(stack[5])
		data := memory.ReadStringFromMemory(ctx, module, dataOffset, dataByteCount)

		timeoutSecondDuration := uint32(stack[6])

		replyMsg, errPub := natscn.Request(subject, []byte(data), time.Duration(timeoutSecondDuration)*time.Second)

		if errPub != nil {

			stringResultFromHost = commons.CreateStringError(errPub.Error(), 0)

		} else {

			stringResultFromHost = string(replyMsg.Data)
		}
	}

	retBuffPtrPos := uint32(stack[7])
	retBuffSize := uint32(stack[8])

	memory.WriteStringToMemory(stringResultFromHost, ctx, module, retBuffPtrPos, retBuffSize)

	stack[0] = 0

})

NatsConnectRequest : only if context is cli or http (???) ref: https://docs.nats.io/using-nats/developer/sending/request_reply

View Source

var NatsGetServer = api.GoModuleFunc(func(ctx context.Context, module api.Module, stack []uint64) {
	server := natsconn.GetCapsuleNatsServer()
	retBuffPtrPos := uint32(stack[0])
	retBuffSize := uint32(stack[1])
	memory.WriteStringToMemory(server, ctx, module, retBuffPtrPos, retBuffSize)
	stack[0] = 0
})

View Source

var NatsGetSubject = api.GoModuleFunc(func(ctx context.Context, module api.Module, stack []uint64) {
	subject := natsconn.GetCapsuleNatsSubject()
	retBuffPtrPos := uint32(stack[0])
	retBuffSize := uint32(stack[1])
	memory.WriteStringToMemory(subject, ctx, module, retBuffPtrPos, retBuffSize)
	stack[0] = 0
})

NatsGetSubject return the NATS subject of the capsule launcher

View Source

var NatsPublish = api.GoModuleFunc(func(ctx context.Context, module api.Module, stack []uint64) {

	nc, errConn := natsconn.GetCapsuleNatsConn()

	var stringResultFromHost = ""

	if errConn != nil {

		stringResultFromHost = commons.CreateStringError(errConn.Error(), 0)

	} else {

		subjectOffset := uint32(stack[0])
		subjectByteCount := uint32(stack[1])
		subject := memory.ReadStringFromMemory(ctx, module, subjectOffset, subjectByteCount)

		dataOffset := uint32(stack[2])
		dataByteCount := uint32(stack[3])
		data := memory.ReadStringFromMemory(ctx, module, dataOffset, dataByteCount)

		errPub := nc.Publish(subject, []byte(data))

		if errPub != nil {

			stringResultFromHost = commons.CreateStringError(errPub.Error(), 0)

		} else {
			stringResultFromHost = "[OK](" + subject + ":" + data + ")"
		}
	}

	retBuffPtrPos := uint32(stack[4])
	retBuffSize := uint32(stack[5])

	memory.WriteStringToMemory(stringResultFromHost, ctx, module, retBuffPtrPos, retBuffSize)

	stack[0] = 0

})

NatsPublish : only if context is nats (the module is a subscriber) func NatsPublish(ctx context.Context, module api.Module, subjectOffset, subjectByteCount, dataOffset, dataByteCount, retBuffPtrPos, retBuffSize uint32) {

View Source

var NatsReply = api.GoModuleFunc(func(ctx context.Context, module api.Module, stack []uint64) {

	sub, errSub := natsconn.GetCapsuleNatsSubscription()

	var stringResultFromHost = ""

	if errSub != nil {
		stringResultFromHost = commons.CreateStringError(errSub.Error(), 0)

	} else {

		dataOffset := uint32(stack[0])
		dataByteCount := uint32(stack[1])
		data := memory.ReadStringFromMemory(ctx, module, dataOffset, dataByteCount)

		timeoutSecondDuration := uint32(stack[2])

		msg, errMsg := sub.NextMsg(time.Duration(timeoutSecondDuration) * time.Second)

		if errMsg != nil {
			stringResultFromHost = commons.CreateStringError(errMsg.Error(), 0)

		} else {
			errResp := msg.Respond([]byte(data))
			if errResp != nil {
				stringResultFromHost = commons.CreateStringError(errResp.Error(), 0)

			} else {
				stringResultFromHost = "[OK](" + natsconn.GetCapsuleNatsSubject() + ":" + data + ")"
			}
		}
	}

	retBuffPtrPos := uint32(stack[3])
	retBuffSize := uint32(stack[4])

	memory.WriteStringToMemory(stringResultFromHost, ctx, module, retBuffPtrPos, retBuffSize)

	stack[0] = 0

})

NatsReply : only if context is nats (the module is a subscriber)

View Source

var ReadFile = api.GoModuleFunc(func(ctx context.Context, module api.Module, stack []uint64) {

	positionFilePathName := uint32(stack[0])
	lengthFilePathName := uint32(stack[1])

	filePath := memory.ReadStringFromMemory(ctx, module, positionFilePathName, lengthFilePathName)

	var stringResultFromHost = ""

	data, err := os.ReadFile(filePath)
	if err != nil {
		stringResultFromHost = commons.CreateStringError(err.Error(), 0)

	} else {
		stringResultFromHost = string(data)
	}

	positionReturnBuffer := uint32(stack[2])
	lengthReturnBuffer := uint32(stack[3])

	memory.WriteStringToMemory(stringResultFromHost, ctx, module, positionReturnBuffer, lengthReturnBuffer)

	stack[0] = 0

})

ReadFile : string parameter, return string

View Source

var RedisGet = api.GoModuleFunc(func(ctx context.Context, module api.Module, stack []uint64) {

	InitRedisCli()

	keyPosition := uint32(stack[0])
	keyLength := uint32(stack[1])
	keyStr := memory.ReadStringFromMemory(ctx, module, keyPosition, keyLength)

	valueStr, err := getRedisCli().Get(ctx, keyStr).Result()

	var stringResultFromHost = ""

	if err != nil {
		stringResultFromHost = commons.CreateStringError(err.Error(), 0)

	} else {
		stringResultFromHost = valueStr
	}

	positionReturnBuffer := uint32(stack[2])
	lengthReturnBuffer := uint32(stack[3])

	memory.WriteStringToMemory(stringResultFromHost, ctx, module, positionReturnBuffer, lengthReturnBuffer)

	stack[0] = 0
})

RedisGet : The wasm module will call this function like this: `func RedisGet(key string) (string, error)`

View Source

var RedisKeys = api.GoModuleFunc(func(ctx context.Context, module api.Module, stack []uint64) {
	InitRedisCli()

	patternPosition := uint32(stack[0])
	patternLength := uint32(stack[1])
	patternStr := memory.ReadStringFromMemory(ctx, module, patternPosition, patternLength)

	valueStr, err := getRedisCli().Keys(ctx, patternStr).Result()

	var stringResultFromHost = ""

	if err != nil {
		stringResultFromHost = commons.CreateStringError(err.Error(), 0)

	} else {
		stringResultFromHost = commons.CreateStringFromSlice(valueStr, commons.StrSeparator)
	}

	positionReturnBuffer := uint32(stack[2])
	lengthReturnBuffer := uint32(stack[3])

	memory.WriteStringToMemory(stringResultFromHost, ctx, module, positionReturnBuffer, lengthReturnBuffer)

	stack[0] = 0

})

RedisKeys : get all the keys (with a pattern) The wasm module will call this function like this: `func RedisKeys(pattern string) (string, error)`

View Source

var RedisSet = api.GoModuleFunc(func(ctx context.Context, module api.Module, stack []uint64) {

	InitRedisCli()

	keyPosition := uint32(stack[0])
	keyLength := uint32(stack[1])
	keyStr := memory.ReadStringFromMemory(ctx, module, keyPosition, keyLength)

	valuePosition := uint32(stack[2])
	valueLength := uint32(stack[3])
	valueStr := memory.ReadStringFromMemory(ctx, module, valuePosition, valueLength)

	err := getRedisCli().Set(ctx, keyStr, valueStr, 0).Err()

	var stringResultFromHost = ""

	if err != nil {
		stringResultFromHost = commons.CreateStringError(err.Error(), 0)

	} else {
		stringResultFromHost = "[OK](" + keyStr + ":" + valueStr + ")"
	}

	positionReturnBuffer := uint32(stack[4])
	lengthReturnBuffer := uint32(stack[5])

	memory.WriteStringToMemory(stringResultFromHost, ctx, module, positionReturnBuffer, lengthReturnBuffer)

	stack[0] = 0
})

RedisSet : The wasm module will call this function like this: `func RedisSet(key string, value) (string, error)`

View Source

var RequestParamsGet = api.GoModuleFunc(func(ctx context.Context, module api.Module, stack []uint64) {
	reqId := uint32(stack[0])
	reqParams, err := GetRequestParams(reqId)
	// This variable will store the concatenation of reqParams.JsonData, reqParams.Headers, reqParams.Uri, reqParams.Method
	var stringResultFromHost = ""

	if err != nil {
		stringResultFromHost = commons.CreateStringError("key (requestId) does not exist", 0)

	} else {
		stringResultFromHost = commons.CreateStringFromSlice([]string{reqParams.JsonData, reqParams.Headers, reqParams.Uri, reqParams.Method}, commons.StrSeparator)
	}

	positionReturnBuffer := uint32(stack[1])
	lengthReturnBuffer := uint32(stack[2])

	memory.WriteStringToMemory(stringResultFromHost, ctx, module, positionReturnBuffer, lengthReturnBuffer)

	stack[0] = 0
})

View Source

var WriteFile = api.GoModuleFunc(func(ctx context.Context, module api.Module, stack []uint64) {

	positionFilePathName := uint32(stack[0])
	lengthFilePathName := uint32(stack[1])

	filePath := memory.ReadStringFromMemory(ctx, module, positionFilePathName, lengthFilePathName)

	positionContent := uint32(stack[2])
	lengthContent := uint32(stack[3])

	content := memory.ReadStringFromMemory(ctx, module, positionContent, lengthContent)

	var stringResultFromHost = ""

	data := []byte(content)
	err := os.WriteFile(filePath, data, 0644)

	if err != nil {
		stringResultFromHost = commons.CreateStringError(err.Error(), 0)

	} else {
		stringResultFromHost = "file created"
	}

	positionReturnBuffer := uint32(stack[4])
	lengthReturnBuffer := uint32(stack[5])

	memory.WriteStringToMemory(stringResultFromHost, ctx, module, positionReturnBuffer, lengthReturnBuffer)

	stack[0] = 0

})

Functions ¶

func DeleteRequestParams ¶

func DeleteRequestParams(reqId uint32)

func DeleteRequestParams(reqId string) {

func FunctionName ¶

func FunctionName(ctx context.Context, module api.Module, paramOffset, paramByteCount, retBuffPtrPos, retBuffSize uint32)

FunctionName : The wasm module will call this function like this: `func FunctionName(param string) (string, error)`

func GetHeadersStringFromHeadersRequest ¶

func GetHeadersStringFromHeadersRequest(c *fiber.Ctx) string

GetHeadersStringFromHeadersRequest :

func InitCouchBaseCluster ¶

func InitCouchBaseCluster()

func InitRedisCli ¶

func InitRedisCli()

func StoreRequestParams ¶

func StoreRequestParams(c *fiber.Ctx) uint32

StoreRequestParams stores json data + headers + uri + method and returns the requestId

Types ¶

type WasmRequestParam ¶

type WasmRequestParam struct {
	JsonData string
	Uri      string
	Method   string
	Headers  string
}

func GetRequestParams ¶

func GetRequestParams(reqId uint32) (WasmRequestParam, error)

func GetRequestParams(reqId string) (WasmRequestParam, error) {

Source Files ¶

View all Source files

Directories ¶

Path	Synopsis
memory

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