package api
 
 import (
-       "k8splugin/rb"
+       "k8splugin/internal/rb"
        "os"
        "path/filepath"
        "plugin"
        "github.com/gorilla/mux"
        pkgerrors "github.com/pkg/errors"
 
-       "k8splugin/db"
-       "k8splugin/krd"
+       krd "k8splugin/internal"
+       "k8splugin/internal/db"
 )
 
 // CheckEnvVariables checks for required Environment variables
 
 import (
        "encoding/json"
        "io/ioutil"
-       "k8splugin/rb"
+       "k8splugin/internal/rb"
        "net/http"
 
        "github.com/gorilla/mux"
 
        "bytes"
        "encoding/json"
        "io"
-       "k8splugin/rb"
+       "k8splugin/internal/rb"
        "net/http"
        "net/http/httptest"
        "reflect"
 
        pkgerrors "github.com/pkg/errors"
        "k8s.io/client-go/kubernetes"
 
-       "k8splugin/csar"
-       "k8splugin/db"
-       "k8splugin/krd"
+       helper "k8splugin/internal/app"
+       "k8splugin/internal/db"
 )
 
 //TODO: Separate the http handler code and backend code out
 
 // GetVNFClient retrieves the client used to communicate with a Kubernetes Cluster
 var GetVNFClient = func(kubeConfigPath string) (kubernetes.Clientset, error) {
-       client, err := krd.GetKubeClient(kubeConfigPath)
+       client, err := helper.GetKubeClient(kubeConfigPath)
        if err != nil {
                return client, err
        }
                },
                nil
        */
-       externalVNFID, resourceNameMap, err := csar.CreateVNF(resource.CsarID, resource.CloudRegionID, resource.Namespace, &kubeclient)
+       externalVNFID, resourceNameMap, err := helper.CreateVNF(resource.CsarID, resource.CloudRegionID, resource.Namespace, &kubeclient)
        if err != nil {
                werr := pkgerrors.Wrap(err, "Read Kubernetes Data information error")
                http.Error(w, werr.Error(), http.StatusInternalServerError)
                http.Error(w, err.Error(), http.StatusInternalServerError)
                return
        }
-       err = csar.DestroyVNF(data, namespace, &kubeclient)
+       err = helper.DestroyVNF(data, namespace, &kubeclient)
        if err != nil {
                werr := pkgerrors.Wrap(err, "Delete VNF error")
                http.Error(w, werr.Error(), http.StatusInternalServerError)
 
        pkgerrors "github.com/pkg/errors"
        "k8s.io/client-go/kubernetes"
 
-       "k8splugin/csar"
-       "k8splugin/db"
+       helper "k8splugin/internal/app"
+       "k8splugin/internal/db"
 )
 
 type mockCSAR struct {
                                return kubernetes.Clientset{}, testCase.mockGetVNFClientErr
                        }
                        if testCase.mockCreateVNF != nil {
-                               csar.CreateVNF = testCase.mockCreateVNF.CreateVNF
+                               helper.CreateVNF = testCase.mockCreateVNF.CreateVNF
                        }
                        if testCase.mockStore != nil {
                                db.DBconn = testCase.mockStore
                                db.DBconn = testCase.mockStore
                        }
                        if testCase.mockDeleteVNF != nil {
-                               csar.DestroyVNF = testCase.mockDeleteVNF.DestroyVNF
+                               helper.DestroyVNF = testCase.mockDeleteVNF.DestroyVNF
                        }
 
                        request, _ := http.NewRequest("DELETE", "/v1/vnf_instances/cloudregion1/testnamespace/uuid1", nil)
 
 import (
        "encoding/json"
        "io/ioutil"
-       "k8splugin/rb"
+       "k8splugin/internal/rb"
        "net/http"
 
        "github.com/gorilla/mux"
 
        "bytes"
        "encoding/json"
        "io"
-       "k8splugin/rb"
+       "k8splugin/internal/rb"
        "net/http"
        "net/http/httptest"
        "reflect"
 
 limitations under the License.
 */
 
-package krd
+package app
 
 import (
        "errors"
 
 limitations under the License.
 */
 
-package krd
+package app
 
 import (
        "reflect"
 func TestGetKubeClient(t *testing.T) {
        t.Run("Successfully create Kube Client", func(t *testing.T) {
 
-               clientset, err := GetKubeClient("../mock_files/mock_configs/mock_config")
+               clientset, err := GetKubeClient("../../mock_files/mock_configs/mock_config")
                if err != nil {
                        t.Fatalf("TestGetKubeClient returned an error (%s)", err)
                }
 
 limitations under the License.
 */
 
-package csar
+package app
 
 import (
        "encoding/hex"
        pkgerrors "github.com/pkg/errors"
        yaml "gopkg.in/yaml.v2"
 
-       "k8splugin/krd"
+       utils "k8splugin/internal"
 )
 
 func generateExternalVNFID() string {
 }
 
 func ensuresNamespace(namespace string, kubeclient kubernetes.Interface) error {
-       namespacePlugin, ok := krd.LoadedPlugins["namespace"]
+       namespacePlugin, ok := utils.LoadedPlugins["namespace"]
        if !ok {
                return pkgerrors.New("No plugin for namespace resource found")
        }
                if err != nil {
                        return pkgerrors.Wrap(err, "Error fetching create namespace plugin")
                }
-               namespaceResource := &krd.ResourceData{
+               namespaceResource := &utils.ResourceData{
                        Namespace: namespace,
                }
 
-               _, err = symGetNamespaceFunc.(func(*krd.ResourceData, kubernetes.Interface) (string, error))(
+               _, err = symGetNamespaceFunc.(func(*utils.ResourceData, kubernetes.Interface) (string, error))(
                        namespaceResource, kubeclient)
                if err != nil {
                        return pkgerrors.Wrap(err, "Error creating "+namespace+" namespace")
                        }
                        log.Println("Processing file: " + path)
 
-                       genericKubeData := &krd.ResourceData{
+                       genericKubeData := &utils.ResourceData{
                                YamlFilePath: path,
                                Namespace:    namespace,
                                VnfId:        internalVNFID,
                        }
 
-                       typePlugin, ok := krd.LoadedPlugins[resource]
+                       typePlugin, ok := utils.LoadedPlugins[resource]
                        if !ok {
                                return "", nil, pkgerrors.New("No plugin for resource " + resource + " found")
                        }
                                return "", nil, pkgerrors.Wrap(err, "Error fetching "+resource+" plugin")
                        }
 
-                       internalResourceName, err := symCreateResourceFunc.(func(*krd.ResourceData, kubernetes.Interface) (string, error))(
+                       internalResourceName, err := symCreateResourceFunc.(func(*utils.ResourceData, kubernetes.Interface) (string, error))(
                                genericKubeData, kubeclient)
                        if err != nil {
                                return "", nil, pkgerrors.Wrap(err, "Error in plugin "+resource+" plugin")
        */
 
        for resourceName, resourceList := range data {
-               typePlugin, ok := krd.LoadedPlugins[resourceName]
+               typePlugin, ok := utils.LoadedPlugins[resourceName]
                if !ok {
                        return pkgerrors.New("No plugin for resource " + resourceName + " found")
                }
 
 limitations under the License.
 */
 
-package csar
+package app
 
 import (
        "io/ioutil"
        "plugin"
        "testing"
 
+       yaml "gopkg.in/yaml.v2"
        "k8s.io/client-go/kubernetes"
 
        pkgerrors "github.com/pkg/errors"
-       "gopkg.in/yaml.v2"
 
-       "k8splugin/krd"
+       utils "k8splugin/internal"
 )
 
 func LoadMockPlugins(krdLoadedPlugins *map[string]*plugin.Plugin) error {
-       if _, err := os.Stat("../mock_files/mock_plugins/mockplugin.so"); os.IsNotExist(err) {
+       if _, err := os.Stat("../../mock_files/mock_plugins/mockplugin.so"); os.IsNotExist(err) {
                return pkgerrors.New("mockplugin.so does not exist. Please compile mockplugin.go to generate")
        }
 
-       mockPlugin, err := plugin.Open("../mock_files/mock_plugins/mockplugin.so")
+       mockPlugin, err := plugin.Open("../../mock_files/mock_plugins/mockplugin.so")
        if err != nil {
                return pkgerrors.Cause(err)
        }
 }
 
 func TestCreateVNF(t *testing.T) {
-       oldkrdPluginData := krd.LoadedPlugins
+       oldkrdPluginData := utils.LoadedPlugins
        oldReadMetadataFile := ReadMetadataFile
 
        defer func() {
-               krd.LoadedPlugins = oldkrdPluginData
+               utils.LoadedPlugins = oldkrdPluginData
                ReadMetadataFile = oldReadMetadataFile
        }()
 
-       err := LoadMockPlugins(&krd.LoadedPlugins)
+       err := LoadMockPlugins(&utils.LoadedPlugins)
        if err != nil {
                t.Fatalf("TestCreateVNF returned an error (%s)", err)
        }
                var seqFile MetadataFile
 
                if _, err := os.Stat(yamlFilePath); err == nil {
-                       rawBytes, err := ioutil.ReadFile("../mock_files/mock_yamls/metadata.yaml")
+                       rawBytes, err := ioutil.ReadFile("../../mock_files/mock_yamls/metadata.yaml")
                        if err != nil {
                                return seqFile, pkgerrors.Wrap(err, "Metadata YAML file read error")
                        }
 }
 
 func TestDeleteVNF(t *testing.T) {
-       oldkrdPluginData := krd.LoadedPlugins
+       oldkrdPluginData := utils.LoadedPlugins
 
        defer func() {
-               krd.LoadedPlugins = oldkrdPluginData
+               utils.LoadedPlugins = oldkrdPluginData
        }()
 
-       err := LoadMockPlugins(&krd.LoadedPlugins)
+       err := LoadMockPlugins(&utils.LoadedPlugins)
        if err != nil {
                t.Fatalf("TestCreateVNF returned an error (%s)", err)
        }
 
 func TestReadMetadataFile(t *testing.T) {
        t.Run("Successfully read Metadata YAML file", func(t *testing.T) {
-               _, err := ReadMetadataFile("../mock_files//mock_yamls/metadata.yaml")
+               _, err := ReadMetadataFile("../../mock_files//mock_yamls/metadata.yaml")
                if err != nil {
                        t.Fatalf("TestReadMetadataFile returned an error (%s)", err)
                }
 
 import (
        "bytes"
        "encoding/base64"
-       "k8splugin/db"
+       "k8splugin/internal/db"
        "log"
 
        uuid "github.com/hashicorp/go-uuid"
 
 package rb
 
 import (
-       "k8splugin/db"
+       "k8splugin/internal/db"
        "reflect"
        "sort"
        "strings"
 
 import (
        "bytes"
        "encoding/base64"
-       "k8splugin/db"
+       "k8splugin/internal/db"
        "log"
 
        uuid "github.com/hashicorp/go-uuid"
 
 package rb
 
 import (
-       "k8splugin/db"
+       "k8splugin/internal/db"
        "reflect"
        "sort"
        "strings"
 
 limitations under the License.
 */
 
-package krd
+package utils
 
 import (
        "io/ioutil"
 
 limitations under the License.
 */
 
-package krd
+package utils
 
 import (
        "strings"
                },
                {
                        label:         "Fail to read invalid YAML format",
-                       input:         "./plugins_test.go",
+                       input:         "./utils_test.go",
                        expectedError: "mapping values are not allowed in this contex",
                },
                {
 
 import (
        "k8s.io/client-go/kubernetes"
 
-       "k8splugin/krd"
+       utils "k8splugin/internal"
 )
 
 func main() {}
 
 // Create object in a specific Kubernetes resource
-func Create(data *krd.ResourceData, client kubernetes.Interface) (string, error) {
+func Create(data *utils.ResourceData, client kubernetes.Interface) (string, error) {
        return "externalUUID", nil
 }
 
 
        metaV1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        "k8s.io/client-go/kubernetes"
 
-       "k8splugin/krd"
+       utils "k8splugin/internal"
 )
 
 // Create deployment object in a specific Kubernetes cluster
-func Create(data *krd.ResourceData, client kubernetes.Interface) (string, error) {
+func Create(data *utils.ResourceData, client kubernetes.Interface) (string, error) {
        namespace := data.Namespace
        if namespace == "" {
                namespace = "default"
        }
-       obj, err := krd.DecodeYAML(data.YamlFilePath, nil)
+       obj, err := utils.DecodeYAML(data.YamlFilePath, nil)
        if err != nil {
                return "", pkgerrors.Wrap(err, "Decode deployment object error")
        }
        }
 
        opts := metaV1.ListOptions{
-               Limit: krd.ResourcesListLimit,
+               Limit: utils.ResourcesListLimit,
        }
        opts.APIVersion = "apps/v1"
        opts.Kind = "Deployment"
                return nil, pkgerrors.Wrap(err, "Get Deployment list error")
        }
 
-       result := make([]string, 0, krd.ResourcesListLimit)
+       result := make([]string, 0, utils.ResourcesListLimit)
        if list != nil {
                for _, deployment := range list.Items {
                        log.Printf("%v", deployment.Name)
 
        "strings"
        "testing"
 
-       "k8splugin/krd"
+       utils "k8splugin/internal"
 
        appsV1 "k8s.io/api/apps/v1"
        metaV1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        internalVNFID := "1"
        testCases := []struct {
                label          string
-               input          *krd.ResourceData
+               input          *utils.ResourceData
                clientOutput   *appsV1.Deployment
                expectedResult string
                expectedError  string
        }{
                {
                        label: "Fail to create a deployment with invalid type",
-                       input: &krd.ResourceData{
+                       input: &utils.ResourceData{
                                YamlFilePath: "../../mock_files/mock_yamls/service.yaml",
                        },
                        clientOutput:  &appsV1.Deployment{},
                },
                {
                        label: "Successfully create a deployment",
-                       input: &krd.ResourceData{
+                       input: &utils.ResourceData{
                                VnfId:        internalVNFID,
                                YamlFilePath: "../../mock_files/mock_yamls/deployment.yaml",
                        },
 
        coreV1 "k8s.io/api/core/v1"
        metaV1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
-       "k8splugin/krd"
+       utils "k8splugin/internal"
 )
 
 // Create a namespace object in a specific Kubernetes cluster
-func Create(data *krd.ResourceData, client kubernetes.Interface) (string, error) {
+func Create(data *utils.ResourceData, client kubernetes.Interface) (string, error) {
        namespace := &coreV1.Namespace{
                ObjectMeta: metaV1.ObjectMeta{
                        Name: data.Namespace,
 // List of existing namespaces hosted in a specific Kubernetes cluster
 func List(namespace string, client kubernetes.Interface) ([]string, error) {
        opts := metaV1.ListOptions{
-               Limit: krd.ResourcesListLimit,
+               Limit: utils.ResourcesListLimit,
        }
        opts.APIVersion = "apps/v1"
        opts.Kind = "Namespace"
                return nil, pkgerrors.Wrap(err, "Get Namespace list error")
        }
 
-       result := make([]string, 0, krd.ResourcesListLimit)
+       result := make([]string, 0, utils.ResourcesListLimit)
        if list != nil {
                for _, deployment := range list.Items {
                        log.Printf("%v", deployment.Name)
 
        "strings"
        "testing"
 
-       "k8splugin/krd"
+       utils "k8splugin/internal"
 
        coreV1 "k8s.io/api/core/v1"
        metaV1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        namespace := "test1"
        testCases := []struct {
                label          string
-               input          *krd.ResourceData
+               input          *utils.ResourceData
                clientOutput   *coreV1.Namespace
                expectedResult string
                expectedError  string
        }{
                {
                        label: "Successfully create a namespace",
-                       input: &krd.ResourceData{
+                       input: &utils.ResourceData{
                                Namespace: namespace,
                        },
                        clientOutput:   &coreV1.Namespace{},
 
 package main
 
 import (
-       pkgerrors "github.com/pkg/errors"
-       "k8s.io/client-go/kubernetes"
-       "k8splugin/krd"
        "k8splugin/plugins/network/v1"
        "regexp"
+
+       utils "k8splugin/internal"
+
+       pkgerrors "github.com/pkg/errors"
+       "k8s.io/client-go/kubernetes"
 )
 
 func extractData(data string) (vnfID, cniType, networkName string) {
 }
 
 // Create an ONAP Network object
-func Create(data *krd.ResourceData, client kubernetes.Interface) (string, error) {
+func Create(data *utils.ResourceData, client kubernetes.Interface) (string, error) {
        network := &v1.OnapNetwork{}
-       if _, err := krd.DecodeYAML(data.YamlFilePath, network); err != nil {
+       if _, err := utils.DecodeYAML(data.YamlFilePath, network); err != nil {
                return "", pkgerrors.Wrap(err, "Decode network object error")
        }
 
        }
 
        cniType := config["cnitype"].(string)
-       typePlugin, ok := krd.LoadedPlugins[cniType+"-network"]
+       typePlugin, ok := utils.LoadedPlugins[cniType+"-network"]
        if !ok {
                return "", pkgerrors.New("No plugin for resource " + cniType + " found")
        }
 // Delete an existing Network
 func Delete(name string, namespace string, kubeclient kubernetes.Interface) error {
        _, cniType, networkName := extractData(name)
-       typePlugin, ok := krd.LoadedPlugins[cniType+"-network"]
+       typePlugin, ok := utils.LoadedPlugins[cniType+"-network"]
        if !ok {
                return pkgerrors.New("No plugin for resource " + cniType + " found")
        }
 
 package main
 
 import (
-       pkgerrors "github.com/pkg/errors"
-       "k8splugin/krd"
+       utils "k8splugin/internal"
        "os"
        "plugin"
        "reflect"
        "strings"
        "testing"
+
+       pkgerrors "github.com/pkg/errors"
 )
 
 func LoadMockNetworkPlugins(krdLoadedPlugins *map[string]*plugin.Plugin, networkName, errMsg string) error {
 
 func TestCreateNetwork(t *testing.T) {
        internalVNFID := "1"
-       oldkrdPluginData := krd.LoadedPlugins
+       oldkrdPluginData := utils.LoadedPlugins
 
        defer func() {
-               krd.LoadedPlugins = oldkrdPluginData
+               utils.LoadedPlugins = oldkrdPluginData
        }()
 
        testCases := []struct {
                label          string
-               input          *krd.ResourceData
+               input          *utils.ResourceData
                mockError      string
                mockOutput     string
                expectedResult string
        }{
                {
                        label: "Fail to decode a network object",
-                       input: &krd.ResourceData{
+                       input: &utils.ResourceData{
                                YamlFilePath: "../../mock_files/mock_yamls/service.yaml",
                        },
                        expectedError: "Fail to decode network's configuration: Invalid configuration value",
                },
                {
                        label: "Fail to create a network",
-                       input: &krd.ResourceData{
+                       input: &utils.ResourceData{
                                YamlFilePath: "../../mock_files/mock_yamls/ovn4nfvk8s.yaml",
                        },
                        mockError:     "Internal error",
                },
                {
                        label: "Successfully create a ovn4nfv network",
-                       input: &krd.ResourceData{
+                       input: &utils.ResourceData{
                                VnfId:        internalVNFID,
                                YamlFilePath: "../../mock_files/mock_yamls/ovn4nfvk8s.yaml",
                        },
 
        for _, testCase := range testCases {
                t.Run(testCase.label, func(t *testing.T) {
-                       err := LoadMockNetworkPlugins(&krd.LoadedPlugins, testCase.mockOutput, testCase.mockError)
+                       err := LoadMockNetworkPlugins(&utils.LoadedPlugins, testCase.mockOutput, testCase.mockError)
                        if err != nil {
                                t.Fatalf("TestCreateNetwork returned an error (%s)", err)
                        }
 }
 
 func TestDeleteNetwork(t *testing.T) {
-       oldkrdPluginData := krd.LoadedPlugins
+       oldkrdPluginData := utils.LoadedPlugins
 
        defer func() {
-               krd.LoadedPlugins = oldkrdPluginData
+               utils.LoadedPlugins = oldkrdPluginData
        }()
 
        testCases := []struct {
 
        for _, testCase := range testCases {
                t.Run(testCase.label, func(t *testing.T) {
-                       err := LoadMockNetworkPlugins(&krd.LoadedPlugins, testCase.mockOutput, testCase.mockError)
+                       err := LoadMockNetworkPlugins(&utils.LoadedPlugins, testCase.mockOutput, testCase.mockError)
                        if err != nil {
                                t.Fatalf("TestDeleteNetwork returned an error (%s)", err)
                        }
 
        coreV1 "k8s.io/api/core/v1"
        metaV1 "k8s.io/apimachinery/pkg/apis/meta/v1"
 
-       "k8splugin/krd"
+       utils "k8splugin/internal"
 )
 
 // Create a service object in a specific Kubernetes cluster
-func Create(data *krd.ResourceData, client kubernetes.Interface) (string, error) {
+func Create(data *utils.ResourceData, client kubernetes.Interface) (string, error) {
        namespace := data.Namespace
        if namespace == "" {
                namespace = "default"
        }
-       obj, err := krd.DecodeYAML(data.YamlFilePath, nil)
+       obj, err := utils.DecodeYAML(data.YamlFilePath, nil)
        if err != nil {
                return "", pkgerrors.Wrap(err, "Decode service object error")
        }
        }
 
        opts := metaV1.ListOptions{
-               Limit: krd.ResourcesListLimit,
+               Limit: utils.ResourcesListLimit,
        }
        opts.APIVersion = "apps/v1"
        opts.Kind = "Service"
                return nil, pkgerrors.Wrap(err, "Get Service list error")
        }
 
-       result := make([]string, 0, krd.ResourcesListLimit)
+       result := make([]string, 0, utils.ResourcesListLimit)
        if list != nil {
                for _, deployment := range list.Items {
                        log.Printf("%v", deployment.Name)
 
        "strings"
        "testing"
 
-       "k8splugin/krd"
+       utils "k8splugin/internal"
 
        coreV1 "k8s.io/api/core/v1"
        metaV1 "k8s.io/apimachinery/pkg/apis/meta/v1"
        internalVNFID := "1"
        testCases := []struct {
                label          string
-               input          *krd.ResourceData
+               input          *utils.ResourceData
                clientOutput   *coreV1.Service
                expectedResult string
                expectedError  string
        }{
                {
                        label: "Fail to create a service with invalid type",
-                       input: &krd.ResourceData{
+                       input: &utils.ResourceData{
                                YamlFilePath: "../../mock_files/mock_yamls/deployment.yaml",
                        },
                        clientOutput:  &coreV1.Service{},
                },
                {
                        label: "Successfully create a service",
-                       input: &krd.ResourceData{
+                       input: &utils.ResourceData{
                                VnfId:        internalVNFID,
                                YamlFilePath: "../../mock_files/mock_yamls/service.yaml",
                        },