func (oc *OsdnController) SubnetStartMaster(clusterNetwork *net.IPNet, hostSubnetLength uint) error {
subrange := make([]string, 0)
subnets, err := oc.Registry.GetSubnets()
if err != nil {
log.Errorf("Error in initializing/fetching subnets: %v", err)
return err
}
for _, sub := range subnets {
subrange = append(subrange, sub.Subnet)
if err := oc.validateNode(sub.HostIP); err != nil {
// Don't error out; just warn so the error can be corrected with 'oc'
log.Errorf("Failed to validate HostSubnet %s: %v", err)
} else {
log.Infof("Found existing HostSubnet %s", HostSubnetToString(&sub))
}
}
oc.subnetAllocator, err = netutils.NewSubnetAllocator(clusterNetwork.String(), hostSubnetLength, subrange)
if err != nil {
return err
}
go utilwait.Forever(oc.watchNodes, 0)
return nil
}
func (oc *OvsController) SubnetStartMaster(clusterNetworkCIDR string, clusterBitsPerSubnet uint, serviceNetworkCIDR string) error {
subrange := make([]string, 0)
subnets, _, err := oc.Registry.GetSubnets()
if err != nil {
log.Errorf("Error in initializing/fetching subnets: %v", err)
return err
}
for _, sub := range subnets {
subrange = append(subrange, sub.SubnetCIDR)
}
oc.subnetAllocator, err = netutils.NewSubnetAllocator(clusterNetworkCIDR, clusterBitsPerSubnet, subrange)
if err != nil {
return err
}
getNodes := func(registry *Registry) (interface{}, string, error) {
return registry.GetNodes()
}
result, err := oc.watchAndGetResource("Node", watchNodes, getNodes)
if err != nil {
return err
}
nodes := result.([]api.Node)
err = oc.serveExistingNodes(nodes)
if err != nil {
return err
}
return nil
}
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) SubnetStartMaster(clusterNetwork *net.IPNet, hostSubnetLength uint) error {
subrange := make([]string, 0)
subnets, _, err := oc.Registry.GetSubnets()
if err != nil {
log.Errorf("Error in initializing/fetching subnets: %v", err)
return err
}
for _, sub := range subnets {
subrange = append(subrange, sub.Subnet)
if err := oc.validateNode(sub.HostIP); err != nil {
// Don't error out; just warn so the error can be corrected with 'oc'
log.Errorf("Failed to validate HostSubnet %s: %v", err)
}
}
oc.subnetAllocator, err = netutils.NewSubnetAllocator(clusterNetwork.String(), hostSubnetLength, subrange)
if err != nil {
return err
}
getNodes := func(registry *Registry) (interface{}, string, error) {
return registry.GetNodes()
}
result, err := oc.watchAndGetResource("Node", watchNodes, getNodes)
if err != nil {
return err
}
// Make sure each node has a Subnet allocated
nodes := result.([]kapi.Node)
for _, node := range nodes {
nodeIP, err := GetNodeIP(&node)
if err != nil {
// Don't error out; just warn so the error can be corrected by admin
log.Errorf("Failed to get Node %s IP: %v", node.Name, err)
continue
}
err = oc.validateNode(nodeIP)
if err != nil {
// Don't error out; just warn so the error can be corrected by admin
log.Errorf("Failed to validate Node %s: %v", node.Name, err)
continue
}
_, err = oc.Registry.GetSubnet(node.Name)
if err == nil {
// subnet already exists, continue
continue
}
err = oc.addNode(node.Name, nodeIP)
if err != nil {
return err
}
}
return nil
}
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.
}
go oc.watchMinions()
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
}