Synnefo

def encrypt_db_charfield(plaintext):

        return plaintext

    salt = "".join([choice(letters + digits) for i in xrange(SALT_LEN)])

def decrypt_db_charfield(ciphertext):

        return ciphertext

    has_prefix = ciphertext.startswith(DB_ENCRYPTED_FIELD_PREFIX + ':')

    if not has_prefix:  # Non-encoded value

        if num == 1:

            return query[0]

        if not num:

        raise self.model.MultipleObjectsReturned(

            "get() returned more than one %s -- it returned %s! "

            "Lookup parameters were %s" %

    ram = models.IntegerField('RAM size in MiB', default=0)

    disk = models.IntegerField('Disk size in GiB', default=0)

    disk_template = models.CharField('Disk template', max_length=32,

    deleted = models.BooleanField('Deleted', default=False)

    class Meta:

    username = models.CharField('Username', max_length=64, blank=True,

                                null=True)

    password_hash = models.CharField('Password', max_length=128, blank=True,

    # Sha1 is up to 40 characters long

    hash = models.CharField('Hash', max_length=40, editable=False, null=False)

    # Unique index of the Backend, used for the mac-prefixes of the

    def create_hash(self):

        """Create a hash for this backend. """

    @property

    def password(self):

        super(Backend, self).save(*args, **kwargs)

        if self.hash != old_hash:

            # Populate the new hash to the new instances

    def delete(self, *args, **kwargs):

        # Integrity Error if non-deleted VMs are associated with Backend

class QuotaHolderSerial(models.Model):

    pending = models.BooleanField(default=True, db_index=True)

    accepted = models.BooleanField(default=False)

    rejected = models.BooleanField(default=False)

class VirtualMachine(models.Model):

    # The list of possible actions for a VM

    ACTIONS = (

    )

    # The internal operating state of a VM

    suspended = models.BooleanField('Administratively Suspended',

                                    default=False)

    serial = models.ForeignKey(QuotaHolderSerial,

    # VM State

    # The following fields are volatile data, in the sense

    )

    ACTIONS = (

    )

    RSAPI_STATE_FROM_OPER_STATE = {

    FLAVORS = {

        'CUSTOM': {

        },

        'IP_LESS_ROUTED': {

        },

        'MAC_FILTERED': {

        },

        'PHYSICAL_VLAN': {

        },

    }

        backends = [backend] if backend\

                             else Backend.objects.filter(offline=False)

        for backend in backends:

                BackendNetwork.objects.create(backend=backend, network=self)

    def get_pool(self):

            self.status = status

        def __str__(self):

    class InvalidActionError(Exception):

        def __init__(self, action):

            try:

                utils.validate_mac(mac_prefix + ":00:00:00")

            except utils.InvalidMacAddress:

            self.mac_prefix = mac_prefix

    def since(self, vm, created_since, **kwargs):

        return self.get_query_set().filter(vm=vm, created__gt=created_since,

class VirtualMachineDiagnostic(models.Model):

    network = factory.SubFactory(NetworkFactory)

    index = factory.Sequence(lambda x: x, type=int)

    mac = factory.Sequence(lambda n:

                                         '{0}'.format(int(n) + 2))

    firewall_profile =\

        factory.Sequence(round_seq_first(FACTORY_FOR.FIREWALL_PROFILES))

from django.conf import settings

from copy import deepcopy

def id_from_instance_name(name):

    """Returns VirtualMachine's Django id, given a ganeti machine name.

      (vm.operstate) through the RSAPI_STATE_FROM_OPER_STATE dictionary.

      The last state reported by Ganeti is set whenever Ganeti reports

    """

    try:

            if resource == "cyclades.network.private":

                user_networks = Network.objects.filter(userid=userid,

                                                       deleted=False).count()

                if user_networks + size >= user_network_limit:

                    raise NoQuantityError()

        resources = invert_resources(resources)

    provisions = [('cyclades', 'cyclades.' + r, s)

                  for r, s in resources.items()]

##

## Reconcile pending commissions

                    continue

                reset_holding = []

                for res, val in resources.items():

                if not options['dry_run']:

                    try:

                    except Exception as e:

                        self.stderr.write("Can not set up holding:%s" % e)

                else:

        db_extra = db_res - qh_res

        if db_extra:

            for res in db_extra:

                      % (res, user))

        qh_extra = qh_res - db_res

        if qh_extra:

            for res in qh_extra:

                      % (res, user))

        return False

        accepted, rejected = quotas.resolve_pending_commissions()

        if accepted:

                              % list_to_string(accepted))

        if rejected:

                              % list_to_string(rejected))

        if fix and (accepted or rejected):

    # Get resources related with networks

    net_resources = networks.values("userid")\

    for net_res in net_resources:

        user = net_res['userid']

        if user not in holdings:

def decode_holding(holding):

    res = resource.replace("cyclades.", "")

    return (res, imported - exported + returned - released)

from synnefo.vmapi.settings import CACHE_KEY_PREFIX, CACHE_BACKEND

def get_uuid():

    return str(uuid4())

def get_key(*args):

    args = map(str, filter(bool, list(args)))

    args.insert(0, CACHE_KEY_PREFIX)

# here.

if hasattr(backend, 'close'):

    signals.request_finished.connect(backend.close)

log = getLogger('synnefo.vmapi')

def create_server_params(sender, created_vm_params, **kwargs):

    json_value = json.dumps(created_vm_params)

    uuid = get_uuid()

    return uuid

server_created.connect(create_server_params)

from django.conf import settings

CACHE_BACKEND = getattr(settings, 'VMAPI_CACHE_BACKEND',

CACHE_KEY_PREFIX = getattr(settings, 'VMAPI_CACHE_KEY_PREFIX',

RESET_PARAMS = getattr(settings, 'VMAPI_RESET_PARAMS', True)

BASE_URL = getattr(settings, 'VMAPI_BASE_URL',

from synnefo.vmapi import settings

class TestServerParams(TestCase):

    def test_cache_backend(self):

        from synnefo.vmapi.models import create_server_params

        from synnefo.vmapi import backend

        try:

            from synnefo.db.models import VirtualMachine

        except ImportError:

            print "Skipping test_params_create"

        params = {'password': 'X^942Jjfdsa', 'personality': {}}

        uuid = create_server_params(sender=vm, created_vm_params=params)

        key = "vmapi_%s" % uuid

        self.assertEqual(type(backend.get(key)), str)

        data = json.loads(backend.get(key))

        self.assertEqual(response.status_code, 200)

        response = self.client.get('/vmapi/server-params/%s' % uuid)

        self.assertEqual(response.status_code, 404)

# interpreted as representing official policies, either expressed

# or implied, of GRNET S.A.

urlpatterns = patterns('synnefo.vmapi.views',

log = getLogger('synnefo.vmapi')

def server_params(request, uuid):

    if not uuid:

        raise Http404

        backend.set(cache_key, None)

    return HttpResponse(params, content_type="application/json")