k8s_path="$(git rev-parse --show-toplevel)"
-VERSION="0.11.0-SNAPSHOT"
+VERSION="0.12.0-SNAPSHOT"
GO_VERSION="1.16"
export IMAGE_NAME="nexus3.onap.org:10003/onap/multicloud/k8s"
package app
import (
+ "context"
"fmt"
"log"
"strings"
//-> when it comes back, it will continue from next hook and consider that this one is done
if dbData != nil {
dbData.HookProgress = fmt.Sprintf("%d/%d", index+1, len(executingHooks))
- err := db.DBconn.Update(hc.dbStoreName, key, hc.dbTagInst, dbData)
+ err := db.DBconn.Update(context.TODO(), hc.dbStoreName, key, hc.dbTagInst, dbData)
if err != nil {
return err
}
key := InstanceKey{
ID: finalId,
}
- err = db.DBconn.Create(v.storeName, key, v.tagInst, dbData)
+ err = db.DBconn.Create(context.TODO(), v.storeName, key, v.tagInst, dbData)
if err != nil {
namegenerator.Release(generatedId)
return InstanceResponse{}, pkgerrors.Wrap(err, "Creating Instance DB Entry")
err = hookClient.ExecHook(k8sClient, hookList, release.HookPreInstall, hookTimeoutInfo.preInstallTimeOut, 0, &dbData)
if err != nil {
log.Printf("Error running preinstall hooks for release %s, Error: %s. Stop here", releaseName, err)
- err2 := db.DBconn.Delete(v.storeName, key, v.tagInst)
+ err2 := db.DBconn.Delete(context.TODO(), v.storeName, key, v.tagInst)
if err2 != nil {
log.Printf("Error cleaning failed instance in DB, please check DB.")
} else {
}
dbData.Status = "CREATING"
- err = db.DBconn.Update(v.storeName, key, v.tagInst, dbData)
+ err = db.DBconn.Update(context.TODO(), v.storeName, key, v.tagInst, dbData)
if err != nil {
- err2 := db.DBconn.Delete(v.storeName, key, v.tagInst)
+ err2 := db.DBconn.Delete(context.TODO(), v.storeName, key, v.tagInst)
if err2 != nil {
log.Printf("Delete Instance DB Entry for release %s has error.", releaseName)
} else {
}
log.Printf(" Instance: %s, Main rss are failed, skip post-install and remove instance in DB", finalId)
//main rss creation failed -> remove instance in DB
- err2 := db.DBconn.Delete(v.storeName, key, v.tagInst)
+ err2 := db.DBconn.Delete(context.TODO(), v.storeName, key, v.tagInst)
if err2 != nil {
log.Printf("Delete Instance DB Entry for release %s has error.", releaseName)
} else {
dbData.Status = "CREATED"
dbData.Resources = createdResources
- err = db.DBconn.Update(v.storeName, key, v.tagInst, dbData)
+ err = db.DBconn.Update(context.TODO(), v.storeName, key, v.tagInst, dbData)
if err != nil {
return InstanceResponse{}, pkgerrors.Wrap(err, "Update Instance DB Entry")
}
} else {
dbData.Status = "DONE"
}
- err = db.DBconn.Update(v.storeName, key, v.tagInst, dbData)
+ err = db.DBconn.Update(context.TODO(), v.storeName, key, v.tagInst, dbData)
if err != nil {
log.Printf("Update Instance DB Entry for release %s has error.", releaseName)
}
}()
} else {
dbData.Status = "DONE"
- err = db.DBconn.Update(v.storeName, key, v.tagInst, dbData)
+ err = db.DBconn.Update(context.TODO(), v.storeName, key, v.tagInst, dbData)
if err != nil {
log.Printf("Update Instance DB Entry for release %s has error.", releaseName)
}
key := InstanceKey{
ID: id,
}
- value, err := db.DBconn.Read(v.storeName, key, v.tagInst)
+ value, err := db.DBconn.Read(context.TODO(), v.storeName, key, v.tagInst)
if err != nil {
return InstanceResponse{}, pkgerrors.Wrap(err, "Upgrade Instance")
}
oldKey := InstanceKey{
ID: newInstance.ID,
}
- err2 := db.DBconn.Delete(v.storeName, oldKey, v.tagInst)
+ err2 := db.DBconn.Delete(context.TODO(), v.storeName, oldKey, v.tagInst)
if err2 != nil {
log.Printf("Delete of the temporal instance from the DB has failed %s", err2.Error())
}
namegenerator.Release(newInstance.ID)
newInstanceDb.ID = id
newInstance.ID = id
- err = db.DBconn.Create(v.storeName, key, v.tagInst, newInstanceDb)
+ err = db.DBconn.Create(context.TODO(), v.storeName, key, v.tagInst, newInstanceDb)
if err != nil {
return newInstance, pkgerrors.Wrap(err, "Create Instance DB Entry after update failed")
}
return InstanceResponse{}, pkgerrors.Wrap(err, "Creating Namespace")
}
- err = db.DBconn.Update(v.storeName, key, v.tagInst, dbData)
+ err = db.DBconn.Update(context.TODO(), v.storeName, key, v.tagInst, dbData)
if err != nil {
return InstanceResponse{}, pkgerrors.Wrap(err, "Updating Instance DB Entry")
}
}
dbData.Status = "UPGRADING"
- err = db.DBconn.Update(v.storeName, key, v.tagInst, dbData)
+ err = db.DBconn.Update(context.TODO(), v.storeName, key, v.tagInst, dbData)
if err != nil {
return InstanceResponse{}, pkgerrors.Wrap(err, "Update Instance DB Entry")
}
dbData.Status = "UPGRADED"
dbData.Resources = upgradedResources
- err = db.DBconn.Update(v.storeName, key, v.tagInst, dbData)
+ err = db.DBconn.Update(context.TODO(), v.storeName, key, v.tagInst, dbData)
if err != nil {
return InstanceResponse{}, pkgerrors.Wrap(err, "Update Instance DB Entry")
}
} else {
dbData.Status = "DONE"
}
- err = db.DBconn.Update(v.storeName, key, v.tagInst, dbData)
+ err = db.DBconn.Update(context.TODO(), v.storeName, key, v.tagInst, dbData)
if err != nil {
log.Printf("Update Instance DB Entry for release %s has error.", releaseName)
}
}()
} else {
dbData.Status = "DONE"
- err = db.DBconn.Update(v.storeName, key, v.tagInst, dbData)
+ err = db.DBconn.Update(context.TODO(), v.storeName, key, v.tagInst, dbData)
if err != nil {
log.Printf("Update Instance DB Entry for release %s has error.", releaseName)
}
key := InstanceKey{
ID: id,
}
- value, err := db.DBconn.Read(v.storeName, key, v.tagInst)
+ value, err := db.DBconn.Read(context.TODO(), v.storeName, key, v.tagInst)
if err != nil {
return InstanceDbData{}, pkgerrors.Wrap(err, "Get Instance")
}
key := InstanceKey{
ID: id,
}
- value, err := db.DBconn.Read(v.storeName, key, v.tagInst)
+ value, err := db.DBconn.Read(context.TODO(), v.storeName, key, v.tagInst)
if err != nil {
return InstanceResponse{}, pkgerrors.Wrap(err, "Get Instance")
}
key := InstanceKey{
ID: id,
}
- value, err := db.DBconn.Read(v.storeName, key, v.tagInst)
+ value, err := db.DBconn.Read(context.TODO(), v.storeName, key, v.tagInst)
if err != nil {
return InstanceStatus{}, pkgerrors.Wrap(err, "Get Instance")
}
ID: id,
}
- value, err := db.DBconn.Read(v.storeName, key, v.tagInst)
+ value, err := db.DBconn.Read(context.TODO(), v.storeName, key, v.tagInst)
if err != nil {
return InstanceStatus{}, pkgerrors.Wrap(err, "Get Instance")
}
// Empty string returns all
func (v *InstanceClient) List(rbname, rbversion, profilename string) ([]InstanceMiniResponse, error) {
- dbres, err := db.DBconn.ReadAll(v.storeName, v.tagInst)
+ dbres, err := db.DBconn.ReadAll(context.TODO(), v.storeName, v.tagInst)
if err != nil || len(dbres) == 0 {
return []InstanceMiniResponse{}, pkgerrors.Wrap(err, "Listing Instances")
}
}
if inst.Status == "DELETED" {
//The instance is deleted when the plugin comes back -> just remove from Db
- err = db.DBconn.Delete(v.storeName, key, v.tagInst)
+ err = db.DBconn.Delete(context.TODO(), v.storeName, key, v.tagInst)
if err != nil {
log.Printf("Delete Instance DB Entry for release %s has error.", inst.ReleaseName)
}
inst.Status = "PRE-DELETE"
inst.HookProgress = ""
- err = db.DBconn.Update(v.storeName, key, v.tagInst, inst)
+ err = db.DBconn.Update(context.TODO(), v.storeName, key, v.tagInst, inst)
if err != nil {
log.Printf("Update Instance DB Entry for release %s has error.", inst.ReleaseName)
}
if err != nil {
log.Printf(" Instance: %s, Error running pre-delete hooks error: %s", id, err)
inst.Status = "PRE-DELETE-FAILED"
- err2 := db.DBconn.Update(v.storeName, key, v.tagInst, inst)
+ err2 := db.DBconn.Update(context.TODO(), v.storeName, key, v.tagInst, inst)
if err2 != nil {
log.Printf("Update Instance DB Entry for release %s has error.", inst.ReleaseName)
}
}
inst.Status = "DELETING"
- err = db.DBconn.Update(v.storeName, key, v.tagInst, inst)
+ err = db.DBconn.Update(context.TODO(), v.storeName, key, v.tagInst, inst)
if err != nil {
log.Printf("Update Instance DB Entry for release %s has error.", inst.ReleaseName)
}
log.Printf(err.Error())
}
- err = db.DBconn.Delete(v.storeName, key, v.tagInst)
+ err = db.DBconn.Delete(context.TODO(), v.storeName, key, v.tagInst)
if err != nil {
return pkgerrors.Wrap(err, "Delete Instance")
}
log.Printf(" Resolving template for release %s", instance.Request.ReleaseName)
_, _, hookList, _, err := rb.NewProfileClient().Resolve(instance.Request.RBName, instance.Request.RBVersion, instance.Request.ProfileName, overrideValues, instance.Request.ReleaseName)
instance.Hooks = hookList
- err = db.DBconn.Update(v.storeName, key, v.tagInst, instance)
+ err = db.DBconn.Update(context.TODO(), v.storeName, key, v.tagInst, instance)
if err != nil {
return pkgerrors.Wrap(err, "Update Instance DB Entry")
}
} else {
instance.Status = "DONE"
}
- err = db.DBconn.Update(v.storeName, key, v.tagInst, instance)
+ err = db.DBconn.Update(context.TODO(), v.storeName, key, v.tagInst, instance)
if err != nil {
log.Printf("Update Instance DB Entry for release %s has error.", instance.ReleaseName)
}
if err != nil {
log.Printf(" Instance: %s, Error running pre-delete hooks error: %s", id, err)
instance.Status = "PRE-DELETE-FAILED"
- err = db.DBconn.Update(v.storeName, key, v.tagInst, instance)
+ err = db.DBconn.Update(context.TODO(), v.storeName, key, v.tagInst, instance)
if err != nil {
log.Printf("Update Instance DB Entry for release %s has error.", instance.ReleaseName)
}
ID: instance.ID,
}
instance.Status = "POST-DELETE"
- err := db.DBconn.Update(v.storeName, key, v.tagInst, instance)
+ err := db.DBconn.Update(context.TODO(), v.storeName, key, v.tagInst, instance)
if err != nil {
log.Printf("Update Instance DB Entry for release %s has error.", instance.ReleaseName)
}
//If this case happen, user should clean the cluster
log.Printf(" Instance: %s, Error running post-delete hooks error: %s", instance.ID, err)
instance.Status = "POST-DELETE-FAILED"
- err2 := db.DBconn.Update(v.storeName, key, v.tagInst, instance)
+ err2 := db.DBconn.Update(context.TODO(), v.storeName, key, v.tagInst, instance)
if err2 != nil {
log.Printf("Update Instance DB Entry for release %s has error.", instance.ReleaseName)
return pkgerrors.Wrap(err2, "Delete Instance DB Entry")
if err != nil {
log.Printf(err.Error())
}
- err = db.DBconn.Delete(v.storeName, key, v.tagInst)
+ err = db.DBconn.Delete(context.TODO(), v.storeName, key, v.tagInst)
if err != nil {
log.Printf("Delete Instance DB Entry for release %s has error.", instance.ReleaseName)
return pkgerrors.Wrap(err, "Delete Instance DB Entry")
}
} else {
instance.Status = "DELETED"
- err := db.DBconn.Update(v.storeName, key, v.tagInst, instance)
+ err := db.DBconn.Update(context.TODO(), v.storeName, key, v.tagInst, instance)
if err != nil {
log.Printf("Update Instance DB Entry for release %s has error.", instance.ReleaseName)
return pkgerrors.Wrap(err, "Update Instance DB Entry")
import (
"bytes"
+ "context"
"encoding/json"
"io/ioutil"
"net"
lock.Lock()
defer lock.Unlock()
- err = db.DBconn.Create(iss.storeName, key, iss.tagInst, sub)
+ err = db.DBconn.Create(context.TODO(), iss.storeName, key, iss.tagInst, sub)
if err != nil {
return sub, pkgerrors.Wrap(err, "Creating Status Subscription DB Entry")
}
InstanceId: instanceId,
SubscriptionName: subId,
}
- DBResp, err := db.DBconn.Read(iss.storeName, key, iss.tagInst)
+ DBResp, err := db.DBconn.Read(context.TODO(), iss.storeName, key, iss.tagInst)
if err != nil || DBResp == nil {
return StatusSubscription{}, pkgerrors.Wrap(err, "Error retrieving Subscription data")
}
lock.Lock()
defer lock.Unlock()
- err = db.DBconn.Update(iss.storeName, key, iss.tagInst, sub)
+ err = db.DBconn.Update(context.TODO(), iss.storeName, key, iss.tagInst, sub)
if err != nil {
return sub, pkgerrors.Wrap(err, "Updating Status Subscription DB Entry")
}
lock.Lock()
defer lock.Unlock()
// Retrieve info about created status subscriptions
- dbResp, err := db.DBconn.ReadAll(iss.storeName, iss.tagInst)
+ dbResp, err := db.DBconn.ReadAll(context.TODO(), iss.storeName, iss.tagInst)
if err != nil {
if !strings.Contains(err.Error(), "Did not find any objects with tag") {
return []StatusSubscription{}, pkgerrors.Wrap(err, "Getting Status Subscription data")
InstanceId: instanceId,
SubscriptionName: subId,
}
- err = db.DBconn.Delete(iss.storeName, key, iss.tagInst)
+ err = db.DBconn.Delete(context.TODO(), iss.storeName, key, iss.tagInst)
if err != nil {
return pkgerrors.Wrap(err, "Removing Status Subscription in DB")
}
})
currentSub.LastNotifyStatus = notifyResult.result
currentSub.LastNotifyTime = notifyResult.time
- err = db.DBconn.Update(iss.storeName, key, iss.tagInst, currentSub)
+ err = db.DBconn.Update(context.TODO(), iss.storeName, key, iss.tagInst, currentSub)
if err != nil {
log.Error("Error updating subscription status", log.Fields{
"error": err.Error(),
package connection
import (
+ "context"
"encoding/base64"
"encoding/json"
"io/ioutil"
return Connection{}, pkgerrors.New("Connection already exists")
}
- err = db.DBconn.Create(v.storeName, key, v.tagMeta, c)
+ err = db.DBconn.Create(context.TODO(), v.storeName, key, v.tagMeta, c)
if err != nil {
return Connection{}, pkgerrors.Wrap(err, "Creating DB Entry")
}
//Construct the composite key to select the entry
key := ConnectionKey{CloudRegion: name}
- value, err := db.DBconn.Read(v.storeName, key, v.tagMeta)
+ value, err := db.DBconn.Read(context.TODO(), v.storeName, key, v.tagMeta)
if err != nil {
return Connection{}, pkgerrors.Wrap(err, "Get Connection")
}
// GetConnectivityRecordByName returns Connection for corresponding to name
// JSON example:
// "connectivity-records" :
-// [
-// {
-// “connectivity-record-name” : “<name>”, // example: OVN
-// “FQDN-or-ip” : “<fqdn>”,
-// “ca-cert-to-verify-server” : “<contents of CA certificate to validate the OVN server>”,
-// “ssl-initiator” : “<true/false”>,
-// “user-name”: “<user name>”, //valid if ssl-initator is false
-// “password” : “<password>”, // valid if ssl-initiator is false
-// “private-key” : “<contents of private key in PEM>”, // valid if ssl-initiator is true
-// “cert-to-present” : “<contents of certificate to present to server>” , //valid if ssl-initiator is true
-// },
-// ]
+//
+// [
+// {
+// “connectivity-record-name” : “<name>”, // example: OVN
+// “FQDN-or-ip” : “<fqdn>”,
+// “ca-cert-to-verify-server” : “<contents of CA certificate to validate the OVN server>”,
+// “ssl-initiator” : “<true/false”>,
+// “user-name”: “<user name>”, //valid if ssl-initator is false
+// “password” : “<password>”, // valid if ssl-initiator is false
+// “private-key” : “<contents of private key in PEM>”, // valid if ssl-initiator is true
+// “cert-to-present” : “<contents of certificate to present to server>” , //valid if ssl-initiator is true
+// },
+// ]
func (v *ConnectionClient) GetConnectivityRecordByName(connectionName string,
connectivityRecordName string) (map[string]string, error) {
//Construct the composite key to select the entry
key := ConnectionKey{CloudRegion: name}
- err := db.DBconn.Delete(v.storeName, key, v.tagMeta)
+ err := db.DBconn.Delete(context.TODO(), v.storeName, key, v.tagMeta)
if err != nil {
return pkgerrors.Wrap(err, "Delete Connection")
}
package db
import (
+ "context"
+
k8sconfig "github.com/onap/multicloud-k8s/src/k8splugin/internal/config"
"github.com/hashicorp/consul/api"
}
// Create is used to create a DB entry
-func (c *ConsulStore) Create(root string, key Key, tag string, data interface{}) error {
+func (c *ConsulStore) Create(ctx context.Context, root string, key Key, tag string, data interface{}) error {
//Convert to string as Consul only supports string based keys
k := key.String()
}
// Update is used to update a DB entry
-func (c *ConsulStore) Update(root string, key Key, tag string, data interface{}) error {
- return c.Create(root, key, tag, data)
+func (c *ConsulStore) Update(ctx context.Context, root string, key Key, tag string, data interface{}) error {
+ return c.Create(ctx, root, key, tag, data)
}
// Read method returns the internalID for a particular externalID
-func (c *ConsulStore) Read(root string, key Key, tag string) ([]byte, error) {
+func (c *ConsulStore) Read(ctx context.Context, root string, key Key, tag string) ([]byte, error) {
//Convert to string as Consul only supports string based keys
k := key.String()
}
// Delete method removes an internalID from the Database
-func (c *ConsulStore) Delete(root string, key Key, tag string) error {
+func (c *ConsulStore) Delete(ctx context.Context, root string, key Key, tag string) error {
//Convert to string as Consul only supports string based keys
k := key.String()
}
// ReadAll is used to get all ExternalIDs in a namespace
-func (c *ConsulStore) ReadAll(root string, tag string) (map[string][]byte, error) {
+func (c *ConsulStore) ReadAll(ctx context.Context, root string, tag string) (map[string][]byte, error) {
pairs, _, err := c.client.List(root, nil)
if err != nil {
return nil, err
package db
import (
+ "context"
"reflect"
"strings"
"testing"
for _, testCase := range testCases {
t.Run(testCase.label, func(t *testing.T) {
client, _ := NewConsulStore(testCase.mock)
- err := client.Create(testCase.input["root"], testCase.key,
+ err := client.Create(context.TODO(), testCase.input["root"], testCase.key,
testCase.input["tag"], testCase.input["value"])
if err != nil {
if testCase.expectedError == "" {
for _, testCase := range testCases {
t.Run(testCase.label, func(t *testing.T) {
client, _ := NewConsulStore(testCase.mock)
- result, err := client.Read(testCase.input["root"], testCase.key,
+ result, err := client.Read(context.TODO(), testCase.input["root"], testCase.key,
testCase.input["tag"])
if err != nil {
if testCase.expectedError == "" {
for _, testCase := range testCases {
t.Run(testCase.label, func(t *testing.T) {
client, _ := NewConsulStore(testCase.mock)
- err := client.Delete(testCase.input["root"], testCase.key,
+ err := client.Delete(context.TODO(), testCase.input["root"], testCase.key,
testCase.input["tag"])
if err != nil {
if testCase.expectedError == "" {
for _, testCase := range testCases {
t.Run(testCase.label, func(t *testing.T) {
client, _ := NewConsulStore(testCase.mock)
- result, err := client.ReadAll(testCase.input["root"],
+ result, err := client.ReadAll(context.TODO(), testCase.input["root"],
testCase.input["tag"])
if err != nil {
if testCase.expectedError == "" {
}
// Create is used to create a DB entry
-func (m *MongoStore) Create(coll string, key Key, tag string, data interface{}) error {
+func (m *MongoStore) Create(ctx context.Context, coll string, key Key, tag string, data interface{}) error {
if data == nil || !m.validateParams(coll, key, tag) {
return pkgerrors.New("No Data to store")
}
c := getCollection(coll, m)
- ctx := context.Background()
//Insert the data and then add the objectID to the masterTable
res, err := c.InsertOne(ctx, bson.D{
}
// Update is used to update a DB entry
-func (m *MongoStore) Update(coll string, key Key, tag string, data interface{}) error {
+func (m *MongoStore) Update(ctx context.Context, coll string, key Key, tag string, data interface{}) error {
if data == nil || !m.validateParams(coll, key, tag) {
return pkgerrors.New("No Data to update")
}
c := getCollection(coll, m)
- ctx := context.Background()
//Get the masterkey document based on given key
filter := bson.D{{"key", key}}
- keydata, err := decodeBytes(c.FindOne(context.Background(), filter))
+ keydata, err := decodeBytes(c.FindOne(ctx, filter))
if err != nil {
return pkgerrors.Errorf("Error finding master table: %s", err.Error())
}
}
// Read method returns the data stored for this key and for this particular tag
-func (m *MongoStore) Read(coll string, key Key, tag string) ([]byte, error) {
+func (m *MongoStore) Read(ctx context.Context, coll string, key Key, tag string) ([]byte, error) {
if !m.validateParams(coll, key, tag) {
return nil, pkgerrors.New("Mandatory fields are missing")
}
c := getCollection(coll, m)
- ctx := context.Background()
//Get the masterkey document based on given key
filter := bson.D{{"key", key}}
- keydata, err := decodeBytes(c.FindOne(context.Background(), filter))
+ keydata, err := decodeBytes(c.FindOne(ctx, filter))
if err != nil {
return nil, pkgerrors.Errorf("Error finding master table: %s", err.Error())
}
}
// Helper function that deletes an object by its ID
-func (m *MongoStore) deleteObjectByID(coll string, objID primitive.ObjectID) error {
+func (m *MongoStore) deleteObjectByID(ctx context.Context, coll string, objID primitive.ObjectID) error {
c := getCollection(coll, m)
- ctx := context.Background()
_, err := c.DeleteOne(ctx, bson.D{{"_id", objID}})
if err != nil {
// Delete method removes a document from the Database that matches key
// TODO: delete all referenced docs if tag is empty string
-func (m *MongoStore) Delete(coll string, key Key, tag string) error {
+func (m *MongoStore) Delete(ctx context.Context, coll string, key Key, tag string) error {
if !m.validateParams(coll, key, tag) {
return pkgerrors.New("Mandatory fields are missing")
}
c := getCollection(coll, m)
- ctx := context.Background()
//Get the masterkey document based on given key
filter := bson.D{{"key", key}}
}
//Use tag objectID to read the data from store
- err = m.deleteObjectByID(coll, tagoid)
+ err = m.deleteObjectByID(ctx, coll, tagoid)
if err != nil {
return pkgerrors.Errorf("Error deleting from database: %s", err.Error())
}
if !ok {
return pkgerrors.Errorf("Error finding objectID for key %s", key)
}
- err = m.deleteObjectByID(coll, keyid)
+ err = m.deleteObjectByID(ctx, coll, keyid)
if err != nil {
return pkgerrors.Errorf("Error deleting master table from database: %s", err.Error())
}
}
// ReadAll is used to get all documents in db of a particular tag
-func (m *MongoStore) ReadAll(coll, tag string) (map[string][]byte, error) {
+func (m *MongoStore) ReadAll(ctx context.Context, coll, tag string) (map[string][]byte, error) {
if !m.validateParams(coll, tag) {
return nil, pkgerrors.New("Missing collection or tag name")
}
c := getCollection(coll, m)
- ctx := context.Background()
//Get all master tables in this collection
filter := bson.D{
"go.mongodb.org/mongo-driver/mongo/options"
)
-//Implements the functions used currently in mongo.go
+// Implements the functions used currently in mongo.go
type mockCollection struct {
Err error
mCursor *mongo.Cursor
return testCase.bson, testCase.mockColl.Err
}
- err := m.Create(testCase.input["coll"].(string), testCase.input["key"].(Key),
+ err := m.Create(context.TODO(), testCase.input["coll"].(string), testCase.input["key"].(Key),
testCase.input["tag"].(string), testCase.input["data"])
if err != nil {
if testCase.expectedError == "" {
return testCase.bson, testCase.mockColl.Err
}
- err := m.Update(testCase.input["coll"].(string), testCase.input["key"].(Key),
+ err := m.Update(context.TODO(), testCase.input["coll"].(string), testCase.input["key"].(Key),
testCase.input["tag"].(string), testCase.input["data"])
if err != nil {
if testCase.expectedError == "" {
decodeBytes = func(sr *mongo.SingleResult) (bson.Raw, error) {
return testCase.bson, testCase.mockColl.Err
}
- got, err := m.Read(testCase.input["coll"].(string), testCase.input["key"].(Key),
+ got, err := m.Read(context.TODO(), testCase.input["coll"].(string), testCase.input["key"].(Key),
testCase.input["tag"].(string))
if err != nil {
if testCase.expectedError == "" {
decodeBytes = func(sr *mongo.SingleResult) (bson.Raw, error) {
return testCase.bson, testCase.mockColl.Err
}
- err := m.Delete(testCase.input["coll"].(string), testCase.input["key"].(Key),
+ err := m.Delete(context.TODO(), testCase.input["coll"].(string), testCase.input["key"].(Key),
testCase.input["tag"].(string))
if err != nil {
if testCase.expectedError == "" {
return nil
}
- got, err := m.ReadAll(testCase.input["coll"].(string), testCase.input["tag"].(string))
+ got, err := m.ReadAll(context.TODO(), testCase.input["coll"].(string), testCase.input["tag"].(string))
if err != nil {
if testCase.expectedError == "" {
t.Fatalf("Readall method returned an un-expected (%s)", err)
package db
import (
+ "context"
"encoding/json"
"reflect"
// Creates a new master table with key and links data with tag and
// creates a pointer to the newly added data in the master table
- Create(table string, key Key, tag string, data interface{}) error
+ Create(ctx context.Context, table string, key Key, tag string, data interface{}) error
// Reads data for a particular key with specific tag.
- Read(table string, key Key, tag string) ([]byte, error)
+ Read(ctx context.Context, table string, key Key, tag string) ([]byte, error)
// Update data for particular key with specific tag
- Update(table string, key Key, tag string, data interface{}) error
+ Update(ctx context.Context, table string, key Key, tag string, data interface{}) error
// Deletes a specific tag data for key.
// TODO: If tag is empty, it will delete all tags under key.
- Delete(table string, key Key, tag string) error
+ Delete(ctx context.Context, table string, key Key, tag string) error
// Reads all master tables and data from the specified tag in table
- ReadAll(table string, tag string) (map[string][]byte, error)
+ ReadAll(ctx context.Context, table string, tag string) (map[string][]byte, error)
}
// CreateDBClient creates the DB client
package db
import (
+ "context"
"encoding/json"
pkgerrors "github.com/pkg/errors"
return m.Key
}
-//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 MockDB struct {
Store
Items map[string]map[string][]byte
return m.Err
}
-func (m *MockDB) Create(table string, key Key, tag string, data interface{}) error {
+func (m *MockDB) Create(ctx context.Context, table string, key Key, tag string, data interface{}) error {
djs, err := json.Marshal(data)
if err != nil {
return err
return m.Err
}
-func (m *MockDB) Update(table string, key Key, tag string, data interface{}) error {
+func (m *MockDB) Update(ctx context.Context, table string, key Key, tag string, data interface{}) error {
return m.Err
}
return nil
}
-func (m *MockDB) Read(table string, key Key, tag string) ([]byte, error) {
+func (m *MockDB) Read(ctx context.Context, table string, key Key, tag string) ([]byte, error) {
if m.Err != nil {
return nil, m.Err
}
return nil, m.Err
}
-func (m *MockDB) Delete(table string, key Key, tag string) error {
+func (m *MockDB) Delete(ctx context.Context, table string, key Key, tag string) error {
return m.Err
}
-func (m *MockDB) ReadAll(table string, tag string) (map[string][]byte, error) {
+func (m *MockDB) ReadAll(ctx context.Context, table string, tag string) (map[string][]byte, error) {
if m.Err != nil {
return nil, m.Err
}
package healthcheck
import (
+ "context"
"encoding/json"
"strings"
"sync"
retErr := "Starting hook " + h.Status.Name
// Dump to DB
- err = db.DBconn.Create(ihc.storeName, key, ihc.tagInst, ihcs)
+ err = db.DBconn.Create(context.TODO(), ihc.storeName, key, ihc.tagInst, ihcs)
if err != nil {
retErr = retErr + " and couldn't save to DB"
}
h.Status.KR = kr
}
}
- err = db.DBconn.Create(ihc.storeName, key, ihc.tagInst, ihcs)
+ err = db.DBconn.Create(context.TODO(), ihc.storeName, key, ihc.tagInst, ihcs)
if err != nil {
return instanceMiniHCStatusFromStatus(ihcs),
pkgerrors.Wrap(err, "Creating Instance DB Entry")
"Reason": map[bool]string{true: "Hook finished", false: "All hooks finished"}[b],
})
if b { //Some hook finished - need to update DB
- err = db.DBconn.Update(ihc.storeName, key, ihc.tagInst, ihcs)
+ err = db.DBconn.Update(context.TODO(), ihc.storeName, key, ihc.tagInst, ihcs)
if err != nil {
log.Error("Couldn't update database", log.Fields{
"Store": ihc.storeName,
}
}
ihcs.Status = finalResult
- err = db.DBconn.Update(ihc.storeName, key, ihc.tagInst, ihcs)
+ err = db.DBconn.Update(context.TODO(), ihc.storeName, key, ihc.tagInst, ihcs)
if err != nil {
log.Error("Couldn't update database", log.Fields{
"Store": ihc.storeName,
InstanceId: instanceId,
HealthcheckId: healthcheckId,
}
- DBResp, err := db.DBconn.Read(ihc.storeName, key, ihc.tagInst)
+ DBResp, err := db.DBconn.Read(context.TODO(), ihc.storeName, key, ihc.tagInst)
if err != nil || DBResp == nil {
return InstanceHCStatus{}, pkgerrors.Wrap(err, "Error retrieving Healthcheck data")
}
if cumulatedErr != "" {
return pkgerrors.New("Removing hooks failed with errors:\n" + cumulatedErr)
}
- err = db.DBconn.Delete(ihc.storeName, key, ihc.tagInst)
+ err = db.DBconn.Delete(context.TODO(), ihc.storeName, key, ihc.tagInst)
if err != nil {
return pkgerrors.Wrap(err, "Removing Healthcheck in DB")
}
ihco.Hooks = instance.Hooks
// Retrieve info about running/completed healthchecks
- dbResp, err := db.DBconn.ReadAll(ihc.storeName, ihc.tagInst)
+ dbResp, err := db.DBconn.ReadAll(context.TODO(), ihc.storeName, ihc.tagInst)
if err != nil {
if !strings.Contains(err.Error(), "Did not find any objects with tag") {
return ihco, pkgerrors.Wrap(err, "Getting Healthcheck data")
package namegenerator
import (
+ "context"
"encoding/json"
"log"
"strings"
func (c *cache) readCacheFromDB() error {
// Read the latest from cache
- data, err := db.DBconn.Read(storeName, cacheKeyGlobal, tag)
+ data, err := db.DBconn.Read(context.TODO(), storeName, cacheKeyGlobal, tag)
if err != nil {
log.Println("Error reading name cache from Database: ", err)
return pkgerrors.Wrap(err, "Reading cache from DB")
func (c *cache) writeCacheToDB() {
//Update the database as well
- err := db.DBconn.Update(storeName, cacheKeyGlobal, tag, c.cache)
+ err := db.DBconn.Update(context.TODO(), storeName, cacheKeyGlobal, tag, c.cache)
if err != nil {
// TODO: Replace with DBconn variable
if strings.Contains(err.Error(), "Error finding master table") {
- err = db.DBconn.Create(storeName, cacheKeyGlobal, tag, c.cache)
+ err = db.DBconn.Create(context.TODO(), storeName, cacheKeyGlobal, tag, c.cache)
if err != nil {
log.Println("Error creating the entry in DB. Will try later...")
return
import (
"bytes"
+ "context"
+ "encoding/base64"
"encoding/json"
"io/ioutil"
+ "log"
"os"
"path/filepath"
"github.com/onap/multicloud-k8s/src/k8splugin/internal/db"
- "encoding/base64"
-
- "log"
-
pkgerrors "github.com/pkg/errors"
)
if update {
p.ChartName = prev.ChartName
p.HasContent = prev.HasContent
- err = db.DBconn.Update(v.storeName, key, v.tagMeta, p)
+ err = db.DBconn.Update(context.TODO(), v.storeName, key, v.tagMeta, p)
if err != nil {
return pkgerrors.Wrap(err, "Updating ConfigTemplate DB Entry")
}
} else {
p.ChartName = rbDef.ChartName
p.HasContent = false
- err = db.DBconn.Create(v.storeName, key, v.tagMeta, p)
+ err = db.DBconn.Create(context.TODO(), v.storeName, key, v.tagMeta, p)
if err != nil {
return pkgerrors.Wrap(err, "Creating ConfigTemplate DB Entry")
}
RBVersion: rbVersion,
TemplateName: templateName,
}
- value, err := db.DBconn.Read(v.storeName, key, v.tagMeta)
+ value, err := db.DBconn.Read(context.TODO(), v.storeName, key, v.tagMeta)
if err != nil {
return ConfigTemplate{}, pkgerrors.Wrap(err, "Get ConfigTemplate")
}
func (v *ConfigTemplateClient) List(rbName, rbVersion string) ([]ConfigTemplateList, error) {
//Get all config templates
- dbres, err := db.DBconn.ReadAll(v.storeName, v.tagMeta)
+ dbres, err := db.DBconn.ReadAll(context.TODO(), v.storeName, v.tagMeta)
if err != nil || len(dbres) == 0 {
return []ConfigTemplateList{}, pkgerrors.Wrap(err, "No Config Templates Found")
}
RBVersion: rbVersion,
TemplateName: tmp.TemplateName,
}
- _, err := db.DBconn.Read(v.storeName, keyTmp, v.tagMeta)
+ _, err := db.DBconn.Read(context.TODO(), v.storeName, keyTmp, v.tagMeta)
if err == nil && keyTmp.RBName == rbName && keyTmp.RBVersion == rbVersion {
results = append(results, tmp)
}
RBVersion: rbVersion,
TemplateName: templateName,
}
- err := db.DBconn.Delete(v.storeName, key, v.tagMeta)
+ err := db.DBconn.Delete(context.TODO(), v.storeName, key, v.tagMeta)
if err != nil {
return pkgerrors.Wrap(err, "Delete ConfigTemplate")
}
- err = db.DBconn.Delete(v.storeName, key, v.tagContent)
+ err = db.DBconn.Delete(context.TODO(), v.storeName, key, v.tagContent)
if err != nil {
return pkgerrors.Wrap(err, "Delete ConfigTemplate Content")
}
return pkgerrors.New("Invalid template no Chart.yaml file found")
}
- err = db.DBconn.Create(v.storeName, key, v.tagMeta, t)
+ err = db.DBconn.Create(context.TODO(), v.storeName, key, v.tagMeta, t)
if err != nil {
return pkgerrors.Wrap(err, "Creating ConfigTemplate DB Entry")
}
//Encode given byte stream to text for storage
encodedStr := base64.StdEncoding.EncodeToString(inp)
- err = db.DBconn.Create(v.storeName, key, v.tagContent, encodedStr)
+ err = db.DBconn.Create(context.TODO(), v.storeName, key, v.tagContent, encodedStr)
if err != nil {
return pkgerrors.Errorf("Error uploading data to db %s", err.Error())
}
t.HasContent = true
- err = db.DBconn.Update(v.storeName, key, v.tagMeta, t)
+ err = db.DBconn.Update(context.TODO(), v.storeName, key, v.tagMeta, t)
if err != nil {
return pkgerrors.Wrap(err, "Updating ConfigTemplate DB Entry")
}
RBVersion: rbVersion,
TemplateName: templateName,
}
- value, err := db.DBconn.Read(v.storeName, key, v.tagContent)
+ value, err := db.DBconn.Read(context.TODO(), v.storeName, key, v.tagContent)
if err != nil {
return nil, pkgerrors.Wrap(err, "Get Resource ConfigTemplate content")
}
import (
"bytes"
+ "context"
"encoding/base64"
"encoding/json"
"io/ioutil"
return Definition{}, pkgerrors.New("Definition already exists")
}
- err = db.DBconn.Create(v.storeName, key, v.tagMeta, def)
+ err = db.DBconn.Create(context.TODO(), v.storeName, key, v.tagMeta, def)
if err != nil {
return Definition{}, pkgerrors.Wrap(err, "Creating DB Entry")
}
return Definition{}, pkgerrors.New("Definition does not exists")
}
- err = db.DBconn.Update(v.storeName, key, v.tagMeta, def)
+ err = db.DBconn.Update(context.TODO(), 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(v.storeName, v.tagMeta)
+ res, err := db.DBconn.ReadAll(context.TODO(), v.storeName, v.tagMeta)
if err != nil || len(res) == 0 {
return []Definition{}, pkgerrors.Wrap(err, "Listing Resource Bundle Definitions")
}
//Construct the composite key to select the entry
key := DefinitionKey{RBName: name, RBVersion: version}
- value, err := db.DBconn.Read(v.storeName, key, v.tagMeta)
+ value, err := db.DBconn.Read(context.TODO(), v.storeName, key, v.tagMeta)
if err != nil {
return Definition{}, pkgerrors.Wrap(err, "Get Resource Bundle definition")
}
//Construct the composite key to select the entry
key := DefinitionKey{RBName: name, RBVersion: version}
- err := db.DBconn.Delete(v.storeName, key, v.tagMeta)
+ err := db.DBconn.Delete(context.TODO(), 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(v.storeName, key, v.tagContent)
+ err = db.DBconn.Delete(context.TODO(), v.storeName, key, v.tagContent)
if err != nil {
return pkgerrors.Wrap(err, "Delete Resource Bundle Definition Content")
}
}
//TODO: Use db update api once db supports it.
- err = db.DBconn.Create(v.storeName, key, v.tagMeta, def)
+ err = db.DBconn.Create(context.TODO(), 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(v.storeName, key, v.tagContent, encodedStr)
+ err = db.DBconn.Create(context.TODO(), v.storeName, key, v.tagContent, encodedStr)
if err != nil {
return pkgerrors.Errorf("Error uploading data to db: %s", err.Error())
}
//Construct the composite key to select the entry
key := DefinitionKey{RBName: name, RBVersion: version}
- value, err := db.DBconn.Read(v.storeName, key, v.tagContent)
+ value, err := db.DBconn.Read(context.TODO(), v.storeName, key, v.tagContent)
if err != nil {
return nil, pkgerrors.Wrap(err, "Get Resource Bundle definition content")
}
import (
"bytes"
+ "context"
"encoding/base64"
"encoding/json"
"log"
}
if update {
- err = db.DBconn.Update(v.storeName, key, v.tagMeta, p)
+ err = db.DBconn.Update(context.TODO(), v.storeName, key, v.tagMeta, p)
if err != nil {
return Profile{}, pkgerrors.Wrap(err, "Updating Profile DB Entry")
}
} else {
- err = db.DBconn.Create(v.storeName, key, v.tagMeta, p)
+ err = db.DBconn.Create(context.TODO(), v.storeName, key, v.tagMeta, p)
if err != nil {
return Profile{}, pkgerrors.Wrap(err, "Creating Profile DB Entry")
}
RBVersion: rbVersion,
ProfileName: prName,
}
- value, err := db.DBconn.Read(v.storeName, key, v.tagMeta)
+ value, err := db.DBconn.Read(context.TODO(), v.storeName, key, v.tagMeta)
if err != nil {
return Profile{}, pkgerrors.Wrap(err, "Get Resource Bundle Profile")
}
func (v *ProfileClient) List(rbName, rbVersion string) ([]Profile, error) {
//Get all profiles
- dbres, err := db.DBconn.ReadAll(v.storeName, v.tagMeta)
+ dbres, err := db.DBconn.ReadAll(context.TODO(), v.storeName, v.tagMeta)
if err != nil || len(dbres) == 0 {
return []Profile{}, pkgerrors.Wrap(err, "No Profiles Found")
}
RBVersion: rbVersion,
ProfileName: prName,
}
- err := db.DBconn.Delete(v.storeName, key, v.tagMeta)
+ err := db.DBconn.Delete(context.TODO(), v.storeName, key, v.tagMeta)
if err != nil {
return pkgerrors.Wrap(err, "Delete Resource Bundle Profile")
}
- err = db.DBconn.Delete(v.storeName, key, v.tagContent)
+ err = db.DBconn.Delete(context.TODO(), v.storeName, key, v.tagContent)
if err != nil {
return pkgerrors.Wrap(err, "Delete Resource Bundle Profile Content")
}
}
//Encode given byte stream to text for storage
encodedStr := base64.StdEncoding.EncodeToString(inp)
- err = db.DBconn.Create(v.storeName, key, v.tagContent, encodedStr)
+ err = db.DBconn.Create(context.TODO(), v.storeName, key, v.tagContent, encodedStr)
if err != nil {
return pkgerrors.Errorf("Error uploading data to db %s", err.Error())
}
RBVersion: rbVersion,
ProfileName: prName,
}
- value, err := db.DBconn.Read(v.storeName, key, v.tagContent)
+ value, err := db.DBconn.Read(context.TODO(), v.storeName, key, v.tagContent)
if err != nil {
return nil, pkgerrors.Wrap(err, "Get Resource Bundle Profile content")
}
return nil, pkgerrors.New("Error downloading Profile content")
}
-//GetYamlClient GEt Yaml Files client for profile
+// GetYamlClient GEt Yaml Files client for profile
func (v *ProfileClient) GetYamlClient(rbName string, rbVersion string, profileName string) (ProfileYamlClient, error) {
prData, err := v.Download(rbName, rbVersion, profileName)
if err != nil {
return prYamlClient, nil
}
-//Resolve returns the path where the helm chart merged with
-//configuration overrides resides and final ReleaseName picked for instantiation
+// Resolve returns the path where the helm chart merged with
+// configuration overrides resides and final ReleaseName picked for instantiation
func (v *ProfileClient) Resolve(rbName string, rbVersion string,
profileName string, values []string, overrideReleaseName string) ([]helm.KubernetesResourceTemplate, []helm.KubernetesResourceTemplate, []*helm.Hook, string, error) {
Code Review / multicloud / k8s.git / commitdiff