1 from core.models import User,Site,Service,SingletonModel,PlCoreBase,Slice,SlicePrivilege
3 from django.db import models
4 from django.db.models import Q
5 from django.forms.models import model_to_dict
6 from django.core.exceptions import ValidationError, ObjectDoesNotExist
8 # Create your models here.
10 class SyndicateService(SingletonModel,Service):
12 app_label = "syndicate_storage"
13 verbose_name = "Syndicate Service"
14 verbose_name_plural = "Syndicate Service"
16 def __unicode__(self): return u'Syndicate Service'
19 class SyndicatePrincipal(PlCoreBase):
21 app_label = "syndicate_storage"
23 # for now, this is a user email address
24 principal_id = models.TextField(unique=True)
25 public_key_pem = models.TextField()
26 sealed_private_key = models.TextField()
28 def __unicode__self(self): return "%s" % self.principal_id
31 class Volume(PlCoreBase):
33 app_label = "syndicate_storage"
35 name = models.CharField(max_length=64, help_text="Human-readable, searchable name of the Volume")
37 owner_id = models.ForeignKey(User, verbose_name='Owner')
39 description = models.TextField(null=True, blank=True,max_length=130, help_text="Human-readable description of what this Volume is used for.")
40 blocksize = models.PositiveIntegerField(help_text="Number of bytes per block.")
41 private = models.BooleanField(default=True, help_text="Indicates if the Volume is visible to users other than the Volume Owner and Syndicate Administrators.")
42 archive = models.BooleanField(default=False, help_text="Indicates if this Volume is read-only, and only an Aquisition Gateway owned by the Volume owner (or Syndicate admin) can write to it.")
44 cap_read_data = models.BooleanField(default=True, help_text="VM can read Volume data")
45 cap_write_data = models.BooleanField(default=True, help_text="VM can write Volume data")
46 cap_host_data = models.BooleanField(default=True, help_text="VM can host Volume data")
48 slice_id = models.ManyToManyField(Slice, through="VolumeSlice")
50 def __unicode__(self): return self.name
54 def select_by_user(user):
56 Only return Volumes accessible by the user.
57 Admin users can see everything.
60 qs = Volume.objects.all()
62 qs = Volume.objects.filter( Q(owner_id=user) | Q(private=False) )
67 class VolumeAccessRight(PlCoreBase):
69 app_label = "syndicate_storage"
71 owner_id = models.ForeignKey(User, verbose_name='user')
73 volume = models.ForeignKey(Volume)
75 cap_read_data = models.BooleanField(default=True, help_text="VM can read Volume data")
76 cap_write_data = models.BooleanField(default=True, help_text="VM can write Volume data")
77 cap_host_data = models.BooleanField(default=True, help_text="VM can host Volume data")
80 def __unicode__(self): return "%s-%s" % (self.owner_id.email, self.volume.name)
83 class ObserverSecretValue( models.TextField ):
85 app_label = "syndicate_storage"
87 __metaclass__ = models.SubfieldBase
89 MAGIC_PREFIX = "$SECRET$:"
92 def is_encrypted( cls, secret_str ):
93 # all encrypted secrets start with MAGIC_PREFIX, which is NOT base64-encoded
94 return secret_str.startswith( cls.MAGIC_PREFIX )
97 def unserialize( cls, serialized_ciphertext ):
98 # strip prefix and return ciphertext
99 return serialized_ciphertext[len(cls.MAGIC_PREFIX):]
102 def serialize( cls, ciphertext ):
103 # prepend a magic prefix so we know it's encrypted
104 return cls.MAGIC_PREFIX + ciphertext
106 def to_python( self, secret_str ):
108 Decrypt the value with the Observer key
111 # is this in the clear?
112 if not ObserverSecretValue.is_encrypted( secret_str ):
116 # otherwise, decrypt it
117 from syndicate_observer import syndicatelib
119 # get observer private key
120 config = syndicatelib.get_config()
123 observer_pkey_path = config.SYNDICATE_PRIVATE_KEY
124 observer_pkey_pem = syndicatelib.get_private_key_pem( observer_pkey_path )
126 raise syndicatelib.SyndicateObserverError( "Internal Syndicate Observer error: failed to load Observer private key" )
129 secret_str = ObserverSecretValue.unserialize( secret_str )
132 if secret_str is not None and len(secret_str) > 0:
134 slice_secret = syndicatelib.decrypt_slice_secret( observer_pkey_pem, secret_str )
136 if slice_secret is not None:
140 raise syndicatelib.SyndicateObserverError( "Internal Syndicate Observer error: failed to decrypt slice secret value" )
145 def pre_save( self, model_inst, add ):
147 Encrypt the value with the Observer key
150 from syndicate_observer import syndicatelib
152 # get observer private key
153 config = syndicatelib.get_config()
156 observer_pkey_path = config.SYNDICATE_PRIVATE_KEY
157 observer_pkey_pem = syndicatelib.get_private_key_pem( observer_pkey_path )
159 raise syndicatelib.SyndicateObserverError( "Internal Syndicate Observer error: failed to load Observer private key" )
161 slice_secret = getattr(model_inst, self.attname )
163 if slice_secret is not None:
166 sealed_slice_secret = syndicatelib.encrypt_slice_secret( observer_pkey_pem, slice_secret )
168 return ObserverSecretValue.serialize( sealed_slice_secret )
171 raise syndicatelib.SyndicateObserverError( "Internal Syndicate Observer error: No slice secret generated" )
174 class SliceSecret(models.Model): # NOTE: not a PlCoreBase
176 app_label = "syndicate_storage"
178 slice_id = models.ForeignKey(Slice)
179 secret = ObserverSecretValue(blank=True, help_text="Shared secret between OpenCloud and this slice's Syndicate daemons.")
181 def __unicode__(self): return self.slice_id.name
184 def select_by_user(user):
186 Only return slice secrets for slices where this user has 'admin' role.
187 Admin users can see everything.
190 qs = SliceSecret.objects.all()
192 visible_slice_ids = [sp.slice.id for sp in SlicePrivilege.objects.filter(user=user,role__role='admin')]
193 qs = SliceSecret.objects.filter(slice_id__id__in=visible_slice_ids)
198 class VolumeSlice(PlCoreBase):
200 app_label = "syndicate_storage"
202 volume_id = models.ForeignKey(Volume, verbose_name="Volume")
203 slice_id = models.ForeignKey(Slice, verbose_name="Slice")
205 cap_read_data = models.BooleanField(default=True, help_text="VM can read Volume data")
206 cap_write_data = models.BooleanField(default=True, help_text="VM can write Volume data")
207 cap_host_data = models.BooleanField(default=True, help_text="VM can host Volume data")
209 UG_portnum = models.PositiveIntegerField(help_text="User Gateway port. Any port above 1024 will work, but it must be available slice-wide.", verbose_name="UG port")
210 RG_portnum = models.PositiveIntegerField(help_text="Replica Gateway port. Any port above 1024 will work, but it must be available slice-wide.", verbose_name="RG port")
212 credentials_blob = models.TextField(null=True, blank=True, help_text="Encrypted slice credentials, sealed with the slice secret.")
214 def __unicode__(self): return "%s-%s" % (self.volume_id.name, self.slice_id.name)
218 Verify that our fields are in order:
219 * UG_portnum and RG_portnum have to be valid port numbers between 1025 and 65534
220 * UG_portnum and RG_portnum cannot be changed once set.
221 * UG_portnum and RG_portnum are unique
224 if self.UG_portnum == self.RG_portnum:
225 raise ValidationError( "UG and RG ports must be unique" )
227 if self.UG_portnum < 1025 or self.UG_portnum > 65534:
228 raise ValidationError( "UG port number must be between 1025 and 65534" )
230 if self.RG_portnum < 1025 or self.RG_portnum > 65534:
231 raise ValidationError( "RG port number must be between 1025 and 65534" )
234 def save(self, *args, **kw):
236 Make sure a SliceSecret exists for this slice
239 from syndicate_observer import syndicatelib
241 # get observer private key
242 config = syndicatelib.get_config()
245 observer_pkey_path = config.SYNDICATE_PRIVATE_KEY
246 observer_pkey_pem = syndicatelib.get_private_key_pem( observer_pkey_path )
248 raise syndicatelib.SyndicateObserverError( "Internal Syndicate Observer error: failed to load Observer private key" )
250 # get or create the slice secret
251 slice_secret = syndicatelib.get_or_create_slice_secret( observer_pkey_pem, None, slice_fk=self.slice_id )
253 if slice_secret is None:
254 raise SyndicateObserverError( "Failed to get or create slice secret for %s" % self.slice_id.name )
256 super(VolumeSlice, self).save(*args, **kw)