github.com/zhuohuang-hust/src-cbuild@v0.0.0-20230105071821-c7aab3e7c840/mergeCode/libnetwork/drivers/macvlan/macvlan_store.go (about)

     1  package macvlan
     2  
     3  import (
     4  	"encoding/json"
     5  	"fmt"
     6  	"net"
     7  
     8  	"github.com/Sirupsen/logrus"
     9  	"github.com/docker/libnetwork/datastore"
    10  	"github.com/docker/libnetwork/discoverapi"
    11  	"github.com/docker/libnetwork/netlabel"
    12  	"github.com/docker/libnetwork/types"
    13  )
    14  
    15  const (
    16  	macvlanPrefix         = "macvlan"
    17  	macvlanNetworkPrefix  = macvlanPrefix + "/network"
    18  	macvlanEndpointPrefix = macvlanPrefix + "/endpoint"
    19  )
    20  
    21  // networkConfiguration for this driver's network specific configuration
    22  type configuration struct {
    23  	ID               string
    24  	Mtu              int
    25  	dbIndex          uint64
    26  	dbExists         bool
    27  	Internal         bool
    28  	Parent           string
    29  	MacvlanMode      string
    30  	CreatedSlaveLink bool
    31  	Ipv4Subnets      []*ipv4Subnet
    32  	Ipv6Subnets      []*ipv6Subnet
    33  }
    34  
    35  type ipv4Subnet struct {
    36  	SubnetIP string
    37  	GwIP     string
    38  }
    39  
    40  type ipv6Subnet struct {
    41  	SubnetIP string
    42  	GwIP     string
    43  }
    44  
    45  // initStore drivers are responsible for caching their own persistent state
    46  func (d *driver) initStore(option map[string]interface{}) error {
    47  	if data, ok := option[netlabel.LocalKVClient]; ok {
    48  		var err error
    49  		dsc, ok := data.(discoverapi.DatastoreConfigData)
    50  		if !ok {
    51  			return types.InternalErrorf("incorrect data in datastore configuration: %v", data)
    52  		}
    53  		d.store, err = datastore.NewDataStoreFromConfig(dsc)
    54  		if err != nil {
    55  			return types.InternalErrorf("macvlan driver failed to initialize data store: %v", err)
    56  		}
    57  
    58  		return d.populateNetworks()
    59  	}
    60  
    61  	return nil
    62  }
    63  
    64  // populateNetworks is invoked at driver init to recreate persistently stored networks
    65  func (d *driver) populateNetworks() error {
    66  	kvol, err := d.store.List(datastore.Key(macvlanPrefix), &configuration{})
    67  	if err != nil && err != datastore.ErrKeyNotFound {
    68  		return fmt.Errorf("failed to get macvlan network configurations from store: %v", err)
    69  	}
    70  	// If empty it simply means no macvlan networks have been created yet
    71  	if err == datastore.ErrKeyNotFound {
    72  		return nil
    73  	}
    74  	for _, kvo := range kvol {
    75  		config := kvo.(*configuration)
    76  		if err = d.createNetwork(config); err != nil {
    77  			logrus.Warnf("Could not create macvlan network for id %s from persistent state", config.ID)
    78  		}
    79  	}
    80  
    81  	return nil
    82  }
    83  
    84  func (d *driver) populateEndpoints() error {
    85  	kvol, err := d.store.List(datastore.Key(macvlanEndpointPrefix), &endpoint{})
    86  	if err != nil && err != datastore.ErrKeyNotFound {
    87  		return fmt.Errorf("failed to get macvlan endpoints from store: %v", err)
    88  	}
    89  
    90  	if err == datastore.ErrKeyNotFound {
    91  		return nil
    92  	}
    93  
    94  	for _, kvo := range kvol {
    95  		ep := kvo.(*endpoint)
    96  		n, ok := d.networks[ep.nid]
    97  		if !ok {
    98  			logrus.Debugf("Network (%s) not found for restored macvlan endpoint (%s)", ep.nid[0:7], ep.id[0:7])
    99  			logrus.Debugf("Deleting stale macvlan endpoint (%s) from store", ep.id[0:7])
   100  			if err := d.storeDelete(ep); err != nil {
   101  				logrus.Debugf("Failed to delete stale macvlan endpoint (%s) from store", ep.id[0:7])
   102  			}
   103  			continue
   104  		}
   105  		n.endpoints[ep.id] = ep
   106  		logrus.Debugf("Endpoint (%s) restored to network (%s)", ep.id[0:7], ep.nid[0:7])
   107  	}
   108  
   109  	return nil
   110  }
   111  
   112  // storeUpdate used to update persistent macvlan network records as they are created
   113  func (d *driver) storeUpdate(kvObject datastore.KVObject) error {
   114  	if d.store == nil {
   115  		logrus.Warnf("macvlan store not initialized. kv object %s is not added to the store", datastore.Key(kvObject.Key()...))
   116  		return nil
   117  	}
   118  	if err := d.store.PutObjectAtomic(kvObject); err != nil {
   119  		return fmt.Errorf("failed to update macvlan store for object type %T: %v", kvObject, err)
   120  	}
   121  
   122  	return nil
   123  }
   124  
   125  // storeDelete used to delete macvlan records from persistent cache as they are deleted
   126  func (d *driver) storeDelete(kvObject datastore.KVObject) error {
   127  	if d.store == nil {
   128  		logrus.Debugf("macvlan store not initialized. kv object %s is not deleted from store", datastore.Key(kvObject.Key()...))
   129  		return nil
   130  	}
   131  retry:
   132  	if err := d.store.DeleteObjectAtomic(kvObject); err != nil {
   133  		if err == datastore.ErrKeyModified {
   134  			if err := d.store.GetObject(datastore.Key(kvObject.Key()...), kvObject); err != nil {
   135  				return fmt.Errorf("could not update the kvobject to latest when trying to delete: %v", err)
   136  			}
   137  			goto retry
   138  		}
   139  		return err
   140  	}
   141  
   142  	return nil
   143  }
   144  
   145  func (config *configuration) MarshalJSON() ([]byte, error) {
   146  	nMap := make(map[string]interface{})
   147  	nMap["ID"] = config.ID
   148  	nMap["Mtu"] = config.Mtu
   149  	nMap["Parent"] = config.Parent
   150  	nMap["MacvlanMode"] = config.MacvlanMode
   151  	nMap["Internal"] = config.Internal
   152  	nMap["CreatedSubIface"] = config.CreatedSlaveLink
   153  	if len(config.Ipv4Subnets) > 0 {
   154  		iis, err := json.Marshal(config.Ipv4Subnets)
   155  		if err != nil {
   156  			return nil, err
   157  		}
   158  		nMap["Ipv4Subnets"] = string(iis)
   159  	}
   160  	if len(config.Ipv6Subnets) > 0 {
   161  		iis, err := json.Marshal(config.Ipv6Subnets)
   162  		if err != nil {
   163  			return nil, err
   164  		}
   165  		nMap["Ipv6Subnets"] = string(iis)
   166  	}
   167  
   168  	return json.Marshal(nMap)
   169  }
   170  
   171  func (config *configuration) UnmarshalJSON(b []byte) error {
   172  	var (
   173  		err  error
   174  		nMap map[string]interface{}
   175  	)
   176  
   177  	if err = json.Unmarshal(b, &nMap); err != nil {
   178  		return err
   179  	}
   180  	config.ID = nMap["ID"].(string)
   181  	config.Mtu = int(nMap["Mtu"].(float64))
   182  	config.Parent = nMap["Parent"].(string)
   183  	config.MacvlanMode = nMap["MacvlanMode"].(string)
   184  	config.Internal = nMap["Internal"].(bool)
   185  	config.CreatedSlaveLink = nMap["CreatedSubIface"].(bool)
   186  	if v, ok := nMap["Ipv4Subnets"]; ok {
   187  		if err := json.Unmarshal([]byte(v.(string)), &config.Ipv4Subnets); err != nil {
   188  			return err
   189  		}
   190  	}
   191  	if v, ok := nMap["Ipv6Subnets"]; ok {
   192  		if err := json.Unmarshal([]byte(v.(string)), &config.Ipv6Subnets); err != nil {
   193  			return err
   194  		}
   195  	}
   196  
   197  	return nil
   198  }
   199  
   200  func (config *configuration) Key() []string {
   201  	return []string{macvlanNetworkPrefix, config.ID}
   202  }
   203  
   204  func (config *configuration) KeyPrefix() []string {
   205  	return []string{macvlanNetworkPrefix}
   206  }
   207  
   208  func (config *configuration) Value() []byte {
   209  	b, err := json.Marshal(config)
   210  	if err != nil {
   211  		return nil
   212  	}
   213  
   214  	return b
   215  }
   216  
   217  func (config *configuration) SetValue(value []byte) error {
   218  	return json.Unmarshal(value, config)
   219  }
   220  
   221  func (config *configuration) Index() uint64 {
   222  	return config.dbIndex
   223  }
   224  
   225  func (config *configuration) SetIndex(index uint64) {
   226  	config.dbIndex = index
   227  	config.dbExists = true
   228  }
   229  
   230  func (config *configuration) Exists() bool {
   231  	return config.dbExists
   232  }
   233  
   234  func (config *configuration) Skip() bool {
   235  	return false
   236  }
   237  
   238  func (config *configuration) New() datastore.KVObject {
   239  	return &configuration{}
   240  }
   241  
   242  func (config *configuration) CopyTo(o datastore.KVObject) error {
   243  	dstNcfg := o.(*configuration)
   244  	*dstNcfg = *config
   245  
   246  	return nil
   247  }
   248  
   249  func (config *configuration) DataScope() string {
   250  	return datastore.LocalScope
   251  }
   252  
   253  func (ep *endpoint) MarshalJSON() ([]byte, error) {
   254  	epMap := make(map[string]interface{})
   255  	epMap["id"] = ep.id
   256  	epMap["nid"] = ep.nid
   257  	epMap["SrcName"] = ep.srcName
   258  	if len(ep.mac) != 0 {
   259  		epMap["MacAddress"] = ep.mac.String()
   260  	}
   261  	if ep.addr != nil {
   262  		epMap["Addr"] = ep.addr.String()
   263  	}
   264  	if ep.addrv6 != nil {
   265  		epMap["Addrv6"] = ep.addrv6.String()
   266  	}
   267  	return json.Marshal(epMap)
   268  }
   269  
   270  func (ep *endpoint) UnmarshalJSON(b []byte) error {
   271  	var (
   272  		err   error
   273  		epMap map[string]interface{}
   274  	)
   275  
   276  	if err = json.Unmarshal(b, &epMap); err != nil {
   277  		return fmt.Errorf("Failed to unmarshal to macvlan endpoint: %v", err)
   278  	}
   279  
   280  	if v, ok := epMap["MacAddress"]; ok {
   281  		if ep.mac, err = net.ParseMAC(v.(string)); err != nil {
   282  			return types.InternalErrorf("failed to decode macvlan endpoint MAC address (%s) after json unmarshal: %v", v.(string), err)
   283  		}
   284  	}
   285  	if v, ok := epMap["Addr"]; ok {
   286  		if ep.addr, err = types.ParseCIDR(v.(string)); err != nil {
   287  			return types.InternalErrorf("failed to decode macvlan endpoint IPv4 address (%s) after json unmarshal: %v", v.(string), err)
   288  		}
   289  	}
   290  	if v, ok := epMap["Addrv6"]; ok {
   291  		if ep.addrv6, err = types.ParseCIDR(v.(string)); err != nil {
   292  			return types.InternalErrorf("failed to decode macvlan endpoint IPv6 address (%s) after json unmarshal: %v", v.(string), err)
   293  		}
   294  	}
   295  	ep.id = epMap["id"].(string)
   296  	ep.nid = epMap["nid"].(string)
   297  	ep.srcName = epMap["SrcName"].(string)
   298  
   299  	return nil
   300  }
   301  
   302  func (ep *endpoint) Key() []string {
   303  	return []string{macvlanEndpointPrefix, ep.id}
   304  }
   305  
   306  func (ep *endpoint) KeyPrefix() []string {
   307  	return []string{macvlanEndpointPrefix}
   308  }
   309  
   310  func (ep *endpoint) Value() []byte {
   311  	b, err := json.Marshal(ep)
   312  	if err != nil {
   313  		return nil
   314  	}
   315  	return b
   316  }
   317  
   318  func (ep *endpoint) SetValue(value []byte) error {
   319  	return json.Unmarshal(value, ep)
   320  }
   321  
   322  func (ep *endpoint) Index() uint64 {
   323  	return ep.dbIndex
   324  }
   325  
   326  func (ep *endpoint) SetIndex(index uint64) {
   327  	ep.dbIndex = index
   328  	ep.dbExists = true
   329  }
   330  
   331  func (ep *endpoint) Exists() bool {
   332  	return ep.dbExists
   333  }
   334  
   335  func (ep *endpoint) Skip() bool {
   336  	return false
   337  }
   338  
   339  func (ep *endpoint) New() datastore.KVObject {
   340  	return &endpoint{}
   341  }
   342  
   343  func (ep *endpoint) CopyTo(o datastore.KVObject) error {
   344  	dstEp := o.(*endpoint)
   345  	*dstEp = *ep
   346  	return nil
   347  }
   348  
   349  func (ep *endpoint) DataScope() string {
   350  	return datastore.LocalScope
   351  }