src/ncm/pkg/module/network.go

   1 /*
   2  * Copyright 2020 Intel Corporation, Inc
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package module
  18
  19 import (
  20         "github.com/onap/multicloud-k8s/src/orchestrator/pkg/infra/db"
  21
  22         pkgerrors "github.com/pkg/errors"
  23 )
  24
  25 // Network contains the parameters needed for dynamic networks
  26 type Network struct {
  27         Metadata Metadata    `json:"metadata" yaml:"metadata"`
  28         Spec     NetworkSpec `json:"spec" yaml:"spec"`
  29 }
  30
  31 type NetworkSpec struct {
  32         CniType     string       `json:"cniType" yaml:"cniType"`
  33         Ipv4Subnets []Ipv4Subnet `json:"ipv4Subnets" yaml:"ipv4Subnets"`
  34 }
  35
  36 // NetworkKey is the key structure that is used in the database
  37 type NetworkKey struct {
  38         ClusterProviderName string `json:"provider"`
  39         ClusterName         string `json:"cluster"`
  40         NetworkName         string `json:"network"`
  41 }
  42
  43 // structure for the Network Custom Resource
  44 type CrNetwork struct {
  45         ApiVersion string  `yaml:"apiVersion"`
  46         Kind       string  `yaml:"kind"`
  47         Network    Network `yaml:",inline"`
  48 }
  49
  50 const NETWORK_APIVERSION = "k8s.plugin.opnfv.org/v1alpha1"
  51 const NETWORK_KIND = "Network"
  52
  53 // Manager is an interface exposing the Network functionality
  54 type NetworkManager interface {
  55         CreateNetwork(pr Network, clusterProvider, cluster string, exists bool) (Network, error)
  56         GetNetwork(name, clusterProvider, cluster string) (Network, error)
  57         GetNetworks(clusterProvider, cluster string) ([]Network, error)
  58         DeleteNetwork(name, clusterProvider, cluster string) error
  59 }
  60
  61 // NetworkClient implements the Manager
  62 // It will also be used to maintain some localized state
  63 type NetworkClient struct {
  64         db ClientDbInfo
  65 }
  66
  67 // NewNetworkClient returns an instance of the NetworkClient
  68 // which implements the Manager
  69 func NewNetworkClient() *NetworkClient {
  70         return &NetworkClient{
  71                 db: ClientDbInfo{
  72                         storeName: "cluster",
  73                         tagMeta:   "networkmetadata",
  74                 },
  75         }
  76 }
  77
  78 // CreateNetwork - create a new Network
  79 func (v *NetworkClient) CreateNetwork(p Network, clusterProvider, cluster string, exists bool) (Network, error) {
  80
  81         //Construct key and tag to select the entry
  82         key := NetworkKey{
  83                 ClusterProviderName: clusterProvider,
  84                 ClusterName:         cluster,
  85                 NetworkName:         p.Metadata.Name,
  86         }
  87
  88         //Check if cluster exists
  89         _, err := NewClusterClient().GetCluster(clusterProvider, cluster)
  90         if err != nil {
  91                 return Network{}, pkgerrors.New("Unable to find the cluster")
  92         }
  93
  94         //Check if this Network already exists
  95         _, err = v.GetNetwork(p.Metadata.Name, clusterProvider, cluster)
  96         if err == nil && !exists {
  97                 return Network{}, pkgerrors.New("Network already exists")
  98         }
  99
 100         err = db.DBconn.Insert(v.db.storeName, key, nil, v.db.tagMeta, p)
 101         if err != nil {
 102                 return Network{}, pkgerrors.Wrap(err, "Creating DB Entry")
 103         }
 104
 105         return p, nil
 106 }
 107
 108 // GetNetwork returns the Network for corresponding name
 109 func (v *NetworkClient) GetNetwork(name, clusterProvider, cluster string) (Network, error) {
 110
 111         //Construct key and tag to select the entry
 112         key := NetworkKey{
 113                 ClusterProviderName: clusterProvider,
 114                 ClusterName:         cluster,
 115                 NetworkName:         name,
 116         }
 117
 118         value, err := db.DBconn.Find(v.db.storeName, key, v.db.tagMeta)
 119         if err != nil {
 120                 return Network{}, pkgerrors.Wrap(err, "Get Network")
 121         }
 122
 123         //value is a byte array
 124         if value != nil {
 125                 cp := Network{}
 126                 err = db.DBconn.Unmarshal(value[0], &cp)
 127                 if err != nil {
 128                         return Network{}, pkgerrors.Wrap(err, "Unmarshalling Value")
 129                 }
 130                 return cp, nil
 131         }
 132
 133         return Network{}, pkgerrors.New("Error getting Network")
 134 }
 135
 136 // GetNetworkList returns all of the Network for corresponding name
 137 func (v *NetworkClient) GetNetworks(clusterProvider, cluster string) ([]Network, error) {
 138
 139         //Construct key and tag to select the entry
 140         key := NetworkKey{
 141                 ClusterProviderName: clusterProvider,
 142                 ClusterName:         cluster,
 143                 NetworkName:         "",
 144         }
 145
 146         var resp []Network
 147         values, err := db.DBconn.Find(v.db.storeName, key, v.db.tagMeta)
 148         if err != nil {
 149                 return []Network{}, pkgerrors.Wrap(err, "Get Networks")
 150         }
 151
 152         for _, value := range values {
 153                 cp := Network{}
 154                 err = db.DBconn.Unmarshal(value, &cp)
 155                 if err != nil {
 156                         return []Network{}, pkgerrors.Wrap(err, "Unmarshalling Value")
 157                 }
 158                 resp = append(resp, cp)
 159         }
 160
 161         return resp, nil
 162 }
 163
 164 // Delete the  Network from database
 165 func (v *NetworkClient) DeleteNetwork(name, clusterProvider, cluster string) error {
 166
 167         //Construct key and tag to select the entry
 168         key := NetworkKey{
 169                 ClusterProviderName: clusterProvider,
 170                 ClusterName:         cluster,
 171                 NetworkName:         name,
 172         }
 173
 174         err := db.DBconn.Remove(v.db.storeName, key)
 175         if err != nil {
 176                 return pkgerrors.Wrap(err, "Delete Network Entry;")
 177         }
 178
 179         return nil
 180 }