Initial

Signed-off-by: Alex Ellis (OpenFaaS Ltd) <[email protected]>

Author: alexellis

.DEREK.yml

@@ -0,0 +1 @@
+redirect: https://raw.githubusercontent.com/openfaas/faas/master/.DEREK.yml

LICENSE

@@ -1,6 +1,13 @@
+Annotated portions of this project are licensed under the OpenFaaS Pro
+commercial license, for which a license is required to use the software.
+
+EULA: https://github.com/openfaas/faas/blob/master/pro/EULA.md
+
+The remainder of the source code is licensed under the MIT license.
+
 MIT License
 
-Copyright (c) 2023 OpenFaaS
+Copyright (c) 2017-2023 OpenFaaS Ltd
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
@@ -9,13 +16,14 @@ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
 AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

README.md

@@ -0,0 +1,14 @@
+## go-sdk
+
+A lightweight Go SDK for use within OpenFaaS functions and to control the OpenFaaS gateway.
+
+For use within any Go code (not just OpenFaaS Functions):
+
+* Client - A client for the OpenFaaS REST API
+
+For use within functions:
+
+* ReadSecret() - Read a named secret from within an OpenFaaS Function
+* ReadSecrets() - Read all available secrets returning a queryable map
+
+License: MIT

client.go

@@ -0,0 +1,180 @@
+package sdk
+
+import (
+	"bytes"
+	"context"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"path/filepath"
+
+	"github.com/openfaas/faas-provider/auth"
+	"github.com/openfaas/faas-provider/types"
+)
+
+// Client is used to manage OpenFaaS functions
+type Client struct {
+	GatewayURL  *url.URL
+	Client      *http.Client
+	Credentials *auth.BasicAuthCredentials
+}
+
+// NewClient creates an Client for managing OpenFaaS
+func NewClient(gatewayURL *url.URL, credentials *auth.BasicAuthCredentials, client *http.Client) *Client {
+	return &Client{
+		GatewayURL:  gatewayURL,
+		Client:      http.DefaultClient,
+		Credentials: credentials,
+	}
+}
+
+// GetNamespaces get openfaas namespaces
+func (s *Client) GetNamespaces() ([]string, error) {
+	u := s.GatewayURL
+	namespaces := []string{}
+	u.Path = "/system/namespaces"
+
+	req, err := http.NewRequest(http.MethodGet, u.String(), nil)
+	if err != nil {
+		return namespaces, fmt.Errorf("unable to create request: %s, error: %w", u.String(), err)
+	}
+
+	if s.Credentials != nil {
+		req.SetBasicAuth(s.Credentials.User, s.Credentials.Password)
+	}
+
+	res, err := s.Client.Do(req)
+	if err != nil {
+		return namespaces, fmt.Errorf("unable to make request: %w", err)
+	}
+
+	if res.Body != nil {
+		defer res.Body.Close()
+	}
+
+	bytesOut, err := ioutil.ReadAll(res.Body)
+	if err != nil {
+		return namespaces, err
+	}
+
+	if res.StatusCode == http.StatusUnauthorized {
+		return namespaces, fmt.Errorf("check authorization, status code: %d", res.StatusCode)
+	}
+
+	if len(bytesOut) == 0 {
+		return namespaces, nil
+	}
+
+	if err := json.Unmarshal(bytesOut, &namespaces); err != nil {
+		return namespaces, fmt.Errorf("unable to marshal to JSON: %s, error: %w", string(bytesOut), err)
+	}
+
+	return namespaces, err
+}
+
+// GetFunctions lists all functions
+func (s *Client) GetFunctions(namespace string) ([]types.FunctionStatus, error) {
+	u := s.GatewayURL
+
+	u.Path = "/system/functions"
+
+	if len(namespace) > 0 {
+		query := u.Query()
+		query.Set("namespace", namespace)
+		u.RawQuery = query.Encode()
+	}
+
+	req, err := http.NewRequest(http.MethodGet, u.String(), nil)
+	if err != nil {
+		return []types.FunctionStatus{}, fmt.Errorf("unable to create request for %s, error: %w", u.String(), err)
+	}
+
+	if s.Credentials != nil {
+		req.SetBasicAuth(s.Credentials.User, s.Credentials.Password)
+	}
+
+	res, err := s.Client.Do(req)
+	if err != nil {
+		return []types.FunctionStatus{}, fmt.Errorf("unable to make HTTP request: %w", err)
+	}
+
+	if res.Body != nil {
+		defer res.Body.Close()
+	}
+
+	body, _ := ioutil.ReadAll(res.Body)
+
+	functions := []types.FunctionStatus{}
+	if err := json.Unmarshal(body, &functions); err != nil {
+		return []types.FunctionStatus{},
+			fmt.Errorf("unable to unmarshal value: %q, error: %w", string(body), err)
+	}
+
+	return functions, nil
+}
+
+// ScaleFunction scales a function to a number of replicas
+func (s *Client) ScaleFunction(ctx context.Context, functionName, namespace string, replicas uint64) error {
+
+	scaleReq := types.ScaleServiceRequest{
+		ServiceName: functionName,
+		Replicas:    replicas,
+	}
+
+	var err error
+
+	bodyBytes, _ := json.Marshal(scaleReq)
+	bodyReader := bytes.NewReader(bodyBytes)
+
+	u := s.GatewayURL
+
+	functionPath := filepath.Join("/system/scale-function", functionName)
+	if len(namespace) > 0 {
+		query := u.Query()
+		query.Set("namespace", namespace)
+		u.RawQuery = query.Encode()
+	}
+
+	u.Path = functionPath
+
+	req, err := http.NewRequest(http.MethodPost, u.String(), bodyReader)
+	if err != nil {
+		return fmt.Errorf("cannot connect to OpenFaaS on URL: %s, error: %s", u.String(), err)
+	}
+
+	if s.Credentials != nil {
+		req.SetBasicAuth(s.Credentials.User, s.Credentials.Password)
+	}
+	res, err := http.DefaultClient.Do(req)
+	if err != nil {
+		return fmt.Errorf("cannot connect to OpenFaaS on URL: %s, error: %s", s.GatewayURL, err)
+
+	}
+
+	if res.Body != nil {
+		defer res.Body.Close()
+	}
+
+	switch res.StatusCode {
+	case http.StatusAccepted, http.StatusOK, http.StatusCreated:
+		break
+
+	case http.StatusNotFound:
+		return fmt.Errorf("function %s not found", functionName)
+
+	case http.StatusUnauthorized:
+		return fmt.Errorf("unauthorized action, please setup authentication for this server")
+
+	default:
+		var err error
+		bytesOut, err := ioutil.ReadAll(res.Body)
+		if err != nil {
+			return err
+		}
+
+		return fmt.Errorf("server returned unexpected status code %d, message: %q", res.StatusCode, string(bytesOut))
+	}
+	return nil
+}

client_test.go

@@ -0,0 +1,72 @@
+package sdk
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"net/url"
+	"testing"
+)
+
+func TestSdk_GetNamespaces_TwoNamespaces(t *testing.T) {
+	s := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
+
+		rw.Write([]byte(`["openfaas-fn","dev"]`))
+	}))
+
+	sU, _ := url.Parse(s.URL)
+
+	client := NewClient(sU, nil, http.DefaultClient)
+	ns, err := client.GetNamespaces()
+	if err != nil {
+		t.Fatalf("wanted no error, but got: %s", err)
+	}
+	want := 2
+	if len(ns) != want {
+		t.Fatalf("want %d namespaces, got: %d", want, len(ns))
+	}
+	wantNS := []string{"openfaas-fn", "dev"}
+	gotNS := 0
+
+	for _, n := range ns {
+		for _, w := range wantNS {
+			if n == w {
+				gotNS++
+			}
+		}
+	}
+	if gotNS != len(wantNS) {
+		t.Fatalf("want %d namespaces, got: %d", len(wantNS), gotNS)
+	}
+}
+
+func TestSdk_GetNamespaces_NoNamespaces(t *testing.T) {
+	s := httptest.NewServer(http.HandlerFunc(func(rw http.ResponseWriter, req *http.Request) {
+
+		rw.Write([]byte(`[]`))
+	}))
+
+	sU, _ := url.Parse(s.URL)
+
+	client := NewClient(sU, nil, http.DefaultClient)
+	ns, err := client.GetNamespaces()
+	if err != nil {
+		t.Fatalf("wanted no error, but got: %s", err)
+	}
+	want := 0
+	if len(ns) != want {
+		t.Fatalf("want %d namespaces, got: %d", want, len(ns))
+	}
+	wantNS := []string{}
+	gotNS := 0
+
+	for _, n := range ns {
+		for _, w := range wantNS {
+			if n == w {
+				gotNS++
+			}
+		}
+	}
+	if gotNS != len(wantNS) {
+		t.Fatalf("want %d namespaces, got: %d", len(wantNS), gotNS)
+	}
+}

go.mod

@@ -0,0 +1,7 @@
+module github.com/openfaas/go-sdk
+
+go 1.19
+
+require github.com/openfaas/faas-provider v0.19.1
+
+require github.com/google/go-cmp v0.5.9 // indirect

go.sum

@@ -0,0 +1,4 @@
+github.com/google/go-cmp v0.5.9 h1:O2Tfq5qg4qc4AmwVlvv0oLiVAGB7enBSJ2x2DqQFi38=
+github.com/google/go-cmp v0.5.9/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/openfaas/faas-provider v0.19.1 h1:xH8lTWabfDZwzIvC0u1AO48ghD3BNw6Vo231DLqTeI0=
+github.com/openfaas/faas-provider v0.19.1/go.mod h1:Farrp+9Med8LeK3aoYpqplMP8f5ebTILbCSLg2LPLZk=

secrets.go

@@ -0,0 +1,77 @@
+package sdk
+
+import (
+	"fmt"
+	"os"
+	"path"
+	"strings"
+)
+
+// ReadSecrets reads a single secrets from /var/openfaas/secrets or from
+// the environment "secret_mount_path" if set.
+func ReadSecret(key string) (string, error) {
+
+	readPath := getPath(key)
+	secretBytes, readErr := os.ReadFile(readPath)
+	if readErr != nil {
+		return "", fmt.Errorf("unable to read secret: %s, error: %s", readPath, readErr)
+	}
+	val := strings.TrimSpace(string(secretBytes))
+	return val, nil
+}
+
+// ReadSecrets reads all secrets from /var/openfaas/secrets or from
+// the environment "secret_mount_path" if set.
+// The results are returned in a map of key/value pairs.
+func ReadSecrets() (SecretMap, error) {
+
+	values := map[string]string{}
+	secretMap := newSecretMap(values)
+	base := getPath("")
+
+	files, err := os.ReadDir(base)
+	if err != nil {
+		return secretMap, err
+	}
+
+	for _, file := range files {
+		val, err := ReadSecret(file.Name())
+		if err != nil {
+			return secretMap, err
+		}
+		values[file.Name()] = val
+	}
+
+	return secretMap, nil
+}
+
+func newSecretMap(values map[string]string) SecretMap {
+	return SecretMap{
+		values: values,
+	}
+}
+
+func getPath(key string) string {
+	basePath := "/var/openfaas/secrets/"
+	if len(os.Getenv("secret_mount_path")) > 0 {
+		basePath = os.Getenv("secret_mount_path")
+	}
+	return path.Join(basePath, key)
+}
+
+type SecretMap struct {
+	values map[string]string
+}
+
+func (s *SecretMap) Get(key string) (string, error) {
+	val, ok := s.values[key]
+	if !ok {
+		return "", fmt.Errorf("secret %s not found", key)
+	}
+	return val, nil
+}
+
+func (s *SecretMap) Exists(key string) bool {
+	_, ok := s.values[key]
+	return ok
+}