garm-provider-edge-connect/internal/client/client.go

package client

import (
	"bytes"
	"context"
	"encoding/json"
	"fmt"
	"io"

	"log"
	"net/http"
)

type EdgeConnect struct {
	BaseURL     string
	HttpClient  *http.Client
	Credentials Credentials
}

type Credentials struct {
	Username string
	Password string
}

// curl -X POST https://mc.orca.platform.mg3.mdb.osc.live/api/v1/auth/ctrl/CreateAppInst -H 'Content-Type: application/json' -H "Authorization: Bearer $EDGEXR_TOKEN" -S --data "$CREATEAPPINSTANCE_JSON" --fail-with-body

func (e *EdgeConnect) NewAppInstance(ctx context.Context, input NewAppInstanceInput) error {
	token, err := e.RetrieveToken(ctx)
	if err != nil {
		log.Printf("failed to retrieve token %v\n", err)
		return err
	}

	json_data, err := json.Marshal(input)
	if err != nil {
		log.Printf("failed to marshal NewAppInstanceInput %v\n", err)
		return err
	}

	request, err := http.NewRequestWithContext(ctx, "POST", e.BaseURL+"/api/v1/auth/ctrl/CreateAppInst", bytes.NewBuffer(json_data))
	if err != nil {
		log.Printf("failed to create request %v\n", err)
		return err
	}
	request.Header.Set("Content-Type", "application/json")
	request.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token))

	resp, err := e.HttpClient.Do(request)
	if err != nil {
		log.Printf("failed to execute request %v\n", err)
		return err
	}
	defer resp.Body.Close()

	bytes, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Printf("err while io.ReadAll: %v\n", err)
		return err
	}

	log.Printf("Body %v\n", string(bytes))

	log.Printf("status code %v\n", resp.Status)

	return nil
}

func (e *EdgeConnect) NewApp(ctx context.Context, input NewAppInput) error {
	token, err := e.RetrieveToken(ctx)
	if err != nil {
		log.Printf("err while RetrieveToken: %v\n", err)
		return err
	}

	json_data, err := json.Marshal(input)
	if err != nil {
		log.Printf("err while Marshal: %v\n", err)
		return err
	}

	request, err := http.NewRequestWithContext(ctx, "POST", e.BaseURL+"/api/v1/auth/ctrl/CreateApp", bytes.NewBuffer(json_data))
	if err != nil {
		log.Printf("err while NewRequestWithContext: %v\n", err)
		return err
	}
	request.Header.Set("Content-Type", "application/json")
	request.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token))

	resp, err := e.HttpClient.Do(request)
	if err != nil {
		log.Printf("err while HttpClient.Do: %v\n", err)
		return err
	}

	defer resp.Body.Close()

	log.Printf("status code %v\n", resp.Status)
	bytes, err := io.ReadAll(resp.Body)
	if err != nil {
		log.Printf("err while io.ReadAll: %v\n", err)
		return err
	}

	log.Printf("Body %v\n", string(bytes))

	return nil
}

func (e *EdgeConnect) ShowApp(ctx context.Context, appkey AppKey, region string) (App, error) {
	token, err := e.RetrieveToken(ctx)
	if err != nil {
		return App{}, err
	}

	input := struct {
		App struct {
			Key AppKey `json:"key"`
		} `json:"App"`
		Region string `json:"Region"`
	}{
		App: struct {
			Key AppKey `json:"key"`
		}{
			Key: appkey,
		},
		Region: region,
	}

	json_data, err := json.Marshal(input)
	if err != nil {
		return App{}, err
	}

	request, err := http.NewRequestWithContext(ctx, "POST", e.BaseURL+"/api/v1/auth/ctrl/ShowApp", bytes.NewBuffer(json_data))
	if err != nil {
		return App{}, err
	}
	request.Header.Set("Content-Type", "application/json")
	request.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token))

	resp, err := e.HttpClient.Do(request)
	if err != nil {
		return App{}, err
	}

	defer resp.Body.Close()
	var response struct {
		Data App `json:"data"`
	}
	err = json.NewDecoder(resp.Body).Decode(&response)
	if err != nil {
		return App{}, err
	}

	return response.Data, nil
}

func (e *EdgeConnect) ShowApps(ctx context.Context, appkey AppKey, region string) ([]App, error) {
	token, err := e.RetrieveToken(ctx)
	if err != nil {
		return []App{}, err
	}

	input := struct {
		App struct {
			Key AppKey `json:"key"`
		} `json:"App"`
		Region string `json:"Region"`
	}{
		App: struct {
			Key AppKey `json:"key"`
		}{
			Key: appkey,
		},
		Region: region,
	}

	json_data, err := json.Marshal(input)
	if err != nil {
		return []App{}, err
	}

	request, err := http.NewRequestWithContext(ctx, "POST", e.BaseURL+"/api/v1/auth/ctrl/ShowApp", bytes.NewBuffer(json_data))
	if err != nil {
		return []App{}, err
	}
	request.Header.Set("Content-Type", "application/json")
	request.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token))

	resp, err := e.HttpClient.Do(request)
	if err != nil {
		return []App{}, err
	}

	defer resp.Body.Close()
	type response struct {
		Data App `json:"data"`
	}

	apps := []App{}
	decoder := json.NewDecoder(resp.Body)
	for {
		var d response
		if err := decoder.Decode(&d); err != nil {
			if err.Error() == "EOF" {
				break
			}
			log.Fatal(err)
		}
		apps = append(apps, d.Data)
	}

	return apps, nil
}

func (e *EdgeConnect) ShowAppInstance(ctx context.Context, appinstkey AppInstanceKey, region string) (AppInstance, error) {
	token, err := e.RetrieveToken(ctx)
	if err != nil {
		return AppInstance{}, err
	}

	input := struct {
		App struct {
			AppInstKey AppInstanceKey `json:"key"`
		} `json:"appinst"`
		Region string `json:"Region"`
	}{
		App: struct {
			AppInstKey AppInstanceKey `json:"key"`
		}{
			AppInstKey: appinstkey,
		},
		Region: region,
	}

	json_data, err := json.Marshal(input)
	if err != nil {
		return AppInstance{}, err
	}

	request, err := http.NewRequestWithContext(ctx, "POST", e.BaseURL+"/api/v1/auth/ctrl/ShowAppInst", bytes.NewBuffer(json_data))
	if err != nil {
		return AppInstance{}, err
	}
	request.Header.Set("Content-Type", "application/json")
	request.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token))

	resp, err := e.HttpClient.Do(request)
	if err != nil {
		return AppInstance{}, err
	}

	defer resp.Body.Close()
	var response struct {
		Data AppInstance `json:"data"`
	}

	err = json.NewDecoder(resp.Body).Decode(&response)
	if err != nil {
		return AppInstance{}, err
	}

	return response.Data, nil
}

func (e *EdgeConnect) ShowAppInstances(ctx context.Context, appinstkey AppInstanceKey, region string) ([]AppInstance, error) {
	token, err := e.RetrieveToken(ctx)
	if err != nil {
		return []AppInstance{}, err
	}

	input := struct {
		App struct {
			AppInstKey AppInstanceKey `json:"key"`
		} `json:"appinst"`
		Region string `json:"Region"`
	}{
		App: struct {
			AppInstKey AppInstanceKey `json:"key"`
		}{
			AppInstKey: appinstkey,
		},
		Region: region,
	}

	json_data, err := json.Marshal(input)
	if err != nil {
		return []AppInstance{}, err
	}

	request, err := http.NewRequestWithContext(ctx, "POST", e.BaseURL+"/api/v1/auth/ctrl/ShowAppInst", bytes.NewBuffer(json_data))
	if err != nil {
		return []AppInstance{}, err
	}
	request.Header.Set("Content-Type", "application/json")
	request.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token))

	resp, err := e.HttpClient.Do(request)
	if err != nil {
		return []AppInstance{}, err
	}

	defer resp.Body.Close()
	type response struct {
		Data AppInstance `json:"data"`
	}

	appinstances := []AppInstance{}
	decoder := json.NewDecoder(resp.Body)
	for {
		var d response
		if err := decoder.Decode(&d); err != nil {
			if err.Error() == "EOF" {
				break
			}
			log.Fatal(err)
		}
		appinstances = append(appinstances, d.Data)
	}

	return appinstances, nil
}

func (e *EdgeConnect) RetrieveToken(ctx context.Context) (string, error) {
	json_data, err := json.Marshal(map[string]string{
		"username": e.Credentials.Username,
		"password": e.Credentials.Password,
	})
	if err != nil {
		return "", err
	}

	request, err := http.NewRequestWithContext(ctx, "POST", e.BaseURL+"/api/v1/login", bytes.NewBuffer(json_data))
	if err != nil {
		return "", err
	}
	request.Header.Set("Content-Type", "application/json")

	resp, err := e.HttpClient.Do(request)
	if err != nil {
		return "", err
	}

	defer resp.Body.Close()

	var respData struct {
		Token string `json:"token"`
	}
	err = json.NewDecoder(resp.Body).Decode(&respData)
	if err != nil {
		return "", err
	}

	return respData.Token, nil
}

func (e *EdgeConnect) DeleteApp(ctx context.Context, appkey AppKey, region string) error {
	token, err := e.RetrieveToken(ctx)
	if err != nil {
		return err
	}

	input := struct {
		App struct {
			Key AppKey `json:"key"`
		} `json:"App"`
		Region string `json:"Region"`
	}{
		App: struct {
			Key AppKey `json:"key"`
		}{
			Key: appkey,
		},
		Region: region,
	}

	json_data, err := json.Marshal(input)
	if err != nil {
		return err
	}

	request, err := http.NewRequestWithContext(ctx, "POST", e.BaseURL+"/api/v1/auth/ctrl/DeleteApp", bytes.NewBuffer(json_data))
	if err != nil {
		return err
	}
	request.Header.Set("Content-Type", "application/json")
	request.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token))

	resp, err := e.HttpClient.Do(request)
	if err != nil {
		return err
	}

	defer resp.Body.Close()
	/*bodyBytes, err := io.ReadAll(resp.Body)
	if err != nil {
		return err
	}
	fmt.Printf("Response: %v\n", string(bodyBytes))*/

	return nil
}

func (e *EdgeConnect) DeleteAppInstance(ctx context.Context, appinstancekey AppInstanceKey, region string) error {
	token, err := e.RetrieveToken(ctx)
	if err != nil {
		return err
	}

	input := struct {
		App struct {
			AppInstKey AppInstanceKey `json:"key"`
		} `json:"appinst"`
		Region string `json:"Region"`
	}{
		App: struct {
			AppInstKey AppInstanceKey `json:"key"`
		}{
			AppInstKey: appinstancekey,
		},
		Region: region,
	}

	json_data, err := json.Marshal(input)
	if err != nil {
		return err
	}

	request, err := http.NewRequestWithContext(ctx, "POST", e.BaseURL+"/api/v1/auth/ctrl/DeleteAppInst", bytes.NewBuffer(json_data))
	if err != nil {
		return err
	}

	request.Header.Set("Content-Type", "application/json")
	request.Header.Set("Authorization", fmt.Sprintf("Bearer %s", token))

	resp, err := e.HttpClient.Do(request)
	if err != nil {
		return err
	}

	defer resp.Body.Close()
	/*bodyBytes, err := io.ReadAll(resp.Body)
	if err != nil {
		return err
	}
	fmt.Printf("Response: %v%v\n", resp.StatusCode, string(bodyBytes))*/

	return nil
}