cleanup imports. Add legacy fields back

diff --git a/PLC/Slices.py b/PLC/Slices.py
index e3a4c13..ae40d80 100644 (file)
--- a/PLC/Slices.py
+++ b/PLC/Slices.py
@@ -1,22 +1,19 @@
 from types import StringTypes
 import time
 import re
+import datetime
 
-from sqlalchemy import Column, Integer, String, DateTime
-from sqlalchemy import Table, Column, MetaData, join, ForeignKey
-from sqlalchemy.orm import relationship, backref
-from sqlalchemy.orm import column_property
-from sqlalchemy.orm import object_mapper
-from sqlalchemy.orm import validates
-
-from PLC.Storage.AlchemyObject import AlchemyObj
 from PLC.Faults import *
 from PLC.Parameter import Parameter, Mixed
 from PLC.Filter import Filter
 from PLC.Debug import profile
 from PLC.Nodes import Node
 from PLC.Persons import Person, Persons
+from PLC.SlicePersons import SlicePerson, SlicePersons
+from PLC.SliceNodes import SliceNode, SliceNodes
+from PLC.SliceTags import SliceTag, SliceTags
 from PLC.Timestamp import Timestamp
+from PLC.Storage.AlchemyObject import AlchemyObj
 
 class Slice(AlchemyObj):
     """
@@ -32,14 +29,18 @@ class Slice(AlchemyObj):
         'id': Parameter(int, "Slice identifier", primary_key=True),
         'site_id': Parameter(int, "Identifier of the site to which this slice belongs"),
         'name': Parameter(str, "Slice name", max = 32),
+        'instantiation': Parameter(str, "Slice instantiation state", nullok=True),
         'url': Parameter(str, "URL further describing this slice", max = 254, nullok = True),
         'description': Parameter(str, "Slice description", max = 2048, nullok = True),
         'max_nodes': Parameter(int, "Maximum number of nodes that can be assigned to this slice"),
-        'creator_person_id': Parameter(int, "Identifier of the account that created this slice"),
-        'created': Parameter(int, "Date and time when slice was created, in seconds since UNIX epoch", ro = True),
-        'expires': Parameter(int, "Date and time when slice expires, in seconds since UNIX epoch"),
-        'node_ids': Parameter([int], "List of nodes in this slice", ro = True),
-        'person_ids': Parameter([int], "List of accounts that can use this slice", ro = True),
+        'creator_person_id': Parameter(str, "Identifier of the account that created this slice"),
+        'created': Parameter(datetime, "Date and time when slice was created, in seconds since UNIX epoch", ro = True),
+        'expires': Parameter(datetime, "Date and time when slice expires, in seconds since UNIX epoch"),
+        'node_ids': Parameter([str], "List of nodes in this slice", ro = True),
+        'person_ids': Parameter([str], "List of accounts that can use this slice", ro = True),
+        'slice_tag_ids': Parameter([int], "List of slice attributes", ro = True),
+        'peer_id': Parameter(int, "Peer to which this slice belongs", nullok = True),
+        'peer_slice_id': Parameter(int, "Foreign slice identifier at peer", nullok = True),
         }
     tags = {}
 
@@ -86,26 +87,23 @@ class Slice(AlchemyObj):
         AlchemyObj.sync(self, commit, validate)
         if 'id' not in self:
             # Before a new slice is added, delete expired slices
-            expired = Slices(self.api, expires = -int(time.time()))
-            for slice in expired:
-                slice.delete(commit)
-            Slice().insert(dict(self))
+            #expired = Slices(self.api, expires = -int(time.time()))
+            #for slice in expired:
+            #    slice.delete(commit)
+            AlchemyObj.insert(self, dict(self))
+        else:
+            AlchemyObj.update(self, self['id'], dict(self)) 
 
     def delete(self, commit = True):
         """
         Delete existing slice.
         """
-
-        assert 'slice_id' in self
-
-        # Clean up miscellaneous join tables
-        for table in self.join_tables:
-            self.api.db.do("DELETE FROM %s WHERE slice_id = %d" % \
-                           (table, self['slice_id']))
-
-        # Mark as deleted
-        self['is_deleted'] = True
-        self.sync(commit)
+        assert 'id' in self
+        # delete relationships
+        SlicePerson().delete(self, filter={'slice_id': self['id']}) 
+        SliceNode().delete(self, filter={'slice_id': self['id']}) 
+        SliceTag().delete(self, filter={'slice_id': self['id']}) 
+        AlchemyObj.delete(self, dict(self))
 
 
 class Slices(list):
@@ -130,4 +128,17 @@ class Slices(list):
             raise PLCInvalidArgument, "Wrong slice filter %r"%slice_filter
 
         for slice in slices:
+            slice = Slice(api, object=slice)
+            if not columns or 'person_ids' in columns:
+                slice_persons = SlicePerson().select(filter={'slice_id': slice.id})
+                slice['person_ids'] = [rec.person_id for rec in slice_persons] 
+                
+            if not columns or 'node_ids' in columns:
+                slice_nodes = SliceNode().select(filter={'slice_id': slice.id})
+                slice['node_ids'] = [rec.node_id for rec in slice_nodes]
+
+            if not columns or 'slice_tag_ids' in columns:
+                slice_tags = SliceTag().select(filter={'slice_id': slice.id})
+                slice['slice_tag_ids'] = [rec.slice_tag_id for rec in slice_tags]
+                
             self.append(slice)