func (c *consistencyChecker) globalNetworkCheckPolicyAttachment(network *types.VirtualNetwork) bool { policyName := makeGlobalNetworkPolicyName(c.config, network.GetFQName()) policy, err := types.NetworkPolicyByName(c.client, strings.Join(policyName, ":")) if err != nil { glog.V(3).Infof("No network policy for %s", network.GetName()) return true } policyRefs, err := network.GetNetworkPolicyRefs() if err != nil { glog.Error(err) return true } for _, ref := range policyRefs { if ref.Uuid == policy.GetUuid() { glog.V(5).Infof("Network %s attached to %s", network.GetName(), policy.GetUuid()) return true } } err = policyAttach(c.client, network, policy) if err != nil { glog.Error(err) } else { glog.Infof("attached global network %s to policy", strings.Join(network.GetFQName(), ":")) } return false }
// Subnets can only be deleted if there are no instance-ips or floating-ips associated // with the subnet. func (m *NetworkManagerImpl) updateSubnetConfig(network *types.VirtualNetwork, prefix string) error { prefixList, err := m.NetworkIPPrefixList(network) if err != nil { glog.Fatal(err) } add := true for _, pfx := range prefixList { if pfx == prefix { add = false continue } ipRefs, err := network.GetInstanceIpBackRefs() if err != nil { glog.Error(err) continue } // TODO: filter the IP addresses associated with the subnet that we are // attempting to delete. if len(ipRefs) > 0 { glog.Warningf( "network %s %s is stale but there are %d instance-ips present", network.GetName(), pfx, len(ipRefs)) continue } pool, err := m.LookupFloatingIpPool(network) if err == nil { floatRefs, err := pool.GetFloatingIps() if err != nil { glog.Error(err) continue } // TODO: filter the floating-ips associated with the subnet that we // are attempting to delete. if len(floatRefs) > 0 { glog.Warningf( "network %s %s is stale but there are %d floating-ip addresses present", network.GetName(), pfx, len(floatRefs)) continue } } err = config.RemoveSubnet(m.client, network, pfx) if err != nil { glog.Error(err) } } if add { _, err := config.AddSubnet(m.client, network, m.config.PublicSubnet) if err != nil { glog.Error(err) } return err } return nil }
func (m *NetworkManagerImpl) DeleteFloatingIpPool(network *types.VirtualNetwork, cascade bool) error { obj, err := m.client.FindByName("floating-ip-pool", makePoolName(network)) if err != nil { glog.Errorf("Get floating-ip-pool %s: %v", network.GetName(), err) return err } if cascade { pool := obj.(*types.FloatingIpPool) m.floatingIpPoolDeleteChildren(pool) } m.client.Delete(obj) return nil }
func (m *NetworkManagerImpl) LocateFloatingIp(network *types.VirtualNetwork, resourceName, targetAddress string) (*types.FloatingIp, error) { obj, err := m.client.FindByName("floating-ip-pool", makePoolName(network)) if err != nil { glog.Errorf("Get floating-ip-pool %s: %v", network.GetName(), err) return nil, err } pool := obj.(*types.FloatingIpPool) fqn := AppendConst(pool.GetFQName(), resourceName) obj, err = m.client.FindByName("floating-ip", strings.Join(fqn, ":")) if err == nil { fip := obj.(*types.FloatingIp) if targetAddress != "" && fip.GetFloatingIpAddress() != targetAddress { fip.SetFloatingIpAddress(targetAddress) err = m.client.Update(fip) if err != nil { glog.Errorf("Update floating-ip %s: %v", resourceName, err) return nil, err } } return fip, nil } projectFQN := network.GetFQName()[0 : len(network.GetFQName())-1] obj, err = m.client.FindByName("project", strings.Join(projectFQN, ":")) if err != nil { glog.Errorf("Get project %s: %v", projectFQN[len(projectFQN)-1], err) return nil, err } project := obj.(*types.Project) fip := new(types.FloatingIp) fip.SetParent(pool) fip.SetName(resourceName) if targetAddress != "" { fip.SetFloatingIpAddress(targetAddress) } fip.AddProject(project) err = m.client.Create(fip) if err != nil { glog.Errorf("Create floating-ip %s: %v", resourceName, err) return nil, err } if targetAddress == "" { fip, err = types.FloatingIpByUuid(m.client, fip.GetUuid()) } return fip, err }
func (m *NetworkManagerImpl) LocateFloatingIpPool(network *types.VirtualNetwork) (*types.FloatingIpPool, error) { obj, err := m.client.FindByName("floating-ip-pool", makePoolName(network)) if err == nil { return obj.(*types.FloatingIpPool), nil } pool := new(types.FloatingIpPool) pool.SetName(network.GetName()) pool.SetParent(network) err = m.client.Create(pool) if err != nil { glog.Errorf("Create floating-ip-pool %s: %v", network.GetName(), err) return nil, err } return pool, nil }
func policyDetach(client contrail.ApiClient, network *types.VirtualNetwork, policyName string) error { refs, err := network.GetNetworkPolicyRefs() if err != nil { glog.Errorf("get network policy-refs %s: %v", network.GetName(), err) return err } for _, ref := range refs { if strings.Join(ref.To, ":") == policyName { network.DeleteNetworkPolicy(ref.Uuid) err := client.Update(network) if err != nil { glog.Errorf("Update network %s policies: %v", network.GetName(), err) } return err } } return nil }
func (m *ServiceManagerImpl) detachPolicy(network *types.VirtualNetwork, policyName string) error { refs, err := network.GetNetworkPolicyRefs() if err != nil { glog.Errorf("get network policy-refs %s: %v", network.GetName(), err) return err } for _, ref := range refs { if strings.Join(ref.To, ":") == policyName { network.DeleteNetworkPolicy(ref.Uuid) err := m.client.Update(network) if err != nil { glog.Errorf("Update network %s policies: %v", network.GetName(), err) } return err } } return nil }
func (m *NetworkManagerImpl) DeleteNetwork(network *types.VirtualNetwork) error { refs, err := network.GetNetworkPolicyRefs() if err != nil { glog.Errorf("Get %s policy refs: %v", network.GetName(), err) } m.client.Delete(network) for _, ref := range refs { obj, err := m.client.FindByUuid("network-policy", ref.Uuid) if err != nil { glog.Errorf("Get policy %s: %v", ref.Uuid, err) } policy := obj.(*types.NetworkPolicy) npRefs, err := policy.GetVirtualNetworkBackRefs() if len(npRefs) == 0 { m.client.Delete(policy) } } return nil }
func policyAttach(client contrail.ApiClient, network *types.VirtualNetwork, policy *types.NetworkPolicy) error { refs, err := network.GetNetworkPolicyRefs() if err != nil { glog.Errorf("get network policy-refs %s: %v", network.GetName(), err) return err } for _, ref := range refs { if ref.Uuid == policy.GetUuid() { return nil } } network.AddNetworkPolicy(policy, types.VirtualNetworkPolicyType{ Sequence: &types.SequenceType{Major: 10, Minor: 0}, }) err = client.Update(network) if err != nil { glog.Errorf("Update network %s policies: %v", network.GetName(), err) return err } return nil }
func (m *ServiceManagerImpl) attachPolicy(network *types.VirtualNetwork, policy *types.NetworkPolicy) error { refs, err := network.GetNetworkPolicyRefs() if err != nil { glog.Errorf("get network policy-refs %s: %v", network.GetName(), err) return err } for _, ref := range refs { if ref.Uuid == policy.GetUuid() { return nil } } network.AddNetworkPolicy(policy, types.VirtualNetworkPolicyType{ Sequence: &types.SequenceType{10, 0}, }) err = m.client.Update(network) if err != nil { glog.Errorf("Update network %s policies: %v", network.GetName(), err) return err } return nil }
func buildNetworkInfo(net *types.VirtualNetwork, detail bool) ( *NetworkInfo, error) { var subnets []string var policies []string refList, err := net.GetNetworkIpamRefs() if err != nil { return nil, err } for _, ref := range refList { attr := ref.Attr.(types.VnSubnetsType) for _, ipamSubnet := range attr.IpamSubnets { subnets = append(subnets, fmt.Sprintf("%s/%d", ipamSubnet.Subnet.IpPrefix, ipamSubnet.Subnet.IpPrefixLen)) } } if detail { refList, err = net.GetNetworkPolicyRefs() for _, ref := range refList { policies = append(policies, strings.Join(ref.To, ":")) } } info := &NetworkInfo{ net.GetUuid(), net.GetName(), net.GetIdPerms().Enable, net.GetVirtualNetworkProperties().NetworkId, net.GetVirtualNetworkProperties().AllowTransit, net.GetVirtualNetworkProperties().ForwardingMode, subnets, policies, net.GetRouteTargetList().RouteTarget, } return info, err }
func (m *NetworkManagerImpl) LocateFloatingIpPool( network *types.VirtualNetwork, subnet string) (*types.FloatingIpPool, error) { obj, err := m.client.FindByName( "floating-ip-pool", makePoolName(network)) if err == nil { return obj.(*types.FloatingIpPool), nil } address, prefixlen := PrefixToAddressLen(subnet) pool := new(types.FloatingIpPool) pool.SetName(network.GetName()) pool.SetParent(network) pool.SetFloatingIpPoolPrefixes( &types.FloatingIpPoolType{ Subnet: []types.SubnetType{types.SubnetType{address, prefixlen}}}) err = m.client.Create(pool) if err != nil { glog.Errorf("Create floating-ip-pool %s: %v", network.GetName(), err) return nil, err } return pool, nil }
func (m *NetworkManagerImpl) GetGatewayAddress(network *types.VirtualNetwork) (string, error) { refs, err := network.GetNetworkIpamRefs() if err != nil { glog.Errorf("Get network %s network-ipam refs: %v", network.GetName(), err) return "", err } attr := refs[0].Attr.(types.VnSubnetsType) if len(attr.IpamSubnets) == 0 { glog.Errorf("Network %s has no subnets configured", network.GetName()) return "", fmt.Errorf("Network %s: empty subnet list", network.GetName()) } gateway := attr.IpamSubnets[0].DefaultGateway if gateway == "" { glog.Errorf("Gateway for %s is empty", network.GetName()) return "", fmt.Errorf("Gateway is empty: %+v", attr.IpamSubnets) } return gateway, nil }