PLC/ForeignSlices.py

   1 #
   2 # Thierry Parmentelat - INRIA
   3 #
   4 import time
   5
   6 from types import StringTypes
   7
   8 from PLC.Table import Row, Table
   9 from PLC.Parameter import Parameter
  10 from PLC.Filter import Filter
  11
  12 class ForeignSlice (Row) :
  13     """
  14     This object stores information about slices hosted on
  15     other peering instances of myplc
  16     """
  17
  18     table_name = 'slices'
  19     primary_key = 'slice_id'
  20
  21     fields = {
  22         'slice_id': Parameter (int, "Slice Id"),
  23         'name' :    Parameter (str, "Slice name"),
  24         'peer_id': Parameter (str, "Peer id"),
  25         'instantiation': Parameter(str, "Slice instantiation state"),
  26         'url': Parameter(str, "URL further describing this slice", max = 254, nullok = True),
  27         'description': Parameter(str, "Slice description", max = 2048, nullok = True),
  28         'max_nodes': Parameter(int, "Maximum number of nodes that can be assigned to this slice"),
  29         'created': Parameter(int, "Date and time when slice was created, in seconds since UNIX epoch", ro = True),
  30         'expires': Parameter(int, "Date and time when slice expires, in seconds since UNIX epoch"),
  31         }
  32
  33     def __init__(self,api,fields={},uptodate=True):
  34         Row.__init__(self,api,fields)
  35         self.uptodate=uptodate
  36
  37     def validate_created(self,timestamp):
  38         return time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(timestamp))
  39
  40     def validate_expires(self,timestamp):
  41         return time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(timestamp))
  42
  43     def purge_peer_slice (self,commit=True):
  44         sql = "DELETE FROM peer_slice WHERE slice_id=%d"%self['slice_id']
  45         self.api.db.do(sql)
  46         if commit:
  47             self.api.db.commit()
  48
  49     def delete (self, commit=True):
  50         """
  51         Delete existing foreign slice.
  52         """
  53         self.purge_peer_slice()
  54         self['deleted']=True
  55         self.sync(commit)
  56
  57
  58 class ForeignSlices (Table):
  59     def __init__ (self, api, foreign_slice_filter = None, columns = None):
  60         Table.__init__(self, api, ForeignSlice, columns)
  61
  62         sql = ""
  63         sql += "SELECT %s FROM view_foreign_slices " % ", ".join(self.columns)
  64         sql += "WHERE deleted IS False "
  65
  66         if foreign_slice_filter is not None:
  67             if isinstance(foreign_slice_filter, (list, tuple, set)):
  68                 # Separate the list into integers and strings
  69                 ints = filter(lambda x: isinstance(x, (int, long)), foreign_slice_filter)
  70                 strs = filter(lambda x: isinstance(x, StringTypes), foreign_slice_filter)
  71                 foreign_slice_filter = Filter(ForeignSlice.fields, {'slice_id': ints, 'name': strs})
  72                 sql += " AND (%s)" % foreign_slice_filter.sql(api, "OR")
  73             elif isinstance(foreign_slice_filter, dict):
  74                 foreign_slice_filter = Filter(ForeignSlice.fields, foreign_slice_filter)
  75                 sql += " AND (%s)" % foreign_slice_filter.sql(api, "AND")
  76
  77         self.selectall(sql)
  78
  79     # managing an index by slicename
  80     def name_index(self):
  81         if 'name' not in self.columns:
  82             raise PLCFault,"ForeignSlices::name_index, name not selected"
  83         self.index={}
  84         for foreign_slice in self:
  85             self.index[foreign_slice['name']]=foreign_slice
  86
  87     def name_add_by(self,foreign_slice):
  88         self.index[foreign_slice['name']]=foreign_slice
  89
  90     def name_locate(self,name):
  91         return self.index[name]
  92