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
   5 class SlicePlus(Slice, PlusObjectMixin):
   6     class Meta:
   7         proxy = True
   8
   9     def __init__(self, *args, **kwargs):
  10         super(SlicePlus, self).__init__(*args, **kwargs)
  11         self._update_site_allocation = None
  12         self._update_users = None
  13         self._sliceInfo = None
  14
  15     def getSliceInfo(self, user=None):
  16         if not self._sliceInfo:
  17             used_sites = {}
  18             used_deployments = {}
  19             sliverCount = 0
  20             for sliver in self.slivers.all():
  21                 site = sliver.node.site_deployment.site
  22                 deployment = sliver.node.site_deployment.deployment
  23                 used_sites[site.name] = used_sites.get(site.name, 0) + 1
  24                 used_deployments[deployment.name] = used_deployments.get(deployment.name, 0) + 1
  25                 sliverCount = sliverCount + 1
  26
  27             users = {}
  28             for priv in SlicePrivilege.objects.filter(slice=self):
  29                 if not (priv.user.id in users.keys()):
  30                     users[priv.user.id] = {"name": priv.user.email, "id": priv.user.id, "roles": []}
  31                 users[priv.user.id]["roles"].append(priv.role.role)
  32
  33             self._sliceInfo= {"sitesUsed": used_sites,
  34                     "deploymentsUsed": used_deployments,
  35                     "sliverCount": sliverCount,
  36                     "siteCount": len(used_sites.keys()),
  37                     "users": users,
  38                     "roles": []}
  39
  40         if user:
  41             auser = self._sliceInfo["users"].get(user.id, None)
  42             if (auser):
  43                 self._sliceInfo["roles"] = auser["roles"]
  44
  45         return self._sliceInfo
  46
  47     @property
  48     def site_allocation(self):
  49         return self.getSliceInfo()["sitesUsed"]
  50
  51     @site_allocation.setter
  52     def site_allocation(self, value):
  53         self._update_site_allocation = value
  54         #print "XXX set sitesUsed to", value
  55
  56     @property
  57     def user_names(self):
  58         return [user["name"] for user in self.getSliceInfo()["users"].values()]
  59
  60     @user_names.setter
  61     def user_names(self, value):
  62         pass # it's read-only
  63
  64     @property
  65     def users(self):
  66         return [user["id"] for user in self.getSliceInfo()["users"].values()]
  67
  68     @users.setter
  69     def users(self, value):
  70         self._update_users = value
  71         #print "XXX set users to", value
  72
  73     @property
  74     def network_ports(self):
  75         # XXX this assumes there is only one network that can have ports bound
  76         # to it for a given slice. This is intended for the tenant view, which
  77         # will obey this field.
  78         networkPorts = ""
  79         for networkSlice in self.networkslices.all():
  80             network = networkSlice.network
  81             if network.ports:
  82                 networkPorts = network.ports
  83
  84         return networkPorts
  85
  86     @network_ports.setter
  87     def network_ports(self, value):
  88         print "XXX set networkPorts to", value
  89
  90     @staticmethod
  91     def select_by_user(user):
  92         if user.is_admin:
  93             qs = SlicePlus.objects.all()
  94         else:
  95             slice_ids = [sp.slice.id for sp in SlicePrivilege.objects.filter(user=user)]
  96             qs = SlicePlus.objects.filter(id__in=slice_ids)
  97         return qs
  98
  99     def get_node_allocation(self, siteList):
 100         siteIDList = [site.id for site in siteList]
 101         nodeList = []
 102         for node in Node.objects.all():
 103             if (node.site_deployment.site.id in siteIDList):
 104                 node.sliverCount = 0
 105                 for sliver in node.slivers.all():
 106                      if sliver.slice.id == self.id:
 107                          node.sliverCount = node.sliverCount + 1
 108                 nodeList.append(node)
 109         return nodeList
 110
 111     def save(self, *args, **kwargs):
 112         super(SlicePlus, self).save(*args, **kwargs)
 113
 114         if self._update_site_allocation:
 115             self.save_site_allocation(noAct=True)
 116
 117         if self._update_users:
 118             self.save_users(noAct=True)
 119
 120         if self._update_site_allocation:
 121             self.save_site_allocation()
 122
 123         if self._update_users:
 124             self.save_users()
 125
 126     def save_site_allocation(self, noAct = False):
 127         new_site_allocation = self._update_site_allocation
 128
 129         all_slice_slivers = self.slivers.all()
 130         for site_name in new_site_allocation.keys():
 131             desired_allocation = new_site_allocation[site_name]
 132
 133             # make a list of the slivers for this site
 134             slivers = []
 135             for sliver in all_slice_slivers:
 136                 if sliver.node.site_deployment.site.name == site_name:
 137                     slivers.append(sliver)
 138
 139             # delete extra slivers
 140             while (len(slivers) > desired_allocation):
 141                 sliver = slivers.pop()
 142                 print "deleting sliver", sliver
 143                 if (not noAct):
 144                     sliver.delete()
 145
 146             # add more slivers
 147             if (len(slivers) < desired_allocation):
 148                 site = Site.objects.get(name = site_name)
 149                 nodes = self.get_node_allocation([site])
 150
 151                 if (not nodes):
 152                     raise ValueError("no nodes in site %s" % site_name)
 153
 154                 while (len(slivers) < desired_allocation):
 155                     # pick the least allocated node
 156                     nodes = sorted(nodes, key=attrgetter("sliverCount"))
 157                     node = nodes[0]
 158
 159                     sliver = Sliver(name=node.name,
 160                             slice=self,
 161                             node=node,
 162                             image = self.default_image,
 163                             flavor = self.default_flavor,
 164                             creator = self.creator,
 165                             deployment = node.site_deployment.deployment)
 166                     slivers.append(sliver)
 167                     if (not noAct):
 168                         sliver.save()
 169
 170                     print "added sliver", sliver
 171
 172                     node.sliverCount = node.sliverCount + 1
 173
 174     def save_users(self, noAct = False):
 175         new_users = self._update_users
 176
 177         default_role = SliceRole.objects.get(role="default")
 178
 179         slice_privs = self.sliceprivileges.all()
 180         slice_user_ids = [priv.user.id for priv in slice_privs]
 181
 182         for user_id in new_users:
 183             if (user_id not in slice_user_ids):
 184                 priv = SlicePrivilege(slice=self, user=User.objects.get(id=user_id), role=default_role)
 185                 if (not noAct):
 186                     priv.save()
 187
 188                 print "added user id", user_id
 189
 190         for priv in slice_privs:
 191              if (priv.role.id != default_role.id):
 192                  # only mess with 'default' users; don't kill an admin
 193                  continue
 194
 195              if (priv.user.id not in new_users):
 196                  if (not noAct):
 197                      priv.delete()
 198
 199                  print "deleted user id", user_id
 200
 201
 202
 203
 204