work with bugout-go

nodes/node_balancer/cmd/bugout.go

@@ -1,241 +0,0 @@
-package cmd
-
-import (
-	"bytes"
-	"encoding/json"
-	"fmt"
-	"io/ioutil"
-	"net/http"
-
-	configs "github.com/bugout-dev/moonstream/nodes/node_balancer/configs"
-)
-
-var (
-	bugoutClient BugoutClient
-)
-
-type BugoutClient struct {
-	Client  http.Client
-	AuthURL string
-}
-
-type PingResponse struct {
-	Status string `json:"status"`
-}
-
-// Bugout responses
-type BugoutUserResponse struct {
-	ID            string `json:"user_id"`
-	ApplicationID string `json:"application_id"`
-}
-
-type UserAccess struct {
-	UserID           string `json:"user_id"`
-	AccessID         string `json:"access_id"`
-	Name             string `json:"name"`
-	Description      string `json:"description"`
-	BlockchainAccess bool   `json:"blockchain_access"`
-	ExtendedMethods  bool   `json:"extended_methods"`
-
-	dataSource string
-}
-
-type BugoutResourceResponse struct {
-	ID           string     `json:"id"`
-	ResourceData UserAccess `json:"resource_data"`
-}
-
-type BugoutResourcesResponse struct {
-	Resources []BugoutResourceResponse `json:"resources"`
-}
-
-// Initialize Bugout http client
-func InitBugoutClient() {
-	client := http.Client{Timeout: configs.BUGOUT_AUTH_CALL_TIMEOUT}
-	bugoutClient = BugoutClient{
-		Client:  client,
-		AuthURL: configs.BUGOUT_AUTH_URL,
-	}
-}
-
-// Get Bugout user
-func (bc *BugoutClient) GetUser(token string) (BugoutUserResponse, error) {
-	var userResponse BugoutUserResponse
-
-	url := fmt.Sprintf("%s/user", configs.BUGOUT_AUTH_URL)
-	req, err := http.NewRequest("GET", url, nil)
-	if err != nil {
-		return userResponse, err
-	}
-
-	req.Header = http.Header{
-		"Authorization": []string{fmt.Sprintf("Bearer %s", token)},
-	}
-	resp, err := bc.Client.Do(req)
-	if err != nil {
-		return userResponse, err
-	}
-	defer resp.Body.Close()
-
-	// Parse response
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return userResponse, err
-	}
-	err = json.Unmarshal(body, &userResponse)
-	if err != nil {
-		return userResponse, err
-	}
-
-	return userResponse, nil
-}
-
-// Find Bugout user
-func (bc *BugoutClient) FindUser(token, userID string) (BugoutUserResponse, error) {
-	var userResponse BugoutUserResponse
-
-	url := fmt.Sprintf("%s/user/find?user_id=%s", configs.BUGOUT_AUTH_URL, userID)
-	req, err := http.NewRequest("GET", url, nil)
-	if err != nil {
-		return userResponse, err
-	}
-
-	req.Header = http.Header{
-		"Authorization": []string{fmt.Sprintf("Bearer %s", token)},
-	}
-	resp, err := bc.Client.Do(req)
-	if err != nil {
-		return userResponse, err
-	}
-	defer resp.Body.Close()
-
-	// Parse response
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return userResponse, err
-	}
-	err = json.Unmarshal(body, &userResponse)
-	if err != nil {
-		return userResponse, err
-	}
-
-	return userResponse, nil
-}
-
-func (bc *BugoutClient) AddUserAccess(token string, proposedUserAccess UserAccess) (UserAccess, error) {
-	var userAccess UserAccess
-
-	// Check user exists
-	user, err := bc.FindUser(token, proposedUserAccess.UserID)
-	if err != nil {
-		return userAccess, err
-	}
-	if user == (BugoutUserResponse{}) {
-		return userAccess, fmt.Errorf("User with id %s not found", proposedUserAccess.UserID)
-	}
-
-	resource := map[string]interface{}{
-		"application_id": configs.NB_APPLICATION_ID,
-		"resource_data":  proposedUserAccess,
-	}
-	resourceJson, err := json.Marshal(resource)
-	if err != nil {
-		return userAccess, err
-	}
-	url := fmt.Sprintf("%s/resources", configs.BUGOUT_AUTH_URL)
-	req, err := http.NewRequest("POST", url, bytes.NewBuffer(resourceJson))
-	if err != nil {
-		return userAccess, err
-	}
-	req.Header = http.Header{
-		"Authorization": []string{fmt.Sprintf("Bearer %s", token)},
-		"Content-Type":  []string{"application/json"},
-	}
-	resp, err := bc.Client.Do(req)
-	if err != nil {
-		return userAccess, err
-	}
-	defer resp.Body.Close()
-
-	// Parse response
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return userAccess, err
-	}
-	var resourceResponse BugoutResourceResponse
-	err = json.Unmarshal(body, &resourceResponse)
-	if err != nil {
-		return userAccess, err
-	}
-
-	userAccess = resourceResponse.ResourceData
-
-	return userAccess, nil
-}
-
-// Get Bugout resource
-func (bc *BugoutClient) GetResources(token, userID, accessID string) (BugoutResourcesResponse, error) {
-	var resourcesResponse BugoutResourcesResponse
-
-	url := fmt.Sprintf("%s/resources?application_id=%s", configs.BUGOUT_AUTH_URL, configs.NB_APPLICATION_ID)
-	if userID != "" {
-		url += fmt.Sprintf("&user_id=%s", userID)
-	}
-	if accessID != "" {
-		url += fmt.Sprintf("&access_id=%s", accessID)
-	}
-	req, err := http.NewRequest("GET", url, nil)
-	if err != nil {
-		return resourcesResponse, err
-	}
-	req.Header = http.Header{
-		"Authorization": []string{fmt.Sprintf("Bearer %s", token)},
-	}
-	resp, err := bc.Client.Do(req)
-	if err != nil {
-		return resourcesResponse, err
-	}
-	defer resp.Body.Close()
-
-	// Parse response
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return resourcesResponse, err
-	}
-	err = json.Unmarshal(body, &resourcesResponse)
-	if err != nil {
-		return resourcesResponse, err
-	}
-
-	return resourcesResponse, nil
-}
-
-func (bc *BugoutClient) DeleteResource(token, resourceID string) (BugoutResourceResponse, error) {
-	var resourceResponse BugoutResourceResponse
-
-	url := fmt.Sprintf("%s/resources/%s", configs.BUGOUT_AUTH_URL, resourceID)
-	req, err := http.NewRequest("DELETE", url, nil)
-	if err != nil {
-		return resourceResponse, err
-	}
-	req.Header = http.Header{
-		"Authorization": []string{fmt.Sprintf("Bearer %s", token)},
-	}
-	resp, err := bc.Client.Do(req)
-	if err != nil {
-		return resourceResponse, err
-	}
-	defer resp.Body.Close()
-
-	// Parse response
-	body, err := ioutil.ReadAll(resp.Body)
-	if err != nil {
-		return resourceResponse, err
-	}
-	err = json.Unmarshal(body, &resourceResponse)
-	if err != nil {
-		return resourceResponse, err
-	}
-
-	return resourceResponse, nil
-}

nodes/node_balancer/cmd/cli.go

@@ -6,6 +6,7 @@ import (
 	"fmt"
 	"os"
 
+	bugout "github.com/bugout-dev/bugout-go/pkg"
 	"github.com/bugout-dev/moonstream/nodes/node_balancer/configs"
 
 	"github.com/google/uuid"
@@ -13,6 +14,8 @@ import (
 
 var (
 	stateCLI StateCLI
+
+	bugoutClient bugout.BugoutClient
 )
 
 // Command Line Interface state
@@ -45,6 +48,21 @@ type StateCLI struct {
 	offsetFlag int
 }
 
+type PingResponse struct {
+	Status string `json:"status"`
+}
+
+type UserAccess struct {
+	UserID           string `json:"user_id"`
+	AccessID         string `json:"access_id"`
+	Name             string `json:"name"`
+	Description      string `json:"description"`
+	BlockchainAccess bool   `json:"blockchain_access"`
+	ExtendedMethods  bool   `json:"extended_methods"`
+
+	dataSource string
+}
+
 func (s *StateCLI) usage() {
 	fmt.Printf(`usage: nodebalancer [-h] {%[1]s,%[2]s,%[3]s,%[4]s,%[5]s} ...
 
@@ -174,23 +192,45 @@ func CLI() {
 			BlockchainAccess: stateCLI.blockchainAccessFlag,
 			ExtendedMethods:  stateCLI.extendedMethodsFlag,
 		}
-		userAccess, err := bugoutClient.AddUserAccess(configs.NB_CONTROLLER_TOKEN, proposedUserAccess)
+		_, err := bugoutClient.Brood.FindUser(
+			configs.NB_CONTROLLER_TOKEN,
+			map[string]string{
+				"user_id":        proposedUserAccess.UserID,
+				"application_id": configs.NB_APPLICATION_ID,
+			},
+		)
+		if err != nil {
+			fmt.Printf("User does not exists %v\n", err)
+			os.Exit(1)
+		}
+		resource, err := bugoutClient.Brood.CreateResource(configs.NB_CONTROLLER_TOKEN, configs.NB_APPLICATION_ID, proposedUserAccess)
 		if err != nil {
 			fmt.Printf("Unable to create user access %v\n", err)
 			os.Exit(1)
 		}
-		userAccessJson, err := json.Marshal(userAccess)
+		resource_data, err := json.Marshal(resource.ResourceData)
 		if err != nil {
-			fmt.Printf("Unable to marshal user access struct %v\n", err)
+			fmt.Printf("Unable to encode resource %s data interface to json %v", resource.Id, err)
 			os.Exit(1)
 		}
-		fmt.Println(string(userAccessJson))
+		fmt.Println(string(resource_data))
 
 	case "delete-access":
 		stateCLI.deleteAccessCmd.Parse(os.Args[2:])
 		stateCLI.checkRequirements()
 
-		resources, err := bugoutClient.GetResources(configs.NB_CONTROLLER_TOKEN, stateCLI.userIDFlag, stateCLI.accessIDFlag)
+		queryParameters := make(map[string]string)
+		if stateCLI.userIDFlag != "" {
+			queryParameters["user_id"] = stateCLI.userIDFlag
+		}
+		if stateCLI.accessIDFlag != "" {
+			queryParameters["access_id"] = stateCLI.accessIDFlag
+		}
+		resources, err := bugoutClient.Brood.GetResources(
+			configs.NB_CONTROLLER_TOKEN,
+			configs.NB_APPLICATION_ID,
+			queryParameters,
+		)
 		if err != nil {
 			fmt.Printf("Unable to get Bugout resources %v\n", err)
 			os.Exit(1)
@@ -198,12 +238,23 @@ func CLI() {
 
 		var userAccesses []UserAccess
 		for _, resource := range resources.Resources {
-			deletedResource, err := bugoutClient.DeleteResource(configs.NB_CONTROLLER_TOKEN, resource.ID)
+			deletedResource, err := bugoutClient.Brood.DeleteResource(configs.NB_CONTROLLER_TOKEN, resource.Id)
 			if err != nil {
-				fmt.Printf("Unable to delete resource with id %s %v\n", resource.ID, err)
+				fmt.Printf("Unable to delete resource %s %v\n", resource.Id, err)
 				continue
 			}
-			userAccesses = append(userAccesses, deletedResource.ResourceData)
+			resource_data, err := json.Marshal(deletedResource.ResourceData)
+			if err != nil {
+				fmt.Printf("Unable to encode resource %s data interface to json %v", resource.Id, err)
+				continue
+			}
+			var userAccess UserAccess
+			err = json.Unmarshal(resource_data, &userAccess)
+			if err != nil {
+				fmt.Printf("Unable to decode resource %s data json to structure %v", resource.Id, err)
+				continue
+			}
+			userAccesses = append(userAccesses, userAccess)
 		}
 
 		userAccessesJson, err := json.Marshal(userAccesses)
@@ -223,7 +274,18 @@ func CLI() {
 		stateCLI.usersCmd.Parse(os.Args[2:])
 		stateCLI.checkRequirements()
 
-		resources, err := bugoutClient.GetResources(configs.NB_CONTROLLER_TOKEN, stateCLI.userIDFlag, stateCLI.accessIDFlag)
+		var queryParameters map[string]string
+		if stateCLI.userIDFlag != "" {
+			queryParameters["user_id"] = stateCLI.userIDFlag
+		}
+		if stateCLI.accessIDFlag != "" {
+			queryParameters["access_id"] = stateCLI.accessIDFlag
+		}
+		resources, err := bugoutClient.Brood.GetResources(
+			configs.NB_CONTROLLER_TOKEN,
+			configs.NB_APPLICATION_ID,
+			queryParameters,
+		)
 		if err != nil {
 			fmt.Printf("Unable to get Bugout resources %v\n", err)
 			os.Exit(1)
@@ -240,8 +302,19 @@ func CLI() {
 			limit = len(resources.Resources[offset:]) + offset
 		}
 
-		for _, resourceData := range resources.Resources[offset:limit] {
+		for _, resource := range resources.Resources[offset:limit] {
-			userAccesses = append(userAccesses, resourceData.ResourceData)
+			resource_data, err := json.Marshal(resource.ResourceData)
+			if err != nil {
+				fmt.Printf("Unable to encode resource %s data interface to json %v", resource.Id, err)
+				continue
+			}
+			var userAccess UserAccess
+			err = json.Unmarshal(resource_data, &userAccess)
+			if err != nil {
+				fmt.Printf("Unable to decode resource %s data json to structure %v", resource.Id, err)
+				continue
+			}
+			userAccesses = append(userAccesses, userAccess)
 		}
 		userAccessesJson, err := json.Marshal(userAccesses)
 		if err != nil {
@@ -265,5 +338,11 @@ func CLI() {
 func init() {
 	configs.VerifyEnvironments()
 
-	InitBugoutClient()
+	// Init bugout client
+	bc, err := bugout.ClientFromEnv()
+	if err != nil {
+		fmt.Printf("Unable to initialize bugout client %v", err)
+		os.Exit(1)
+	}
+	bugoutClient = bc
 }

nodes/node_balancer/cmd/middleware.go

@@ -139,7 +139,11 @@ func accessMiddleware(next http.Handler) http.Handler {
 			currentUserAccess = controllerUserAccess
 			currentUserAccess.dataSource = dataSource
 		} else {
-			resources, err := bugoutClient.GetResources(configs.NB_CONTROLLER_TOKEN, "", accessID)
+			resources, err := bugoutClient.Brood.GetResources(
+				configs.NB_CONTROLLER_TOKEN,
+				configs.NB_APPLICATION_ID,
+				map[string]string{"access_id": accessID},
+			)
 			if err != nil {
 				http.Error(w, "Unable to get user with provided access identifier", http.StatusForbidden)
 				return
@@ -148,7 +152,17 @@ func accessMiddleware(next http.Handler) http.Handler {
 				http.Error(w, "User with provided access identifier not found", http.StatusForbidden)
 				return
 			}
-			userAccess := resources.Resources[0].ResourceData
+			resource_data, err := json.Marshal(resources.Resources[0].ResourceData)
+			if err != nil {
+				http.Error(w, "Unable to encode resource data interface to json", http.StatusInternalServerError)
+				return
+			}
+			var userAccess UserAccess
+			err = json.Unmarshal(resource_data, &userAccess)
+			if err != nil {
+				http.Error(w, "Unable to decode resource data json to structure", http.StatusInternalServerError)
+				return
+			}
 			currentUserAccess = UserAccess{
 				UserID:           userAccess.UserID,
 				AccessID:         userAccess.AccessID,

nodes/node_balancer/cmd/server.go

@@ -5,6 +5,7 @@ package cmd
 
 import (
 	"context"
+	"encoding/json"
 	"fmt"
 	"log"
 	"net/http"
@@ -111,11 +112,27 @@ func Server() {
 	// Record system information
 	reporter.Publish(humbug.SystemReport())
 
-	resources, err := bugoutClient.GetResources(configs.NB_CONTROLLER_TOKEN, "", configs.NB_CONTROLLER_ACCESS_ID)
+	// TODO(kompotkot): Remove, make it work without brood for internal crawlers
+	resources, err := bugoutClient.Brood.GetResources(
+		configs.NB_CONTROLLER_TOKEN,
+		configs.NB_APPLICATION_ID,
+		map[string]string{"access_id": configs.NB_CONTROLLER_ACCESS_ID},
+	)
 	if err != nil {
-		fmt.Printf("Unable to access Bugout authentication server %v", err)
+		fmt.Printf("Unable to get user with provided access identifier %v", err)
+	}
+	if len(resources.Resources) == 0 {
+		fmt.Printf("User with provided access identifier not found %v", err)
+	}
+	resource_data, err := json.Marshal(resources.Resources[0].ResourceData)
+	if err != nil {
+		fmt.Printf("Unable to encode resource data interface to json %v", err)
+	}
+	var userAccess UserAccess
+	err = json.Unmarshal(resource_data, &userAccess)
+	if err != nil {
+		fmt.Printf("Unable to decode resource data json to structure %v", err)
 	}
-	userAccess := resources.Resources[0].ResourceData
 	controllerUserAccess = UserAccess{
 		UserID:           userAccess.UserID,
 		AccessID:         userAccess.AccessID,