planetstack/core/xoslib/objects/sliceplus.py

   1 from core.models import Slice, SlicePrivilege, SliceRole, Sliver, Site, Node, User
   2 from plus import PlusObjectMixin
   3 from operator import itemgetter, attrgetter
   4 from rest_framework.exceptions import APIException
   5
   6 class SlicePlus(Slice, PlusObjectMixin):
   7     class Meta:
   8         proxy = True
   9
  10     def __init__(self, *args, **kwargs):
  11         super(SlicePlus, self).__init__(*args, **kwargs)
  12         self._update_users = None
  13         self._sliceInfo = None
  14         self.getSliceInfo()
  15         self._site_allocation = self._sliceInfo["sitesUsed"]
  16         self._initial_site_allocation = self._site_allocation
  17         self._network_ports = self._sliceInfo["networkPorts"]
  18         self._initial_network_ports = self._network_ports
  19
  20     def getSliceInfo(self, user=None):
  21         if not self._sliceInfo:
  22             used_sites = {}
  23             ready_sites = {}
  24             used_deployments = {}
  25             sliverCount = 0
  26             sshCommands = []
  27             for sliver in self.slivers.all():
  28                 site = sliver.node.site_deployment.site
  29                 deployment = sliver.node.site_deployment.deployment
  30                 used_sites[site.name] = used_sites.get(site.name, 0) + 1
  31                 used_deployments[deployment.name] = used_deployments.get(deployment.name, 0) + 1
  32                 sliverCount = sliverCount + 1
  33
  34                 sshCommand = sliver.get_ssh_command()
  35                 if sshCommand:
  36                     sshCommands.append(sshCommand)
  37
  38                     ready_sites[site.name] = ready_sites.get(site.name, 0) + 1
  39
  40             users = {}
  41             for priv in SlicePrivilege.objects.filter(slice=self):
  42                 if not (priv.user.id in users.keys()):
  43                     users[priv.user.id] = {"name": priv.user.email, "id": priv.user.id, "roles": []}
  44                 users[priv.user.id]["roles"].append(priv.role.role)
  45
  46             # XXX this assumes there is only one network that can have ports bound
  47             # to it for a given slice. This is intended for the tenant view, which
  48             # will obey this field.
  49             networkPorts = ""
  50             for networkSlice in self.networkslices.all():
  51                 network = networkSlice.network
  52                 if (network.owner.id != self.id):
  53                     continue
  54                 if network.ports:
  55                     networkPorts = network.ports
  56
  57             self._sliceInfo= {"sitesUsed": used_sites,
  58                     "sitesReady": ready_sites,
  59                     "deploymentsUsed": used_deployments,
  60                     "sliverCount": sliverCount,
  61                     "siteCount": len(used_sites.keys()),
  62                     "users": users,
  63                     "roles": [],
  64                     "sshCommands": sshCommands,
  65                     "networkPorts": networkPorts}
  66
  67         if user:
  68             auser = self._sliceInfo["users"].get(user.id, None)
  69             if (auser):
  70                 self._sliceInfo["roles"] = auser["roles"]
  71
  72         return self._sliceInfo
  73
  74     @property
  75     def site_ready(self):
  76         return self.getSliceInfo()["sitesReady"]
  77
  78     @site_ready.setter
  79     def site_ready(self, value):
  80         pass
  81
  82     @property
  83     def site_allocation(self):
  84         return self._site_allocation
  85
  86     @site_allocation.setter
  87     def site_allocation(self, value):
  88         self._site_allocation = value
  89
  90     @property
  91     def user_names(self):
  92         return [user["name"] for user in self.getSliceInfo()["users"].values()]
  93
  94     @user_names.setter
  95     def user_names(self, value):
  96         pass # it's read-only
  97
  98     @property
  99     def users(self):
 100         return [user["id"] for user in self.getSliceInfo()["users"].values()]
 101
 102     @users.setter
 103     def users(self, value):
 104         self._update_users = value
 105         #print "XXX set users to", value
 106
 107     @property
 108     def network_ports(self):
 109         return self._network_ports
 110
 111     @network_ports.setter
 112     def network_ports(self, value):
 113         self._network_ports = value
 114         #print "XXX set networkPorts to", value
 115
 116     @staticmethod
 117     def select_by_user(user):
 118         if user.is_admin:
 119             qs = SlicePlus.objects.all()
 120         else:
 121             slice_ids = [sp.slice.id for sp in SlicePrivilege.objects.filter(user=user)]
 122             qs = SlicePlus.objects.filter(id__in=slice_ids)
 123         return qs
 124
 125     def get_node_allocation(self, siteList):
 126         siteIDList = [site.id for site in siteList]
 127         nodeList = []
 128         for node in Node.objects.all():
 129             if (node.site_deployment.site.id in siteIDList):
 130                 node.sliverCount = 0
 131                 for sliver in node.slivers.all():
 132                      if sliver.slice.id == self.id:
 133                          node.sliverCount = node.sliverCount + 1
 134                 nodeList.append(node)
 135         return nodeList
 136
 137     def save(self, *args, **kwargs):
 138         updated_image = self.has_field_changed("default_image")
 139         updated_flavor = self.has_field_changed("default_flavor")
 140
 141         super(SlicePlus, self).save(*args, **kwargs)
 142
 143         # try things out first
 144
 145         updated_sites = (self._site_allocation != self._initial_site_allocation) or updated_image or updated_flavor
 146         if updated_sites:
 147             self.save_site_allocation(noAct=True, reset=(updated_image or updated_flavor))
 148
 149         if self._update_users:
 150             self.save_users(noAct=True)
 151
 152         if (self._network_ports != self._initial_network_ports):
 153             self.save_network_ports(noAct=True)
 154
 155         # now actually save them
 156
 157         if updated_sites:
 158             self.save_site_allocation(reset=(updated_image or updated_flavor))
 159
 160         if self._update_users:
 161             self.save_users()
 162
 163         if (self._network_ports != self._initial_network_ports):
 164             self.save_network_ports()
 165
 166     def save_site_allocation(self, noAct = False, reset=False):
 167         print "save_site_allocation, reset=",reset
 168
 169         if (not self._site_allocation):
 170             # Must be a sliver that was just created, and has not site_allocation
 171             # field.
 172             return
 173
 174         all_slice_slivers = self.slivers.all()
 175         for site_name in self._site_allocation.keys():
 176             desired_allocation = self._site_allocation[site_name]
 177
 178             # make a list of the slivers for this site
 179             slivers = []
 180             for sliver in all_slice_slivers:
 181                 if sliver.node.site_deployment.site.name == site_name:
 182                     slivers.append(sliver)
 183
 184             # delete extra slivers
 185             while (reset and len(slivers)>0) or (len(slivers) > desired_allocation):
 186                 sliver = slivers.pop()
 187                 if (not noAct):
 188                     print "deleting sliver", sliver
 189                     sliver.delete()
 190                 else:
 191                     print "would delete sliver", sliver
 192
 193             # add more slivers
 194             if (len(slivers) < desired_allocation):
 195                 site = Site.objects.get(name = site_name)
 196                 nodes = self.get_node_allocation([site])
 197
 198                 if (not nodes):
 199                     raise APIException(detail="no nodes in site %s" % site_name)
 200
 201                 while (len(slivers) < desired_allocation):
 202                     # pick the least allocated node
 203                     nodes = sorted(nodes, key=attrgetter("sliverCount"))
 204                     node = nodes[0]
 205
 206                     sliver = Sliver(name=node.name,
 207                             slice=self,
 208                             node=node,
 209                             image = self.default_image,
 210                             flavor = self.default_flavor,
 211                             creator = self.creator,
 212                             deployment = node.site_deployment.deployment)
 213                     slivers.append(sliver)
 214                     if (not noAct):
 215                         print "added sliver", sliver
 216                         sliver.save()
 217                     else:
 218                         print "would add sliver", sliver
 219
 220                     node.sliverCount = node.sliverCount + 1
 221
 222     def save_users(self, noAct = False):
 223         new_users = self._update_users
 224
 225         default_role = SliceRole.objects.get(role="default")
 226
 227         slice_privs = self.sliceprivileges.all()
 228         slice_user_ids = [priv.user.id for priv in slice_privs]
 229
 230         for user_id in new_users:
 231             if (user_id not in slice_user_ids):
 232                 priv = SlicePrivilege(slice=self, user=User.objects.get(id=user_id), role=default_role)
 233                 if (not noAct):
 234                     priv.save()
 235
 236                 print "added user id", user_id
 237
 238         for priv in slice_privs:
 239              if (priv.role.id != default_role.id):
 240                  # only mess with 'default' users; don't kill an admin
 241                  continue
 242
 243              if (priv.user.id not in new_users):
 244                  if (not noAct):
 245                      priv.delete()
 246
 247                  print "deleted user id", user_id
 248
 249     def save_network_ports(self, noAct=False):
 250         # First search for any network that already has a filled in 'ports'
 251         # field. We'll assume there can only be one, so it must be the right
 252         # one.
 253         for networkSlice in self.networkslices.all():
 254             network = networkSlice.network
 255             if (network.owner.id != self.id):
 256                 continue
 257             if network.ports:
 258                 network.ports = self._network_ports
 259                 if (not noAct):
 260                     network.save()
 261                 return
 262
 263         # Now try a network that is a "NAT", since setting ports on a non-NAT
 264         # network doesn't make much sense.
 265         for networkSlice in self.networkslices.all():
 266             network = networkSlice.network
 267             if (network.owner.id != self.id):
 268                 continue
 269             if network.template.translation=="NAT":
 270                 network.ports = self._network_ports
 271                 if (not noAct):
 272                     network.save()
 273                 return
 274
 275         # uh oh, we didn't find a network
 276
 277         raise APIException(detail="No network was found that ports could be set on")
 278
 279
 280
 281
 282