func (m *ServiceManagerImpl) locatePolicyRule(policy *types.NetworkPolicy, lhs, rhs *types.VirtualNetwork) error {
lhsName := strings.Join(lhs.GetFQName(), ":")
rhsName := strings.Join(rhs.GetFQName(), ":")
entries := policy.GetNetworkPolicyEntries()
for _, rule := range entries.PolicyRule {
if rule.SrcAddresses[0].VirtualNetwork == lhsName &&
rule.DstAddresses[0].VirtualNetwork == rhsName {
return nil
}
}
rule := new(types.PolicyRuleType)
rule.Protocol = "any"
rule.Direction = "<>"
rule.SrcAddresses = []types.AddressType{types.AddressType{
VirtualNetwork: lhsName,
}}
rule.DstAddresses = []types.AddressType{types.AddressType{
VirtualNetwork: rhsName,
}}
rule.SrcPorts = []types.PortType{types.PortType{-1, -1}}
rule.DstPorts = []types.PortType{types.PortType{-1, -1}}
rule.ActionList = &types.ActionListType{
SimpleAction: "pass",
}
entries.AddPolicyRule(rule)
policy.SetNetworkPolicyEntries(&entries)
err := m.client.Update(policy)
if err != nil {
glog.Errorf("policy-rule: %v", err)
return err
}
return nil
}
func (m *NetworkManagerImpl) DeleteConnections(network *types.VirtualNetwork, policies map[string]string) error {
for policyID, _ := range policies {
network.DeleteNetworkPolicy(policyID)
}
err := m.client.Update(network)
for policyID, targetName := range policies {
policy, policyErr := types.NetworkPolicyByUuid(m.client, policyID)
if policyErr != nil {
glog.Error(policyErr)
continue
}
networkRefs, policyErr := policy.GetVirtualNetworkBackRefs()
if len(networkRefs) > 1 {
continue
}
if len(networkRefs) == 1 {
if strings.Join(networkRefs[0].To, ":") == targetName {
policyErr = m.disconnectNetworkFromPolicy(policy, targetName)
if policyErr != nil {
glog.Error(policyErr)
continue
}
} else {
continue
}
}
policyErr = m.client.Delete(policy)
if policyErr != nil {
glog.Error(policyErr)
}
}
return err
}
func (m *ServiceManagerImpl) DeleteConnections(network *types.VirtualNetwork, purgeList []string) error {
if len(purgeList) == 0 {
return nil
}
for _, policyId := range purgeList {
network.DeleteNetworkPolicy(policyId)
}
err := m.client.Update(network)
if err != nil {
return err
}
for _, policyId := range purgeList {
policy, err := types.NetworkPolicyByUuid(m.client, policyId)
if err != nil {
glog.Error(err)
continue
}
refs, err := policy.GetVirtualNetworkBackRefs()
if err != nil {
glog.Error(err)
continue
}
if len(refs) == 0 {
err = m.client.Delete(policy)
if err != nil {
glog.Error(err)
}
}
}
return nil
}
func TestReadChildren(t *testing.T) {
client := new(ApiClient)
client.Init()
project := new(types.Project)
project.SetFQName("domain", []string{"default-domain", "p1"})
assert.NoError(t, client.Create(project))
net := new(types.VirtualNetwork)
net.SetFQName("project", []string{"default-domain", "p1", "n1"})
assert.NoError(t, client.Create(net))
vmi1 := new(types.VirtualMachineInterface)
vmi1.SetFQName("project", []string{"default-domain", "p1", "port1"})
vmi1.AddVirtualNetwork(net)
assert.NoError(t, client.Create(vmi1))
vmi2 := new(types.VirtualMachineInterface)
vmi2.SetFQName("project", []string{"default-domain", "p1", "port2"})
vmi2.AddVirtualNetwork(net)
assert.NoError(t, client.Create(vmi2))
refs, err := project.GetVirtualMachineInterfaces()
assert.NoError(t, err)
assert.Len(t, refs, 2)
}
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
}
func (m *InstanceManager) LocateInterface(
network *types.VirtualNetwork, instance *types.VirtualMachine) *types.VirtualMachineInterface {
tenant := network.GetFQName()[len(network.GetFQName())-2]
fqn := interfaceFQName(m.config.DefaultDomain, tenant, instance.GetName())
obj, err := m.client.FindByName(
"virtual-machine-interface", strings.Join(fqn, ":"))
if err == nil {
nic := obj.(*types.VirtualMachineInterface)
// TODO(prm): ensure network is as expected, else update.
return nic
}
nic := new(types.VirtualMachineInterface)
nic.SetFQName("project", fqn)
nic.AddVirtualMachine(instance)
if network != nil {
nic.AddVirtualNetwork(network)
}
err = m.client.Create(nic)
if err != nil {
glog.Errorf("Create interface %s: %v", instance.GetName(), err)
return nil
}
obj, err = m.client.FindByUuid(nic.GetType(), nic.GetUuid())
if err != nil {
glog.Errorf("Get vmi %s: %v", nic.GetUuid(), err)
return nil
}
return obj.(*types.VirtualMachineInterface)
}
func TestPropertyUpdate(t *testing.T) {
client := contrail.NewClient("localhost", 8082)
net := types.VirtualNetwork{}
net.SetName("test")
err := client.Create(&net)
if err != nil {
t.Error(err)
}
defer client.Delete(&net)
props := net.GetVirtualNetworkProperties()
if len(props.ForwardingMode) > 0 {
t.Error(props.ForwardingMode)
}
props.ForwardingMode = "l2_l3"
net.SetVirtualNetworkProperties(&props)
err = client.Update(&net)
if err != nil {
t.Error(err)
}
obj, err := client.FindByUuid("virtual-network", net.GetUuid())
if err != nil {
t.Fatal(err)
}
netPtr := obj.(*types.VirtualNetwork)
p2 := netPtr.GetVirtualNetworkProperties()
if p2.ForwardingMode != "l2_l3" {
t.Errorf("Expected: l2_l3 got: %s", p2.ForwardingMode)
}
}
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 (c *Controller) globalNetworkConnectionUpdate(network *types.VirtualNetwork) {
if !networkAccessGlobalNetworks(c.config, network.GetFQName()) {
return
}
// connect to each of the global-networks
for _, gbl := range c.config.GlobalNetworks {
err := c.networkMgr.Connect(network, gbl)
if err != nil {
glog.Error(err)
continue
}
glog.V(2).Infof("Connected %s to %s", strings.Join(network.GetFQName(), ":"), gbl)
}
}
func TestPodCreate(t *testing.T) {
kube := mocks.NewKubeClient()
client := new(contrail_mocks.ApiClient)
client.Init()
client.AddInterceptor("virtual-machine-interface", &VmiInterceptor{})
allocator := new(mocks.AddressAllocator)
networkMgr := new(mocks.NetworkManager)
controller := NewTestController(kube, client, allocator, networkMgr)
pod := &api.Pod{
ObjectMeta: api.ObjectMeta{
Name: "test",
Namespace: "testns",
UID: kubetypes.UID(uuid.New()),
Labels: map[string]string{
"name": "testnet",
},
},
}
netnsProject := new(types.Project)
netnsProject.SetUuid(uuid.New())
netnsProject.SetFQName("", []string{"default-domain", "testns"})
client.Create(netnsProject)
testnet := new(types.VirtualNetwork)
testnet.SetFQName("project", []string{"default-domain", "testns", "testnet"})
client.Create(testnet)
allocator.On("LocateIpAddress", string(pod.ObjectMeta.UID)).Return("10.0.0.42", nil)
networkMgr.On("LocateNetwork", "testns", "testnet",
controller.config.PrivateSubnet).Return(testnet, nil)
networkMgr.On("GetGatewayAddress", testnet).Return("10.0.255.254", nil)
kube.PodInterface.On("Update", pod).Return(pod, nil)
shutdown := make(chan struct{})
go controller.Run(shutdown)
controller.AddPod(pod)
time.Sleep(100 * time.Millisecond)
type shutdownMsg struct {
}
shutdown <- shutdownMsg{}
kube.PodInterface.AssertExpectations(t)
}
func CreateNetworkWithSubnet(
client contrail.ApiClient, project_id, name, prefix string) (
string, error) {
expr := regexp.MustCompile(`(([0-9]{1,3}\.){3}[0-9]{1,3})/([0-9]{1,2})`)
match := expr.FindStringSubmatch(prefix)
if match == nil {
return "", fmt.Errorf("Invalid subnet prefix %s", prefix)
}
address := match[1]
prefixlen, _ := strconv.Atoi(match[3])
obj, err := client.FindByUuid("project", project_id)
if err != nil {
return "", err
}
project := obj.(*types.Project)
refList, err := project.GetNetworkIpams()
if err != nil {
return "", err
}
var ipam *types.NetworkIpam
if len(refList) > 0 {
obj, err := client.FindByUuid("network-ipam", refList[0].Uuid)
if err != nil {
return "", err
}
ipam = obj.(*types.NetworkIpam)
} else {
obj, err := client.FindByName("network-ipam",
"default-domain:default-project:default-network-ipam")
if err != nil {
return "", err
}
ipam = obj.(*types.NetworkIpam)
}
net := new(types.VirtualNetwork)
net.SetParent(project)
net.SetName(name)
subnets := types.VnSubnetsType{}
subnets.AddIpamSubnets(
&types.IpamSubnetType{
Subnet: &types.SubnetType{address, prefixlen}})
net.AddNetworkIpam(ipam, subnets)
err = client.Create(net)
if err != nil {
return "", err
}
return net.GetUuid(), nil
}
func TestCreate(t *testing.T) {
client := contrail.NewClient("localhost", 8082)
net := types.VirtualNetwork{}
net.SetName("test")
ipam, err := client.FindByName("network-ipam",
"default-domain:default-project:default-network-ipam")
if err != nil {
t.Fatal(err)
}
subnets := types.VnSubnetsType{}
subnets.AddIpamSubnets(
&types.IpamSubnetType{
Subnet: &types.SubnetType{"10.0.0.0", 8}})
net.AddNetworkIpam(ipam.(*types.NetworkIpam), subnets)
err = client.Create(&net)
if err != nil {
t.Error(err)
}
if len(net.GetUuid()) == 0 {
t.Error("No uuid assigned")
}
netPtr, err := client.FindByUuid("virtual-network", net.GetUuid())
if err != nil {
t.Error(err)
} else {
xnet := netPtr.(*types.VirtualNetwork)
refs, err := xnet.GetNetworkIpamRefs()
if err != nil {
t.Error(err)
} else if len(refs) > 0 {
xattr := refs[0].Attr.(types.VnSubnetsType)
if len(xattr.IpamSubnets) == 1 {
isubnet := xattr.IpamSubnets[0]
if isubnet.Subnet.IpPrefix != "10.0.0.0" ||
isubnet.Subnet.IpPrefixLen != 8 {
t.Errorf("Bad subnet %s/%d",
isubnet.Subnet.IpPrefix,
isubnet.Subnet.IpPrefixLen)
}
} else {
t.Errorf("%d subnets", len(xattr.IpamSubnets))
}
} else {
t.Error("Empty network-ipam reference list")
}
}
err = client.Delete(&net)
if err != nil {
t.Error(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 (m *ServiceManagerImpl) PurgeStalePolicyRefs(network *types.VirtualNetwork, services ServiceIdList,
doDelete func(string, string) bool) error {
purgeList := make([]string, 0)
refs, err := network.GetNetworkPolicyRefs()
if err != nil {
return err
}
for _, ref := range refs {
if len(ref.To) < 3 {
glog.Errorf("unexpected policy id %+v", ref.To)
continue
}
namespace := ref.To[1]
serviceName := ref.To[len(ref.To)-1]
if !services.Contains(namespace, serviceName) && doDelete(namespace, serviceName) {
purgeList = append(purgeList, ref.Uuid)
}
}
if len(purgeList) == 0 {
return nil
}
for _, policyId := range purgeList {
network.DeleteNetworkPolicy(policyId)
}
err = m.client.Update(network)
if err != nil {
return err
}
for _, policyId := range purgeList {
policy, err := types.NetworkPolicyByUuid(m.client, policyId)
if err != nil {
glog.Error(err)
continue
}
refs, err := policy.GetVirtualNetworkBackRefs()
if err != nil {
glog.Error(err)
}
if len(refs) == 0 {
err = m.client.Delete(policy)
if err != nil {
glog.Error(err)
}
}
}
return nil
}
//
// Retrieve the list of IP prefixes associated with this network.
//
func (m *NetworkManagerImpl) NetworkIPPrefixList(network *types.VirtualNetwork) ([]string, error) {
prefixList := make([]string, 0)
refList, err := network.GetNetworkIpamRefs()
if err != nil {
return nil, err
}
for _, ref := range refList {
attr := ref.Attr.(types.VnSubnetsType)
for _, ipamSubnet := range attr.IpamSubnets {
prefixList = append(prefixList,
fmt.Sprintf("%s/%d", ipamSubnet.Subnet.IpPrefix, ipamSubnet.Subnet.IpPrefixLen))
}
}
return prefixList, nil
}
func TestReadModifiedPolicy(t *testing.T) {
client := new(ApiClient)
client.Init()
project := new(types.Project)
project.SetFQName("domain", []string{"default-domain", "p1"})
assert.NoError(t, client.Create(project))
policy := new(types.NetworkPolicy)
policy.SetFQName("project", []string{"default-domain", "p1", "x"})
assert.NoError(t, client.Create(policy))
net1 := new(types.VirtualNetwork)
net1.SetFQName("project", []string{"default-domain", "p1", "n1"})
net1.AddNetworkPolicy(policy,
types.VirtualNetworkPolicyType{
Sequence: &types.SequenceType{10, 0},
})
assert.NoError(t, client.Create(net1))
net2 := new(types.VirtualNetwork)
net2.SetFQName("project", []string{"default-domain", "p1", "n2"})
net2.AddNetworkPolicy(policy,
types.VirtualNetworkPolicyType{
Sequence: &types.SequenceType{10, 0},
})
assert.NoError(t, client.Create(net2))
refs, err := policy.GetVirtualNetworkBackRefs()
assert.NoError(t, err)
assert.Len(t, refs, 2)
assert.NoError(t, client.Delete(net1))
refs, err = policy.GetVirtualNetworkBackRefs()
assert.NoError(t, err)
assert.Len(t, refs, 1)
assert.NoError(t, client.Delete(net2))
refs, err = policy.GetVirtualNetworkBackRefs()
assert.NoError(t, err)
assert.Len(t, refs, 0)
}
func TestChildrenRefs(t *testing.T) {
db := NewInMemDatabase()
project := new(types.Project)
project.SetUuid(uuid.New())
project.SetName("p1")
assert.NoError(t, db.Put(project, nil, GetReferenceList(project)))
net := new(types.VirtualNetwork)
net.SetUuid(uuid.New())
net.SetFQName("project", []string{"p1", "n1"})
assert.NoError(t, db.Put(net, project, UIDList{}))
vmi1 := new(types.VirtualMachineInterface)
vmi1.SetUuid(uuid.New())
vmi1.SetName("port1")
vmi1.AddVirtualNetwork(net)
assert.NoError(t, db.Put(vmi1, project, GetReferenceList(vmi1)))
vmi2 := new(types.VirtualMachineInterface)
vmi2.SetUuid(uuid.New())
vmi2.SetName("port2")
vmi2.AddVirtualNetwork(net)
assert.NoError(t, db.Put(vmi2, project, GetReferenceList(vmi2)))
result, err := db.GetChildren(parseUID(project.GetUuid()), "virtual_network")
assert.NoError(t, err)
assert.Len(t, result, 1)
result, err = db.GetChildren(parseUID(project.GetUuid()), "virtual_machine_interface")
assert.NoError(t, err)
assert.Len(t, result, 2)
assert.Contains(t, result, parseUID(vmi1.GetUuid()))
assert.Contains(t, result, parseUID(vmi2.GetUuid()))
assert.Error(t, db.Delete(project))
assert.NoError(t, db.Delete(vmi1))
assert.Error(t, db.Delete(net))
assert.NoError(t, db.Delete(vmi2))
assert.NoError(t, db.Delete(net))
assert.NoError(t, db.Delete(project))
}
// connectionShouldDelete returns true when a connection should be deleted.
// When a connection is first considered to be stale it is added to a GC list; if it is considered to be stale
// in two consistency runs, it is deleted.
func (c *consistencyChecker) connectionShouldDelete(network *types.VirtualNetwork, lastIterationMap networkConnectionMap, policyName []string) bool {
networkName := strings.Join(network.GetFQName(), ":")
policyCSN := strings.Join(policyName, ":")
if entry, ok := lastIterationMap[networkName]; ok {
if _, exists := entry[policyCSN]; exists {
glog.Infof("%s network connection %s delete", networkName, policyCSN)
return true
}
}
gcPolicies, exists := c.staleConnectionMap[networkName]
if !exists {
gcPolicies = make(policySet, 0)
c.staleConnectionMap[networkName] = gcPolicies
}
glog.Infof("%s network connection %s not used by pod specifications", networkName, policyCSN)
gcPolicies[policyCSN] = true
return false
}
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 (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
}
func TestReadRefs(t *testing.T) {
client := new(ApiClient)
client.Init()
project := new(types.Project)
project.SetFQName("domain", []string{"default-domain", "p1"})
assert.NoError(t, client.Create(project))
net := new(types.VirtualNetwork)
net.SetFQName("project", []string{"default-domain", "p1", "n1"})
assert.NoError(t, client.Create(net))
vmi1 := new(types.VirtualMachineInterface)
vmi1.SetFQName("project", []string{"default-domain", "p1", "port1"})
vmi1.AddVirtualNetwork(net)
assert.NoError(t, client.Create(vmi1))
refs, err := vmi1.GetVirtualNetworkRefs()
assert.NoError(t, err)
assert.Len(t, refs, 1)
assert.Equal(t, net.GetUuid(), refs[0].Uuid)
}
// 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) 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
}
// Connect creates a network-policy and corresponding policy rule (when they do not exist) in order to
// connect the source network with the target. The target network may or not exist yet.
func (m *NetworkManagerImpl) Connect(network *types.VirtualNetwork, targetCSN string) error {
targetName := strings.Split(targetCSN, ":")
policy, err := m.locatePolicy(targetName)
if err != nil {
return err
}
policyAttach(m.client, network, policy)
target, err := types.VirtualNetworkByName(m.client, targetCSN)
if err == nil {
err = policyAttach(m.client, target, policy)
if err != nil {
glog.Error(err)
}
}
err = policyLocateRuleByFQN(m.client, policy, network.GetFQName(), targetName)
if err != nil {
return err
}
return 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 TestReadBackRefs(t *testing.T) {
client := new(ApiClient)
client.Init()
project := new(types.Project)
project.SetFQName("domain", []string{"default-domain", "p1"})
assert.NoError(t, client.Create(project))
net := new(types.VirtualNetwork)
net.SetFQName("project", []string{"default-domain", "p1", "n1"})
props := new(types.VirtualNetworkType)
props.ForwardingMode = "turbo"
net.SetVirtualNetworkProperties(props)
assert.NoError(t, client.Create(net))
vmi1 := new(types.VirtualMachineInterface)
vmi1.SetFQName("project", []string{"default-domain", "p1", "port1"})
vmi1.AddVirtualNetwork(net)
assert.NoError(t, client.Create(vmi1))
vmi2 := new(types.VirtualMachineInterface)
vmi2.SetFQName("project", []string{"default-domain", "p1", "port2"})
vmi2.AddVirtualNetwork(net)
assert.NoError(t, client.Create(vmi2))
refs, err := net.GetVirtualMachineInterfaceBackRefs()
assert.NoError(t, err)
assert.Len(t, refs, 2)
idList := make([]string, len(refs))
for i, ref := range refs {
idList[i] = ref.Uuid
}
assert.Contains(t, idList, vmi1.GetUuid())
assert.Contains(t, idList, vmi2.GetUuid())
rProps := net.GetVirtualNetworkProperties()
assert.Equal(t, "turbo", rProps.ForwardingMode)
}
func TestReference(t *testing.T) {
db := NewInMemDatabase()
ipam := new(types.NetworkIpam)
ipam.SetUuid(uuid.New())
ipam.SetFQName("project", strings.Split("default-domain:p1:ipam", ":"))
assert.NoError(t, db.Put(ipam, nil, UIDList{}))
net := new(types.VirtualNetwork)
net.SetUuid(uuid.New())
net.SetFQName("project", strings.Split("default-domain:p1:network", ":"))
subnets := types.VnSubnetsType{}
subnets.AddIpamSubnets(
&types.IpamSubnetType{
Subnet: &types.SubnetType{"10.0.0.0", 8}})
net.AddNetworkIpam(ipam, subnets)
refs := GetReferenceList(net)
assert.NoError(t, db.Put(net, nil, refs))
result, err := db.GetBackReferences(parseUID(ipam.GetUuid()), "virtual_network")
assert.NoError(t, err)
assert.Contains(t, result, parseUID(net.GetUuid()))
}
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 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
}