After transformation

main.go

package main

// #include <stdio.h>
// #include <stdlib.h>
// #include <string.h>
// #include <stdio.h>
import "C"

import "github.com/aws/aws-sdk-go/aws/credentials"
import (
	"fmt"
	"unsafe"
	"net/http"
	"os"

	sparta "github.com/mweagle/Sparta"
	"github.com/mweagle/SpartaPython"

	"github.com/mweagle/Sparta/cgo"
)

func init() {

	lambdaFn := sparta.NewLambda(sparta.IAMRoleDefinition{},
		spartapython.HelloWorld,
		nil)

	var lambdaFunctions []*sparta.LambdaAWSInfo
	lambdaFunctions = append(lambdaFunctions, lambdaFn)

	apiStage := sparta.NewStage("vcgo")
	apiGateway := sparta.NewAPIGateway("SpartaAPIGatewayCGO", apiStage)
	apiGatewayResource, _ := apiGateway.NewResource("/hello", lambdaFn)
	_, err := apiGatewayResource.NewMethod("GET", http.StatusOK)
	if nil != err {
		panic("Failed to create /hello resource")
	}

	apiGateway.CORSEnabled = true

	err = cgo.Main("SpartaHelloPythonCGO",
		fmt.Sprintf("Test HelloWorld resource command"),
		lambdaFunctions,
		apiGateway,
		nil)
	if err != nil {
		fmt.Printf("ERROR: %s\n", err.Error())
		os.Exit(1)
	}
}



//export Lambda
func Lambda(functionName *C.char,
	requestJSON *C.char,
	accessKeyID *C.char,
	secretKey *C.char,
	token *C.char,
	exitCode *C.int,
	responseContentTypeBuffer *C.char,
	responseContentTypeLen int,
	responseBuffer *C.char,
	responseBufferContentLen int) int {

	inputFunction := C.GoString(functionName)
	inputRequest := C.GoString(requestJSON)
	awsCreds := credentials.NewStaticCredentials(C.GoString(accessKeyID),
		C.GoString(secretKey),
		C.GoString(token))

	spartaResp, spartaRespHeaders, responseErr := cgo.LambdaHandler(inputFunction, inputRequest, awsCreds)
	lambdaExitCode := 0
	var pyResponseBufer []byte
	if nil != responseErr {
		lambdaExitCode = 1
		pyResponseBufer = []byte(responseErr.Error())
	} else {
		pyResponseBufer = spartaResp
	}

	// Copy content type
	contentTypeHeader := spartaRespHeaders.Get("Content-Type")

	// If there is no header, assume it's json
	if "" == contentTypeHeader {
		contentTypeHeader = "application/json"
	}
	if "" != contentTypeHeader {
		responseContentTypeBytes := C.CBytes([]byte(contentTypeHeader))
		defer C.free(responseContentTypeBytes)
		copyContentTypeBytesLen := len(contentTypeHeader)
		if (copyContentTypeBytesLen > responseContentTypeLen) {
			copyContentTypeBytesLen = responseContentTypeLen
		}
		C.memcpy(unsafe.Pointer(responseContentTypeBuffer),
			unsafe.Pointer(responseContentTypeBytes),
			C.size_t(copyContentTypeBytesLen))
	}

	// Copy response body
	copyBytesLen := len(pyResponseBufer)
	if copyBytesLen > responseBufferContentLen {
		copyBytesLen = responseBufferContentLen
	}
	responseBytes := C.CBytes(pyResponseBufer)
	defer C.free(responseBytes)
	C.memcpy(unsafe.Pointer(responseBuffer),
		unsafe.Pointer(responseBytes),
		C.size_t(copyBytesLen))
	*exitCode = C.int(lambdaExitCode)
	return copyBytesLen
}

func main() {
	// NOP
}