// assignVNID, revokeVNID and updateVNID methods updates in-memory structs and persists etcd objects
func (vmap *masterVNIDMap) assignVNID(osClient *osclient.Client, nsName string) error {
vmap.lock.Lock()
defer vmap.lock.Unlock()
netid, exists, err := vmap.allocateNetID(nsName)
if err != nil {
return err
}
if !exists {
// Create NetNamespace Object and update vnid map
netns := &osapi.NetNamespace{
TypeMeta: unversioned.TypeMeta{Kind: "NetNamespace"},
ObjectMeta: kapi.ObjectMeta{Name: nsName},
NetName: nsName,
NetID: netid,
}
_, err := osClient.NetNamespaces().Create(netns)
if err != nil {
vmap.releaseNetID(nsName)
return err
}
}
return nil
}
func updateNetNamespace(osClient *osclient.Client, netns *sdnapi.NetNamespace, action sdnapi.PodNetworkAction, args string) (*sdnapi.NetNamespace, error) {
sdnapi.SetChangePodNetworkAnnotation(netns, action, args)
_, err := osClient.NetNamespaces().Update(netns)
if err != nil {
return nil, err
}
backoff := utilwait.Backoff{
Duration: 100 * time.Millisecond,
Factor: 2,
Steps: 5,
}
name := netns.Name
err = utilwait.ExponentialBackoff(backoff, func() (bool, error) {
netns, err = osClient.NetNamespaces().Get(name)
if err != nil {
return false, err
}
if _, _, err := sdnapi.GetChangePodNetworkAnnotation(netns); err == sdnapi.ErrorPodNetworkAnnotationNotFound {
return true, nil
} else {
return false, nil
}
})
if err != nil {
return nil, err
}
return netns, nil
}
func createProject(osClient *osclient.Client, clientConfig *restclient.Config, name string) (*sdnapi.NetNamespace, error) {
_, err := testserver.CreateNewProject(osClient, *clientConfig, name, name)
if err != nil {
return nil, fmt.Errorf("error creating project %q: %v", name, err)
}
backoff := utilwait.Backoff{
Duration: 100 * time.Millisecond,
Factor: 2,
Steps: 5,
}
var netns *sdnapi.NetNamespace
err = utilwait.ExponentialBackoff(backoff, func() (bool, error) {
netns, err = osClient.NetNamespaces().Get(name)
if kapierrors.IsNotFound(err) {
return false, nil
} else if err != nil {
return false, err
}
return true, nil
})
if err != nil {
return nil, fmt.Errorf("could not get NetNamepsace %q: %v", name, err)
}
return netns, nil
}
func (vmap *nodeVNIDMap) populateVNIDs(osClient *osclient.Client) error {
nets, err := osClient.NetNamespaces().List(kapi.ListOptions{})
if err != nil {
return err
}
for _, net := range nets.Items {
vmap.setVNID(net.Name, net.NetID)
}
return nil
}
func (vmap *masterVNIDMap) revokeVNID(osClient *osclient.Client, nsName string) error {
vmap.lock.Lock()
defer vmap.lock.Unlock()
// Delete NetNamespace object
if err := osClient.NetNamespaces().Delete(nsName); err != nil {
return err
}
if err := vmap.releaseNetID(nsName); err != nil {
return err
}
return nil
}
func (vmap *masterVNIDMap) updateVNID(osClient *osclient.Client, netns *osapi.NetNamespace) error {
action, args, err := osapi.GetChangePodNetworkAnnotation(netns)
if err == osapi.ErrorPodNetworkAnnotationNotFound {
// Nothing to update
return nil
}
vmap.lock.Lock()
defer vmap.lock.Unlock()
netid, err := vmap.updateNetID(netns.NetName, action, args)
if err != nil {
return err
}
netns.NetID = netid
osapi.DeleteChangePodNetworkAnnotation(netns)
if _, err := osClient.NetNamespaces().Update(netns); err != nil {
return err
}
return nil
}
func (vmap *masterVNIDMap) populateVNIDs(osClient *osclient.Client) error {
netnsList, err := osClient.NetNamespaces().List(kapi.ListOptions{})
if err != nil {
return err
}
for _, netns := range netnsList.Items {
vmap.setVNID(netns.NetName, netns.NetID)
// Skip GlobalVNID, not part of netID allocation range
if netns.NetID == osapi.GlobalVNID {
continue
}
switch err := vmap.netIDManager.Allocate(netns.NetID); err {
case nil: // Expected normal case
case pnetid.ErrAllocated: // Expected when project networks are joined
default:
return fmt.Errorf("unable to allocate netid %d: %v", netns.NetID, err)
}
}
return nil
}