planetstack/model_policies/model_policy_Slice.py

   1
   2 def handle(slice):
   3         from core.models import SiteDeployments,SliceDeployment,Deployment,Network,NetworkSlice,NetworkTemplate
   4         from collections import defaultdict
   5         site_deployments = SiteDeployments.objects.all()
   6         site_deploy_lookup = defaultdict(list)
   7         for site_deployment in site_deployments:
   8                 site_deploy_lookup[site_deployment.site].append(site_deployment.deployment)
   9
  10         slice_deployments = SliceDeployment.objects.all()
  11         slice_deploy_lookup = defaultdict(list)
  12         for slice_deployment in slice_deployments:
  13                 slice_deploy_lookup[slice_deployment.slice].append(slice_deployment.deployment)
  14
  15         all_deployments = Deployment.objects.all()
  16         # slices are added to all deployments for now
  17         expected_deployments = all_deployments
  18         #expected_deployments = site_deploy_lookup[slice.site]
  19         for expected_deployment in expected_deployments:
  20                 if slice not in slice_deploy_lookup or \
  21                    expected_deployment not in slice_deploy_lookup[slice]:
  22                         sd = SliceDeployment(slice=slice, deployment=expected_deployment)
  23                         sd.save()
  24
  25         # make sure slice has at least 1 public and 1 private networkd
  26         public_nets = []
  27         private_net = None
  28         networks = Network.objects.filter(owner=slice)
  29         for network in networks:
  30                 if network.template.name == 'Public dedicated IPv4':
  31                         public_nets.append(network)
  32                 elif network.template.name == 'Public shared IPv4':
  33                         public_nets.append(network)
  34                 elif network.template.name == 'Private':
  35                         private_net = network
  36         if not public_nets:
  37                 # ensure there is at least one public network, and default it to dedicated
  38                 nat_net = Network(
  39                     name = slice.name+'-nat',
  40                     template = NetworkTemplate.objects.get(name='Public shared IPv4'),
  41                     owner = slice
  42                     )
  43                 nat_net.save()
  44                 public_nets.append(nat_net)
  45
  46         if not private_net:
  47                 private_net = Network(
  48                 name = slice.name+'-private',
  49                 template = NetworkTemplate.objects.get(name='Private'),
  50                 owner = slice
  51                 )
  52                 private_net.save()
  53         # create slice networks
  54         public_net_slice = None
  55         private_net_slice = None
  56         net_slices = NetworkSlice.objects.filter(slice=slice, network__in=[private_net]+public_nets)
  57         for net_slice in net_slices:
  58                 if net_slice.network in public_nets:
  59                         public_net_slice = net_slice
  60                 elif net_slice.network == private_net:
  61                         private_net_slice = net_slice
  62         if not public_net_slice:
  63                 public_net_slice = NetworkSlice(slice=slice, network=public_nets[0])
  64                 public_net_slice.save()
  65         if not private_net_slice:
  66                 private_net_slice = NetworkSlice(slice=slice, network=private_net)
  67                 private_net_slice.save()
  68
  69
  70
  71