handler.go

package function

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"log"
	"net/http"
	"os"
	"strings"
	"time"

	"github.com/openfaas/openfaas-cloud/sdk"
)

// Handle a serverless request
func Handle(req []byte) string {

	garbageReq := GarbageRequest{}
	err := json.Unmarshal(req, &garbageReq)
	if err != nil {
		log.Panic(err)
	}

	gatewayURL := os.Getenv("gateway_url")
	deployedFunctions, err := listFunctions(garbageReq.Owner, gatewayURL)

	if err != nil {
		log.Panic(err)
	}

	fmt.Printf("Functions owned by %s:\n %s", garbageReq.Owner, deployedFunctions)

	deleted := 0
	for _, fn := range deployedFunctions {
		if fn.GetRepo() == garbageReq.Repo {
			if !included(&fn, garbageReq.Owner, garbageReq.Functions) {
				err = deleteFunction(fn.Name, gatewayURL)
				deleted = deleted + 1
				if err != nil {
					log.Println(err)
				}
			}
		}
	}

	return fmt.Sprintf("Garbage collection ran for %s/%s - %d functions deleted.", garbageReq.Owner, garbageReq.Repo, deleted)
}

func formatCloudName(name, owner string) string {
	return owner + "-" + name
}

func included(fn *openFaaSFunction, owner string, functionStack []string) bool {

	for _, name := range functionStack {
		if strings.EqualFold(formatCloudName(name, owner), fn.Name) {
			return true
		}
	}

	return false
}

func deleteFunction(target, gatewayURL string) error {
	var err error
	fmt.Println("Delete ", target)

	c := http.Client{
		Timeout: time.Second * 3,
	}
	delReq := struct {
		FunctionName string
	}{
		FunctionName: target,
	}

	bytesReq, _ := json.Marshal(delReq)
	bufferReader := bytes.NewBuffer(bytesReq)
	httpReq, _ := http.NewRequest(http.MethodDelete, gatewayURL+"system/functions", bufferReader)

	addAuthErr := sdk.AddBasicAuth(httpReq)
	if addAuthErr != nil {
		log.Printf("Basic auth error %s", addAuthErr)
	}

	response, err := c.Do(httpReq)

	if err == nil {
		defer response.Body.Close()
		if response.Body != nil {
			bodyBytes, bErr := ioutil.ReadAll(response.Body)
			if bErr != nil {
				log.Fatal(bErr)
			}
			log.Println(string(bodyBytes))
		}
	}

	return err
}

func listFunctions(owner, gatewayURL string) ([]openFaaSFunction, error) {

	var err error

	c := http.Client{
		Timeout: time.Second * 3,
	}

	request, _ := http.NewRequest(http.MethodGet, gatewayURL+"/function/list-functions?user="+owner, nil)

	response, err := c.Do(request)

	if err == nil {
		defer response.Body.Close()

		if response.Body != nil {
			bodyBytes, bErr := ioutil.ReadAll(response.Body)
			if bErr != nil {
				log.Fatal(bErr)
			}

			functions := []openFaaSFunction{}
			mErr := json.Unmarshal(bodyBytes, &functions)
			if mErr != nil {
				log.Fatal(mErr)
			}

			return functions, nil
		}
	}

	return nil, fmt.Errorf("no functions found for user: %s", owner)
}

type GarbageRequest struct {
	Functions []string `json:"functions"`
	Repo      string   `json:"repo"`
	Owner     string   `json:"owner"`
}

type openFaaSFunction struct {
	Name   string            `json:"name"`
	Image  string            `json:"image"`
	Labels map[string]string `json:"labels"`
}

func (f *openFaaSFunction) GetOwner() string {
	return f.Labels["Git-Owner"]
}

func (f *openFaaSFunction) GetRepo() string {
	return f.Labels["Git-Repo"]
}