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