func (oc *OvsController) StartMaster(sync bool, containerNetwork string, containerSubnetLength uint) error {
// wait a minute for etcd to come alive
status := oc.subnetRegistry.CheckEtcdIsAlive(60)
if !status {
log.Errorf("Etcd not running?")
return errors.New("Etcd not reachable. Sync cluster check failed.")
}
// initialize the minion key
if sync {
err := oc.subnetRegistry.InitMinions()
if err != nil {
log.Infof("Minion path already initialized.")
}
}
// initialize the subnet key?
oc.subnetRegistry.InitSubnets()
subrange := make([]string, 0)
subnets, err := oc.subnetRegistry.GetSubnets()
if err != nil {
log.Errorf("Error in initializing/fetching subnets: %v", err)
return err
}
for _, sub := range *subnets {
subrange = append(subrange, sub.Sub)
}
err = oc.subnetRegistry.WriteNetworkConfig(containerNetwork, containerSubnetLength)
if err != nil {
return err
}
oc.subnetAllocator, err = netutils.NewSubnetAllocator(containerNetwork, containerSubnetLength, subrange)
if err != nil {
return err
}
err = oc.ServeExistingMinions()
if err != nil {
log.Warningf("Error initializing existing minions: %v", err)
// no worry, we can still keep watching it.
}
if _, is_mt := oc.flowController.(*multitenant.FlowController); is_mt {
nets, err := oc.subnetRegistry.GetNetNamespaces()
if err != nil {
return err
}
inUse := make([]uint, 0)
for _, net := range nets {
inUse = append(inUse, net.NetID)
oc.VnidMap[net.Name] = net.NetID
}
oc.netIDManager, err = netutils.NewNetIDAllocator(10, MaxUint, inUse)
if err != nil {
return err
}
go oc.watchNetworks()
}
go oc.watchMinions()
return nil
}
func (oc *OsdnController) VnidStartMaster() error {
err := populateVNIDMap(oc)
if err != nil {
return err
}
inUse := make([]uint, 0)
for _, netid := range oc.VNIDMap {
if netid != AdminVNID {
inUse = append(inUse, netid)
}
}
// VNID: 0 reserved for default namespace and can reach any network in the cluster
// VNID: 1 to 9 are internally reserved for any special cases in the future
oc.netIDManager, err = netutils.NewNetIDAllocator(10, MaxVNID, inUse)
if err != nil {
return err
}
// 'default' namespace is currently always an admin namespace
oc.adminNamespaces = append(oc.adminNamespaces, "default")
go watchNamespaces(oc)
return nil
}
func (oc *OsdnController) VnidStartMaster() error {
nets, _, err := oc.Registry.GetNetNamespaces()
if err != nil {
return err
}
inUse := make([]uint, 0)
for _, net := range nets {
if net.NetID != AdminVNID {
inUse = append(inUse, net.NetID)
}
oc.VNIDMap[net.Name] = net.NetID
}
// VNID: 0 reserved for default namespace and can reach any network in the cluster
// VNID: 1 to 9 are internally reserved for any special cases in the future
oc.netIDManager, err = netutils.NewNetIDAllocator(10, MaxVNID, inUse)
if err != nil {
return err
}
getNamespaces := func(registry *Registry) (interface{}, string, error) {
return registry.GetNamespaces()
}
result, err := oc.watchAndGetResource("Namespace", watchNamespaces, getNamespaces)
if err != nil {
return err
}
// 'default' namespace is currently always an admin namespace
oc.adminNamespaces = append(oc.adminNamespaces, "default")
// Handle existing namespaces
namespaces := result.([]kapi.Namespace)
for _, ns := range namespaces {
nsName := ns.ObjectMeta.Name
// Revoke invalid VNID for admin namespaces
if oc.isAdminNamespace(nsName) {
netid, ok := oc.VNIDMap[nsName]
if ok && (netid != AdminVNID) {
err := oc.revokeVNID(nsName)
if err != nil {
return err
}
}
}
_, found := oc.VNIDMap[nsName]
// Assign VNID for the namespace if it doesn't exist
if !found {
err := oc.assignVNID(nsName)
if err != nil {
return err
}
}
}
return nil
}
func (master *OsdnMaster) VnidStartMaster() error {
err := master.vnids.PopulateVNIDs(master.registry)
if err != nil {
return err
}
// VNID: 0 reserved for default namespace and can reach any network in the cluster
// VNID: 1 to 9 are internally reserved for any special cases in the future
master.netIDManager, err = netutils.NewNetIDAllocator(10, MaxVNID, master.vnids.GetAllocatedVNIDs())
if err != nil {
return err
}
// 'default' namespace is currently always an admin namespace
master.adminNamespaces = append(master.adminNamespaces, "default")
go utilwait.Forever(master.watchNamespaces, 0)
return nil
}
func (oc *OsdnController) VnidStartMaster() error {
err := populateVNIDMap(oc)
if err != nil {
return err
}
// VNID: 0 reserved for default namespace and can reach any network in the cluster
// VNID: 1 to 9 are internally reserved for any special cases in the future
oc.netIDManager, err = netutils.NewNetIDAllocator(10, MaxVNID, oc.getAllocatedVNIDs())
if err != nil {
return err
}
// 'default' namespace is currently always an admin namespace
oc.adminNamespaces = append(oc.adminNamespaces, "default")
go utilwait.Forever(oc.watchNamespaces, 0)
return nil
}
func (oc *OvsController) StartMaster(sync bool, clusterNetworkCIDR string, clusterBitsPerSubnet uint, serviceNetworkCIDR string) error {
// wait a minute for etcd to come alive
status := oc.subnetRegistry.CheckEtcdIsAlive(60)
if !status {
log.Errorf("Etcd not running?")
return errors.New("Etcd not reachable. Sync cluster check failed.")
}
// initialize the node key
if sync {
err := oc.subnetRegistry.InitNodes()
if err != nil {
log.Infof("Node path already initialized.")
}
}
// initialize the subnet key?
oc.subnetRegistry.InitSubnets()
subrange := make([]string, 0)
subnets, _, err := oc.subnetRegistry.GetSubnets()
if err != nil {
log.Errorf("Error in initializing/fetching subnets: %v", err)
return err
}
for _, sub := range subnets {
subrange = append(subrange, sub.SubnetCIDR)
}
err = oc.subnetRegistry.WriteNetworkConfig(clusterNetworkCIDR, clusterBitsPerSubnet, serviceNetworkCIDR)
if err != nil {
return err
}
oc.subnetAllocator, err = netutils.NewSubnetAllocator(clusterNetworkCIDR, clusterBitsPerSubnet, subrange)
if err != nil {
return err
}
result, err := oc.watchAndGetResource("Node")
if err != nil {
return err
}
nodes := result.([]api.Node)
err = oc.serveExistingNodes(nodes)
if err != nil {
return err
}
if _, is_mt := oc.flowController.(*multitenant.FlowController); is_mt {
nets, _, err := oc.subnetRegistry.GetNetNamespaces()
if err != nil {
return err
}
inUse := make([]uint, 0)
for _, net := range nets {
inUse = append(inUse, net.NetID)
oc.VNIDMap[net.Name] = net.NetID
}
// VNID: 0 reserved for default namespace and can reach any network in the cluster
// VNID: 1 to 9 are internally reserved for any special cases in the future
oc.netIDManager, err = netutils.NewNetIDAllocator(10, MaxVNID, inUse)
if err != nil {
return err
}
result, err := oc.watchAndGetResource("Namespace")
if err != nil {
return err
}
namespaces := result.([]string)
// Handle existing namespaces without VNID
for _, nsName := range namespaces {
// Skip admin namespaces, they will have VNID: 0
if oc.isAdminNamespace(nsName) {
// Revoke VNID if already exists
if _, ok := oc.VNIDMap[nsName]; ok {
err := oc.revokeVNID(nsName)
if err != nil {
return err
}
}
continue
}
// Skip if VNID already exists for the namespace
if _, ok := oc.VNIDMap[nsName]; ok {
continue
}
err := oc.assignVNID(nsName)
if err != nil {
return err
}
}
}
return nil
}
func (oc *OvsController) StartMaster(clusterNetworkCIDR string, clusterBitsPerSubnet uint, serviceNetworkCIDR string) error {
subrange := make([]string, 0)
subnets, _, err := oc.subnetRegistry.GetSubnets()
if err != nil {
log.Errorf("Error in initializing/fetching subnets: %v", err)
return err
}
for _, sub := range subnets {
subrange = append(subrange, sub.SubnetCIDR)
}
err = oc.subnetRegistry.WriteNetworkConfig(clusterNetworkCIDR, clusterBitsPerSubnet, serviceNetworkCIDR)
if err != nil {
return err
}
oc.subnetAllocator, err = netutils.NewSubnetAllocator(clusterNetworkCIDR, clusterBitsPerSubnet, subrange)
if err != nil {
return err
}
result, err := oc.watchAndGetResource("Node")
if err != nil {
return err
}
nodes := result.([]api.Node)
err = oc.serveExistingNodes(nodes)
if err != nil {
return err
}
if oc.isMultitenant() {
nets, _, err := oc.subnetRegistry.GetNetNamespaces()
if err != nil {
return err
}
inUse := make([]uint, 0)
for _, net := range nets {
if net.NetID != AdminVNID {
inUse = append(inUse, net.NetID)
}
oc.VNIDMap[net.Name] = net.NetID
}
// VNID: 0 reserved for default namespace and can reach any network in the cluster
// VNID: 1 to 9 are internally reserved for any special cases in the future
oc.netIDManager, err = netutils.NewNetIDAllocator(10, MaxVNID, inUse)
if err != nil {
return err
}
result, err := oc.watchAndGetResource("Namespace")
if err != nil {
return err
}
// Handle existing namespaces
namespaces := result.([]string)
for _, nsName := range namespaces {
// Revoke invalid VNID for admin namespaces
if oc.isAdminNamespace(nsName) {
netid, ok := oc.VNIDMap[nsName]
if ok && (netid != AdminVNID) {
err := oc.revokeVNID(nsName)
if err != nil {
return err
}
}
}
_, found := oc.VNIDMap[nsName]
// Assign VNID for the namespace if it doesn't exist
if !found {
err := oc.assignVNID(nsName)
if err != nil {
return err
}
}
}
}
return nil
}
func (oc *OvsController) StartMaster(sync bool, containerNetwork string, containerSubnetLength uint, serviceNetwork string) error {
// wait a minute for etcd to come alive
status := oc.subnetRegistry.CheckEtcdIsAlive(60)
if !status {
log.Errorf("Etcd not running?")
return errors.New("Etcd not reachable. Sync cluster check failed.")
}
// initialize the node key
if sync {
err := oc.subnetRegistry.InitNodes()
if err != nil {
log.Infof("Node path already initialized.")
}
}
// initialize the subnet key?
oc.subnetRegistry.InitSubnets()
subrange := make([]string, 0)
subnets, err := oc.subnetRegistry.GetSubnets()
if err != nil {
log.Errorf("Error in initializing/fetching subnets: %v", err)
return err
}
for _, sub := range subnets {
subrange = append(subrange, sub.SubnetIP)
}
err = oc.subnetRegistry.WriteNetworkConfig(containerNetwork, containerSubnetLength, serviceNetwork)
if err != nil {
return err
}
oc.subnetAllocator, err = netutils.NewSubnetAllocator(containerNetwork, containerSubnetLength, subrange)
if err != nil {
return err
}
err = oc.ServeExistingNodes()
if err != nil {
log.Warningf("Error initializing existing nodes: %v", err)
// no worry, we can still keep watching it.
}
if _, is_mt := oc.flowController.(*multitenant.FlowController); is_mt {
nets, err := oc.subnetRegistry.GetNetNamespaces()
if err != nil {
return err
}
inUse := make([]uint, 0)
for _, net := range nets {
inUse = append(inUse, net.NetID)
oc.VNIDMap[net.Name] = net.NetID
}
// VNID: 0 reserved for default namespace and can reach any network in the cluster
// VNID: 1 to 9 are internally reserved for any special cases in the future
oc.netIDManager, err = netutils.NewNetIDAllocator(10, MaxVNID, inUse)
if err != nil {
return err
}
go oc.watchNetworks()
}
go oc.watchNodes()
return nil
}