// CreateHandler handles creation of the connectivity entry in the database
// This is a multipart handler. See following example curl request
-// curl -i -F "metadata={\"cloud-region\":\"kud\",\"cloud-owner\":\"me\"};type=application/json" \
-// -F file=@/home/user/.kube/config \
-// -X POST http://localhost:8081/v1/connectivity-info
+//
+// curl -i -F "metadata={\"cloud-region\":\"kud\",\"cloud-owner\":\"me\"};type=application/json" \
+// -F file=@/home/user/.kube/config \
+// -X POST http://localhost:8081/v1/connectivity-info
func (h connectionHandler) createHandler(w http.ResponseWriter, r *http.Request) {
var v connection.Connection
v.Kubeconfig = base64.StdEncoding.EncodeToString(content)
- ret, err := h.client.Create(v)
+ ret, err := h.client.Create(r.Context(), v)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
vars := mux.Vars(r)
name := vars["connname"]
- ret, err := h.client.Get(name)
+ ret, err := h.client.Get(r.Context(), name)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
vars := mux.Vars(r)
name := vars["connname"]
- err := h.client.Delete(name)
+ err := h.client.Delete(r.Context(), name)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
package api
import (
+ "context"
"encoding/json"
"io"
"io/ioutil"
http.Error(w, err.Error(), http.StatusUnprocessableEntity)
return
}
- h.createOrUpdateHandler(v, w, false)
+ h.createOrUpdateHandler(r.Context(), v, w, false)
}
// createOrUpdateHandler handles creation of the definition entry in the database
v.RBVersion = version
v.RBName = name
- h.createOrUpdateHandler(v, w, true)
+ h.createOrUpdateHandler(r.Context(), v, w, true)
}
// createOrUpdateHandler handles creation of the definition entry in the database
-func (h rbDefinitionHandler) createOrUpdateHandler(v rb.Definition, w http.ResponseWriter, update bool) {
+func (h rbDefinitionHandler) createOrUpdateHandler(ctx context.Context, v rb.Definition, w http.ResponseWriter, update bool) {
// Name is required.
if v.RBName == "" {
http.Error(w, "Missing name in request", http.StatusBadRequest)
var ret rb.Definition
var err error
if update {
- ret, err = h.client.Update(v)
+ ret, err = h.client.Update(ctx, v)
} else {
- ret, err = h.client.Create(v)
+ ret, err = h.client.Create(ctx, v)
}
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
- err = h.client.Upload(name, version, inpBytes)
+ err = h.client.Upload(r.Context(), name, version, inpBytes)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
vars := mux.Vars(r)
name := vars["rbname"]
- ret, err := h.client.List(name)
+ ret, err := h.client.List(r.Context(), name)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
// Returns a list of rb.Definitions
func (h rbDefinitionHandler) listAllHandler(w http.ResponseWriter, r *http.Request) {
- ret, err := h.client.List("")
+ ret, err := h.client.List(r.Context(), "")
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
name := vars["rbname"]
version := vars["rbversion"]
- ret, err := h.client.Get(name, version)
+ ret, err := h.client.Get(r.Context(), name, version)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
name := vars["rbname"]
version := vars["rbversion"]
- err := h.client.Delete(name, version)
+ err := h.client.Delete(r.Context(), name, version)
if err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
import (
"bytes"
+ "context"
"encoding/json"
"io"
"net/http"
pkgerrors "github.com/pkg/errors"
)
-//Creating an embedded interface via anonymous variable
-//This allows us to make mockDB satisfy the DatabaseConnection
-//interface even if we are not implementing all the methods in it
+// Creating an embedded interface via anonymous variable
+// This allows us to make mockDB satisfy the DatabaseConnection
+// interface even if we are not implementing all the methods in it
type mockRBDefinition struct {
rb.DefinitionManager
// Items and err will be used to customize each test
Err error
}
-func (m *mockRBDefinition) Create(inp rb.Definition) (rb.Definition, error) {
+func (m *mockRBDefinition) Create(ctx context.Context, inp rb.Definition) (rb.Definition, error) {
if m.Err != nil {
return rb.Definition{}, m.Err
}
return m.Items[0], nil
}
-func (m *mockRBDefinition) List(name string) ([]rb.Definition, error) {
+func (m *mockRBDefinition) List(ctx context.Context, name string) ([]rb.Definition, error) {
if m.Err != nil {
return []rb.Definition{}, m.Err
}
return m.Items, nil
}
-func (m *mockRBDefinition) Get(name, version string) (rb.Definition, error) {
+func (m *mockRBDefinition) Get(ctx context.Context, name, version string) (rb.Definition, error) {
if m.Err != nil {
return rb.Definition{}, m.Err
}
return m.Items[0], nil
}
-func (m *mockRBDefinition) Delete(name, version string) error {
+func (m *mockRBDefinition) Delete(ctx context.Context, name, version string) error {
return m.Err
}
-func (m *mockRBDefinition) Upload(name, version string, inp []byte) error {
+func (m *mockRBDefinition) Upload(ctx context.Context, name, version string, inp []byte) error {
return m.Err
}
func (k *KubernetesClient) getKubeConfig(cloudregion string) (string, error) {
conn := connection.NewConnectionClient()
- kubeConfigPath, err := conn.Download(cloudregion)
+ kubeConfigPath, err := conn.Download(context.TODO(), cloudregion)
if err != nil {
return "", pkgerrors.Wrap(err, "Downloading kubeconfig")
}
return nil
}
-//GetMapper returns the RESTMapper that was created for this client
+// GetMapper returns the RESTMapper that was created for this client
func (k *KubernetesClient) GetMapper() meta.RESTMapper {
return k.restMapper
}
-//GetDynamicClient returns the dynamic client that is needed for
-//unstructured REST calls to the apiserver
+// GetDynamicClient returns the dynamic client that is needed for
+// unstructured REST calls to the apiserver
func (k *KubernetesClient) GetDynamicClient() dynamic.Interface {
return k.dynamicClient
}
return k.clientSet
}
-//GetInstanceID returns the instanceID that is injected into all the
-//resources created by the plugin
+// GetInstanceID returns the instanceID that is injected into all the
+// resources created by the plugin
func (k *KubernetesClient) GetInstanceID() string {
return k.instanceID
}
} else {
log.Printf("Using Definition Template as a Configuration Template")
defClient := rb.NewDefinitionClient()
- definition, err := defClient.Get(rbName, rbVersion)
+ definition, err := defClient.Get(context.TODO(), rbName, rbVersion)
if err != nil {
return configResourceList{}, pkgerrors.Wrap(err, "Get RB Definition")
}
- def, err = defClient.Download(rbName, rbVersion)
+ def, err = defClient.Download(context.TODO(), rbName, rbVersion)
if err != nil {
return configResourceList{}, pkgerrors.Wrap(err, "Downloading RB Definition Template")
}
// ConnectionManager is an interface exposes the Connection functionality
type ConnectionManager interface {
- Create(c Connection) (Connection, error)
- Get(name string) (Connection, error)
- Delete(name string) error
- GetConnectivityRecordByName(connname string, name string) (map[string]string, error)
+ Create(ctx context.Context, c Connection) (Connection, error)
+ Get(ctx context.Context, name string) (Connection, error)
+ Delete(ctx context.Context, name string) error
+ GetConnectivityRecordByName(ctx context.Context, connname string, name string) (map[string]string, error)
}
// ConnectionClient implements the ConnectionManager
}
// Create an entry for the Connection resource in the database`
-func (v *ConnectionClient) Create(c Connection) (Connection, error) {
+func (v *ConnectionClient) Create(ctx context.Context, c Connection) (Connection, error) {
//Construct composite key consisting of name
key := ConnectionKey{CloudRegion: c.CloudRegion}
//Check if this Connection already exists
- _, err := v.Get(c.CloudRegion)
+ _, err := v.Get(ctx, c.CloudRegion)
if err == nil {
return Connection{}, pkgerrors.New("Connection already exists")
}
- err = db.DBconn.Create(context.TODO(), v.storeName, key, v.tagMeta, c)
+ err = db.DBconn.Create(ctx, v.storeName, key, v.tagMeta, c)
if err != nil {
return Connection{}, pkgerrors.Wrap(err, "Creating DB Entry")
}
}
// Get returns Connection for corresponding to name
-func (v *ConnectionClient) Get(name string) (Connection, error) {
+func (v *ConnectionClient) Get(ctx context.Context, name string) (Connection, error) {
//Construct the composite key to select the entry
key := ConnectionKey{CloudRegion: name}
- value, err := db.DBconn.Read(context.TODO(), v.storeName, key, v.tagMeta)
+ value, err := db.DBconn.Read(ctx, v.storeName, key, v.tagMeta)
if err != nil {
return Connection{}, pkgerrors.Wrap(err, "Get Connection")
}
// “cert-to-present” : “<contents of certificate to present to server>” , //valid if ssl-initiator is true
// },
// ]
-func (v *ConnectionClient) GetConnectivityRecordByName(connectionName string,
+func (v *ConnectionClient) GetConnectivityRecordByName(ctx context.Context, connectionName string,
connectivityRecordName string) (map[string]string, error) {
- conn, err := v.Get(connectionName)
+ conn, err := v.Get(ctx, connectionName)
if err != nil {
return nil, pkgerrors.Wrap(err, "Error getting connection")
}
}
// Delete the Connection from database
-func (v *ConnectionClient) Delete(name string) error {
+func (v *ConnectionClient) Delete(ctx context.Context, name string) error {
//Construct the composite key to select the entry
key := ConnectionKey{CloudRegion: name}
- err := db.DBconn.Delete(context.TODO(), v.storeName, key, v.tagMeta)
+ err := db.DBconn.Delete(ctx, v.storeName, key, v.tagMeta)
if err != nil {
return pkgerrors.Wrap(err, "Delete Connection")
}
// Download the connection information onto a kubeconfig file
// The file is named after the name of the connection and will
// be placed in the provided parent directory
-func (v *ConnectionClient) Download(name string) (string, error) {
+func (v *ConnectionClient) Download(ctx context.Context, name string) (string, error) {
- conn, err := v.Get(name)
+ conn, err := v.Get(ctx, name)
if err != nil {
return "", pkgerrors.Wrap(err, "Getting Connection info")
}
}
//Check if provided resource bundle information is valid
- rbDef, err := NewDefinitionClient().Get(rbName, rbVersion)
+ rbDef, err := NewDefinitionClient().Get(context.TODO(), rbName, rbVersion)
if err != nil {
return pkgerrors.Errorf("Invalid Resource Bundle ID provided: %s", err.Error())
}
// DefinitionManager is an interface exposes the resource bundle definition functionality
type DefinitionManager interface {
- Create(def Definition) (Definition, error)
- Update(def Definition) (Definition, error)
- List(name string) ([]Definition, error)
- Get(name string, version string) (Definition, error)
- Delete(name string, version string) error
- Upload(name string, version string, inp []byte) error
+ Create(ctx context.Context, def Definition) (Definition, error)
+ Update(ctx context.Context, def Definition) (Definition, error)
+ List(ctx context.Context, name string) ([]Definition, error)
+ Get(ctx context.Context, name string, version string) (Definition, error)
+ Delete(ctx context.Context, name string, version string) error
+ Upload(ctx context.Context, name string, version string, inp []byte) error
}
// DefinitionClient implements the DefinitionManager
}
// Create an entry for the resource in the database`
-func (v *DefinitionClient) Create(def Definition) (Definition, error) {
+func (v *DefinitionClient) Create(ctx context.Context, def Definition) (Definition, error) {
//Construct composite key consisting of name and version
key := DefinitionKey{RBName: def.RBName, RBVersion: def.RBVersion}
//Check if this definition already exists
- _, err := v.Get(def.RBName, def.RBVersion)
+ _, err := v.Get(ctx, def.RBName, def.RBVersion)
if err == nil {
return Definition{}, pkgerrors.New("Definition already exists")
}
- err = db.DBconn.Create(context.TODO(), v.storeName, key, v.tagMeta, def)
+ err = db.DBconn.Create(ctx, v.storeName, key, v.tagMeta, def)
if err != nil {
return Definition{}, pkgerrors.Wrap(err, "Creating DB Entry")
}
}
// Update an entry for the resource in the database`
-func (v *DefinitionClient) Update(def Definition) (Definition, error) {
+func (v *DefinitionClient) Update(ctx context.Context, def Definition) (Definition, error) {
//Construct composite key consisting of name and version
key := DefinitionKey{RBName: def.RBName, RBVersion: def.RBVersion}
//Check if this definition already exists
- _, err := v.Get(def.RBName, def.RBVersion)
+ _, err := v.Get(ctx, def.RBName, def.RBVersion)
if err != nil {
return Definition{}, pkgerrors.New("Definition does not exists")
}
- err = db.DBconn.Update(context.TODO(), v.storeName, key, v.tagMeta, def)
+ err = db.DBconn.Update(ctx, v.storeName, key, v.tagMeta, def)
if err != nil {
return Definition{}, pkgerrors.Wrap(err, "Updating DB Entry")
}
}
// List all resource entry's versions in the database
-func (v *DefinitionClient) List(name string) ([]Definition, error) {
- res, err := db.DBconn.ReadAll(context.TODO(), v.storeName, v.tagMeta)
+func (v *DefinitionClient) List(ctx context.Context, name string) ([]Definition, error) {
+ res, err := db.DBconn.ReadAll(ctx, v.storeName, v.tagMeta)
if err != nil || len(res) == 0 {
return []Definition{}, pkgerrors.Wrap(err, "Listing Resource Bundle Definitions")
}
}
// Get returns the Resource Bundle Definition for corresponding ID
-func (v *DefinitionClient) Get(name string, version string) (Definition, error) {
+func (v *DefinitionClient) Get(ctx context.Context, name string, version string) (Definition, error) {
//Construct the composite key to select the entry
key := DefinitionKey{RBName: name, RBVersion: version}
- value, err := db.DBconn.Read(context.TODO(), v.storeName, key, v.tagMeta)
+ value, err := db.DBconn.Read(ctx, v.storeName, key, v.tagMeta)
if err != nil {
return Definition{}, pkgerrors.Wrap(err, "Get Resource Bundle definition")
}
}
// Delete the Resource Bundle definition from database
-func (v *DefinitionClient) Delete(name string, version string) error {
+func (v *DefinitionClient) Delete(ctx context.Context, name string, version string) error {
//Construct the composite key to select the entry
key := DefinitionKey{RBName: name, RBVersion: version}
- err := db.DBconn.Delete(context.TODO(), v.storeName, key, v.tagMeta)
+ err := db.DBconn.Delete(ctx, v.storeName, key, v.tagMeta)
if err != nil {
return pkgerrors.Wrap(err, "Delete Resource Bundle Definition")
}
//Delete the content when the delete operation happens
- err = db.DBconn.Delete(context.TODO(), v.storeName, key, v.tagContent)
+ err = db.DBconn.Delete(ctx, v.storeName, key, v.tagContent)
if err != nil {
return pkgerrors.Wrap(err, "Delete Resource Bundle Definition Content")
}
}
// Upload the contents of resource bundle into database
-func (v *DefinitionClient) Upload(name string, version string, inp []byte) error {
+func (v *DefinitionClient) Upload(ctx context.Context, name string, version string, inp []byte) error {
//Check if definition metadata exists
- def, err := v.Get(name, version)
+ def, err := v.Get(ctx, name, version)
if err != nil {
return pkgerrors.Errorf("Invalid Definition ID provided: %s", err.Error())
}
}
//TODO: Use db update api once db supports it.
- err = db.DBconn.Create(context.TODO(), v.storeName, key, v.tagMeta, def)
+ err = db.DBconn.Create(ctx, v.storeName, key, v.tagMeta, def)
if err != nil {
return pkgerrors.Wrap(err, "Storing updated chart metadata")
}
//Encode given byte stream to text for storage
encodedStr := base64.StdEncoding.EncodeToString(inp)
- err = db.DBconn.Create(context.TODO(), v.storeName, key, v.tagContent, encodedStr)
+ err = db.DBconn.Create(ctx, v.storeName, key, v.tagContent, encodedStr)
if err != nil {
return pkgerrors.Errorf("Error uploading data to db: %s", err.Error())
}
// Download the contents of the resource bundle definition from DB
// Returns a byte array of the contents which is used by the
// ExtractTarBall code to create the folder structure on disk
-func (v *DefinitionClient) Download(name string, version string) ([]byte, error) {
+func (v *DefinitionClient) Download(ctx context.Context, name string, version string) ([]byte, error) {
//ignore the returned data here
//Check if id is valid
- _, err := v.Get(name, version)
+ _, err := v.Get(ctx, name, version)
if err != nil {
return nil, pkgerrors.Errorf("Invalid Definition ID provided: %s", err.Error())
}
//Construct the composite key to select the entry
key := DefinitionKey{RBName: name, RBVersion: version}
- value, err := db.DBconn.Read(context.TODO(), v.storeName, key, v.tagContent)
+ value, err := db.DBconn.Read(ctx, v.storeName, key, v.tagContent)
if err != nil {
return nil, pkgerrors.Wrap(err, "Get Resource Bundle definition content")
}
import (
"bytes"
+ "context"
"reflect"
"sort"
"strings"
t.Run(testCase.label, func(t *testing.T) {
db.DBconn = testCase.mockdb
impl := NewDefinitionClient()
- got, err := impl.Create(testCase.inp)
+ got, err := impl.Create(context.TODO(), testCase.inp)
if err != nil {
if testCase.expectedError == "" {
t.Fatalf("Create returned an unexpected error %s", err)
t.Run(testCase.label, func(t *testing.T) {
db.DBconn = testCase.mockdb
impl := NewDefinitionClient()
- got, err := impl.List(testCase.name)
+ got, err := impl.List(context.TODO(), testCase.name)
if err != nil {
if testCase.expectedError == "" {
t.Fatalf("List returned an unexpected error %s", err)
t.Run(testCase.label, func(t *testing.T) {
db.DBconn = testCase.mockdb
impl := NewDefinitionClient()
- got, err := impl.Get(testCase.name, testCase.version)
+ got, err := impl.Get(context.TODO(), testCase.name, testCase.version)
if err != nil {
if testCase.expectedError == "" {
t.Fatalf("Get returned an unexpected error %s", err)
t.Run(testCase.label, func(t *testing.T) {
db.DBconn = testCase.mockdb
impl := NewDefinitionClient()
- err := impl.Delete(testCase.name, testCase.version)
+ err := impl.Delete(context.TODO(), testCase.name, testCase.version)
if err != nil {
if testCase.expectedError == "" {
t.Fatalf("Delete returned an unexpected error %s", err)
t.Run(testCase.label, func(t *testing.T) {
db.DBconn = testCase.mockdb
impl := NewDefinitionClient()
- err := impl.Upload(testCase.name, testCase.version, testCase.content)
+ err := impl.Upload(context.TODO(), testCase.name, testCase.version, testCase.content)
if err != nil {
if testCase.expectedError == "" {
t.Errorf("Upload returned an unexpected error %s", err)
t.Run(testCase.label, func(t *testing.T) {
db.DBconn = testCase.mockdb
impl := NewDefinitionClient()
- data, err := impl.Download(testCase.name, testCase.version)
+ data, err := impl.Download(context.TODO(), testCase.name, testCase.version)
if err != nil {
if testCase.expectedError == "" {
t.Errorf("Download returned an unexpected error %s", err)
return Profile{}, pkgerrors.New("Profile does not exists for this Definition")
}
//Check if provided resource bundle information is valid
- _, err = NewDefinitionClient().Get(p.RBName, p.RBVersion)
+ _, err = NewDefinitionClient().Get(context.TODO(), p.RBName, p.RBVersion)
if err != nil {
return Profile{}, pkgerrors.Errorf("Invalid Resource Bundle ID provided: %s", err.Error())
}
definitionClient := NewDefinitionClient()
- definition, err := definitionClient.Get(rbName, rbVersion)
+ definition, err := definitionClient.Get(context.TODO(), rbName, rbVersion)
if err != nil {
return sortedTemplates, crdList, hookList, finalReleaseName, pkgerrors.Wrap(err, "Getting Definition Metadata")
}
- defData, err := definitionClient.Download(rbName, rbVersion)
+ defData, err := definitionClient.Download(context.TODO(), rbName, rbVersion)
if err != nil {
return sortedTemplates, crdList, hookList, finalReleaseName, pkgerrors.Wrap(err, "Downloading Definition")
}
Code Review / multicloud / k8s.git / commitdiff