Merge branch 'master' into connect-via-client

Conflicts:
	circle/dashboard/templates/dashboard/vm-detail.html
	circle/dashboard/views.py

circle/circle/settings/base.py

@@ -368,9 +368,9 @@ if get_env_variable('DJANGO_SAML', 'FALSE') == 'TRUE':
         from shutilwhich import which
     from saml2 import BINDING_HTTP_POST, BINDING_HTTP_REDIRECT
 
-    # INSTALLED_APPS += (  # needed only for testing djangosaml2
-    #     'djangosaml',
-    # )
+    INSTALLED_APPS += (
+        'djangosaml2',
+    )
     AUTHENTICATION_BACKENDS = (
         'django.contrib.auth.backends.ModelBackend',
         'djangosaml2.backends.Saml2Backend',
@@ -467,4 +467,4 @@ SESSION_COOKIE_NAME = "csessid%x" % (((getnode() // 139) ^
 MAX_NODE_RAM = get_env_variable("MAX_NODE_RAM", 1024)
 
 # Url to download the client: (e.g. http://circlecloud.org/client/download/)
-CLIENT_DOWNLOAD_URL = get_env_variable('CLIENT_DOWNLOAD_URL', 'http://circlecloud.org/client/download/')
\ No newline at end of file
+CLIENT_DOWNLOAD_URL = get_env_variable('CLIENT_DOWNLOAD_URL', 'http://circlecloud.org/client/download/')

circle/circle/settings/production.py

@@ -20,9 +20,12 @@
 
 
 from os import environ
+from sys import argv
 
 from base import *  # noqa
 
+if 'runserver' in argv:
+    SECURE_PROXY_SSL_HEADER = ('HTTP_X_FORWARDED_PROTOCOL', 'https')
 
 ########## HOST CONFIGURATION
 # See: https://docs.djangoproject.com/en/1.5/releases/1.5/

circle/common/models.py

@@ -17,6 +17,7 @@
 
 from collections import deque
 from contextlib import contextmanager
+from functools import update_wrapper
 from hashlib import sha224
 from itertools import chain, imap
 from logging import getLogger
@@ -26,6 +27,7 @@ from warnings import warn
 from django.contrib import messages
 from django.contrib.auth.models import User
 from django.core.cache import cache
+from django.core.exceptions import PermissionDenied
 from django.core.serializers.json import DjangoJSONEncoder
 from django.db.models import (
     CharField, DateTimeField, ForeignKey, NullBooleanField
@@ -36,6 +38,7 @@ from django.utils.functional import Promise
 from django.utils.translation import ugettext_lazy as _, ugettext_noop
 from jsonfield import JSONField
 
+from manager.mancelery import celery
 from model_utils.models import TimeStampedModel
 
 logger = getLogger(__name__)
@@ -212,6 +215,38 @@ class ActivityModel(TimeStampedModel):
         self.result_data = None if value is None else value.to_dict()
 
 
+@celery.task()
+def compute_cached(method, instance, memcached_seconds,
+                   key, start, *args, **kwargs):
+    """Compute and store actual value of cached method."""
+    if isinstance(method, basestring):
+        model, id = instance
+        instance = model.objects.get(id=id)
+        try:
+            method = getattr(model, method)
+            while hasattr(method, '_original') or hasattr(method, 'fget'):
+                try:
+                    method = method._original
+                except AttributeError:
+                    method = method.fget
+        except AttributeError:
+            logger.exception("Couldnt get original method of %s",
+                             unicode(method))
+            raise
+
+    #  call the actual method
+    result = method(instance, *args, **kwargs)
+    # save to memcache
+    cache.set(key, result, memcached_seconds)
+    elapsed = time() - start
+    cache.set("%s.cached" % key, 2, max(memcached_seconds * 0.5,
+                                        memcached_seconds * 0.75 - elapsed))
+    logger.debug('Value of <%s>.%s(%s)=<%s> saved to cache (%s elapsed).',
+                 unicode(instance), method.__name__, unicode(args),
+                 unicode(result), elapsed)
+    return result
+
+
 def method_cache(memcached_seconds=60, instance_seconds=5):  # noqa
     """Cache return value of decorated method to memcached and memory.
 
@@ -233,9 +268,11 @@ def method_cache(memcached_seconds=60, instance_seconds=5):  # noqa
 
     def inner_cache(method):
 
+        method_name = method.__name__
+
         def get_key(instance, *args, **kwargs):
             return sha224(unicode(method.__module__) +
-                          unicode(method.__name__) +
+                          method_name +
                           unicode(instance.id) +
                           unicode(args) +
                           unicode(kwargs)).hexdigest()
@@ -254,21 +291,31 @@ def method_cache(memcached_seconds=60, instance_seconds=5):  # noqa
                 if vals['time'] + instance_seconds > now:
                     # has valid on class cache, return that
                     result = vals['value']
+                    setattr(instance, key, {'time': now, 'value': result})
 
             if result is None:
                 result = cache.get(key)
 
             if invalidate or (result is None):
-                # all caches failed, call the actual method
-                result = method(instance, *args, **kwargs)
-                # save to memcache and class attr
-                cache.set(key, result, memcached_seconds)
+                logger.debug("all caches failed, compute now")
+                result = compute_cached(method, instance, memcached_seconds,
+                                        key, time(), *args, **kwargs)
                 setattr(instance, key, {'time': now, 'value': result})
-                logger.debug('Value of <%s>.%s(%s)=<%s> saved to cache.',
-                             unicode(instance), method.__name__,
-                             unicode(args), unicode(result))
+            elif not cache.get("%s.cached" % key):
+                logger.debug("caches expiring, compute async")
+                cache.set("%s.cached" % key, 1, memcached_seconds * 0.5)
+                try:
+                    compute_cached.apply_async(
+                        queue='localhost.man', kwargs=kwargs, args=[
+                            method_name, (instance.__class__, instance.id),
+                            memcached_seconds, key, time()] + list(args))
+                except:
+                    logger.exception("Couldnt compute async %s", method_name)
 
             return result
+
+        update_wrapper(x, method)
+        x._original = method
         return x
 
     return inner_cache
@@ -367,6 +414,10 @@ class HumanReadableObject(object):
         self._set_values(user_text_template, admin_text_template, params)
 
     def _set_values(self, user_text_template, admin_text_template, params):
+        if isinstance(user_text_template, Promise):
+            user_text_template = user_text_template._proxy____args[0]
+        if isinstance(admin_text_template, Promise):
+            admin_text_template = admin_text_template._proxy____args[0]
         self.user_text_template = user_text_template
         self.admin_text_template = admin_text_template
         self.params = params
@@ -405,6 +456,12 @@ class HumanReadableObject(object):
                              self.user_text_template, unicode(self.params))
             return self.user_text_template
 
+    def get_text(self, user):
+        if user and user.is_superuser:
+            return self.get_admin_text()
+        else:
+            return self.get_user_text()
+
     def to_dict(self):
         return {"user_text_template": self.user_text_template,
                 "admin_text_template": self.admin_text_template,
@@ -435,13 +492,34 @@ class HumanReadableException(HumanReadableObject, Exception):
             self.level = "error"
 
     def send_message(self, request, level=None):
-        if request.user and request.user.is_superuser:
-            msg = self.get_admin_text()
-        else:
-            msg = self.get_user_text()
+        msg = self.get_text(request.user)
         getattr(messages, level or self.level)(request, msg)
 
 
+def fetch_human_exception(exception, user=None):
+    """Fetch user readable message from exception.
+
+    >>> r = humanize_exception("foo", Exception())
+    >>> fetch_human_exception(r, User())
+    u'foo'
+    >>> fetch_human_exception(r).get_text(User())
+    u'foo'
+    >>> fetch_human_exception(Exception(), User())
+    u'Unknown error'
+    >>> fetch_human_exception(PermissionDenied(), User())
+    u'Permission Denied'
+    """
+
+    if not isinstance(exception, HumanReadableException):
+        if isinstance(exception, PermissionDenied):
+            exception = create_readable(ugettext_noop("Permission Denied"))
+        else:
+            exception = create_readable(ugettext_noop("Unknown error"),
+                                        ugettext_noop("Unknown error: %(ex)s"),
+                                        ex=unicode(exception))
+    return exception.get_text(user) if user else exception
+
+
 def humanize_exception(message, exception=None, level=None, **params):
     """Return new dynamic-class exception which is based on
     HumanReadableException and the original class with the dict of exception.

circle/common/operations.py

@@ -18,10 +18,10 @@
 from inspect import getargspec
 from logging import getLogger
 
-from .models import activity_context, has_suffix
-
 from django.core.exceptions import PermissionDenied, ImproperlyConfigured
+from django.utils.translation import ugettext_noop
 
+from .models import activity_context, has_suffix, humanize_exception
 
 logger = getLogger(__name__)
 
@@ -31,6 +31,7 @@ class Operation(object):
     """
     async_queue = 'localhost.man'
     required_perms = None
+    superuser_required = False
     do_not_call_in_templates = True
     abortable = False
     has_percentage = False
@@ -143,13 +144,26 @@ class Operation(object):
     def check_precond(self):
         pass
 
-    def check_auth(self, user):
-        if self.required_perms is None:
+    @classmethod
+    def check_perms(cls, user):
+        """Check if user is permitted to run this operation on any instance
+        """
+
+        if cls.required_perms is None:
             raise ImproperlyConfigured(
                 "Set required_perms to () if none needed.")
-        if not user.has_perms(self.required_perms):
+        if not user.has_perms(cls.required_perms):
             raise PermissionDenied("%s doesn't have the required permissions."
                                    % user)
+        if cls.superuser_required and not user.is_superuser:
+            raise humanize_exception(ugettext_noop(
+                "Superuser privileges are required."), PermissionDenied())
+
+    def check_auth(self, user):
+        """Check if user is permitted to run this operation on this instance
+        """
+
+        self.check_perms(user)
 
     def create_activity(self, parent, user, kwargs):
         raise NotImplementedError
@@ -185,14 +199,17 @@ class OperatedMixin(object):
     def __getattr__(self, name):
         # NOTE: __getattr__ is only called if the attribute doesn't already
         # exist in your __dict__
-        cls = self.__class__
+        return self.get_operation_class(name)(self)
+
+    @classmethod
+    def get_operation_class(cls, name):
         ops = getattr(cls, operation_registry_name, {})
         op = ops.get(name)
         if op:
-            return op(self)
+            return op
         else:
             raise AttributeError("%r object has no attribute %r" %
-                                 (self.__class__.__name__, name))
+                                 (cls.__name__, name))
 
     def get_available_operations(self, user):
         """Yield Operations that match permissions of user and preconditions.

circle/dashboard/admin.py

@@ -21,18 +21,22 @@ from django import contrib
 from django.contrib.auth.admin import UserAdmin, GroupAdmin
 from django.contrib.auth.models import User, Group
 
-from dashboard.models import Profile, GroupProfile
+from dashboard.models import Profile, GroupProfile, ConnectCommand
 
 
 class ProfileInline(contrib.admin.TabularInline):
     model = Profile
 
 
+class CommandInline(contrib.admin.TabularInline):
+    model = ConnectCommand
+
+
 class GroupProfileInline(contrib.admin.TabularInline):
     model = GroupProfile
 
 
-UserAdmin.inlines = (ProfileInline, )
+UserAdmin.inlines = (ProfileInline, CommandInline, )
 GroupAdmin.inlines = (GroupProfileInline, )
 
 contrib.admin.site.unregister(User)

circle/dashboard/forms.py

@@ -39,7 +39,7 @@ from django.contrib.auth.forms import UserCreationForm as OrgUserCreationForm
 from django.forms.widgets import TextInput, HiddenInput
 from django.template import Context
 from django.template.loader import render_to_string
-from django.utils.translation import ugettext as _
+from django.utils.translation import ugettext_lazy as _
 from sizefield.widgets import FileSizeWidget
 from django.core.urlresolvers import reverse_lazy
 
@@ -54,7 +54,9 @@ from .models import Profile, GroupProfile
 from circle.settings.base import LANGUAGES, MAX_NODE_RAM
 from django.utils.translation import string_concat
 
-from .virtvalidator import domain_validator
+from .validators import domain_validator
+
+from dashboard.models import ConnectCommand
 
 LANGUAGES_WITH_CODE = ((l[0], string_concat(l[1], " (", l[0], ")"))
                        for l in LANGUAGES)
@@ -176,7 +178,14 @@ class GroupCreateForm(forms.ModelForm):
         self.fields['org_id'] = forms.ChoiceField(
             # TRANSLATORS: directory like in LDAP
             choices=choices, required=False, label=_('Directory identifier'))
-        if not new_groups:
+        if new_groups:
+            self.fields['org_id'].help_text = _(
+                "If you select an item here, the members of this directory "
+                "group will be automatically added to the group at the time "
+                "they log in. Please note that other users (those with "
+                "permissions like yours) may also automatically become a "
+                "group co-owner).")
+        else:
             self.fields['org_id'].widget = HiddenInput()
 
     def save(self, commit=True):
@@ -634,12 +643,8 @@ class LeaseForm(forms.ModelForm):
             Field('name'),
             Field("suspend_interval_seconds", type="hidden", value="0"),
             Field("delete_interval_seconds", type="hidden", value="0"),
+            HTML(string_concat("<label>", _("Suspend in"), "</label>")),
             Div(
-                Div(
-                    HTML(_("Suspend in")),
-                    css_class="input-group-addon",
-                    style="width: 100px;",
-                ),
                 NumberField("suspend_hours", css_class="form-control"),
                 Div(
                     HTML(_("hours")),
@@ -662,12 +667,8 @@ class LeaseForm(forms.ModelForm):
                 ),
                 css_class="input-group interval-input",
             ),
+            HTML(string_concat("<label>", _("Delete in"), "</label>")),
             Div(
-                Div(
-                    HTML(_("Delete in")),
-                    css_class="input-group-addon",
-                    style="width: 100px;",
-                ),
                 NumberField("delete_hours", css_class="form-control"),
                 Div(
                     HTML(_("hours")),
@@ -691,7 +692,7 @@ class LeaseForm(forms.ModelForm):
                 css_class="input-group interval-input",
             )
         )
-        helper.add_input(Submit("submit", "Save changes"))
+        helper.add_input(Submit("submit", _("Save changes")))
         return helper
 
     class Meta:
@@ -703,6 +704,8 @@ class VmRenewForm(forms.Form):
     force = forms.BooleanField(required=False, label=_(
         "Set expiration times even if they are shorter than "
         "the current value."))
+    save = forms.BooleanField(required=False, label=_(
+        "Save selected lease."))
 
     def __init__(self, *args, **kwargs):
         choices = kwargs.pop('choices')
@@ -714,6 +717,32 @@ class VmRenewForm(forms.Form):
             empty_label=None, label=_('Length')))
         if len(choices) < 2:
             self.fields['lease'].widget = HiddenInput()
+            self.fields['save'].widget = HiddenInput()
+
+    @property
+    def helper(self):
+        helper = FormHelper(self)
+        helper.form_tag = False
+        return helper
+
+
+class VmStateChangeForm(forms.Form):
+
+    interrupt = forms.BooleanField(required=False, label=_(
+        "Forcibly interrupt all running activities."),
+        help_text=_("Set all activities to finished state, "
+                    "but don't interrupt any tasks."))
+    new_state = forms.ChoiceField(Instance.STATUS, label=_(
+        "New status"))
+
+    def __init__(self, *args, **kwargs):
+        show_interrupt = kwargs.pop('show_interrupt')
+        status = kwargs.pop('status')
+        super(VmStateChangeForm, self).__init__(*args, **kwargs)
+
+        if not show_interrupt:
+            self.fields['interrupt'].widget = HiddenInput()
+        self.fields['new_state'].initial = status
 
     @property
     def helper(self):
@@ -1037,6 +1066,22 @@ class UserKeyForm(forms.ModelForm):
         return super(UserKeyForm, self).clean()
 
 
+class ConnectCommandForm(forms.ModelForm):
+    class Meta:
+        fields = ('name', 'access_method', 'template')
+        model = ConnectCommand
+
+    def __init__(self, *args, **kwargs):
+        self.user = kwargs.pop("user")
+        super(ConnectCommandForm, self).__init__(*args, **kwargs)
+
+    def clean(self):
+        if self.user:
+            self.instance.user = self.user
+
+        return super(ConnectCommandForm, self).clean()
+
+
 class TraitsForm(forms.ModelForm):
 
     class Meta:
@@ -1138,3 +1183,53 @@ class VmResourcesForm(forms.ModelForm):
     class Meta:
         model = Instance
         fields = ('num_cores', 'priority', 'ram_size', )
+
+
+vm_search_choices = (
+    ("owned", _("owned")),
+    ("shared", _("shared")),
+    ("all", _("all")),
+)
+
+
+class VmListSearchForm(forms.Form):
+    s = forms.CharField(widget=forms.TextInput(attrs={
+        'class': "form-control input-tags",
+        'placeholder': _("Search...")
+    }))
+
+    stype = forms.ChoiceField(vm_search_choices, widget=forms.Select(attrs={
+        'class': "btn btn-default form-control input-tags",
+        'style': "min-width: 80px;",
+    }))
+
+    include_deleted = forms.BooleanField(widget=forms.CheckboxInput(attrs={
+        'id': "vm-list-search-checkbox",
+    }))
+
+    def __init__(self, *args, **kwargs):
+        super(VmListSearchForm, self).__init__(*args, **kwargs)
+        # set initial value, otherwise it would be overwritten by request.GET
+        if not self.data.get("stype"):
+            data = self.data.copy()
+            data['stype'] = "all"
+            self.data = data
+
+
+class TemplateListSearchForm(forms.Form):
+    s = forms.CharField(widget=forms.TextInput(attrs={
+        'class': "form-control input-tags",
+        'placeholder': _("Search...")
+    }))
+
+    stype = forms.ChoiceField(vm_search_choices, widget=forms.Select(attrs={
+        'class': "btn btn-default input-tags",
+    }))
+
+    def __init__(self, *args, **kwargs):
+        super(TemplateListSearchForm, self).__init__(*args, **kwargs)
+        # set initial value, otherwise it would be overwritten by request.GET
+        if not self.data.get("stype"):
+            data = self.data.copy()
+            data['stype'] = "owned"
+            self.data = data

circle/dashboard/models.py

@@ -46,8 +46,10 @@ from acl.models import AclBase
 from common.models import HumanReadableObject, create_readable, Encoder
 
 from vm.tasks.agent_tasks import add_keys, del_keys
+from vm.models.instance import ACCESS_METHODS
 
 from .store_api import Store, NoStoreException, NotOkException
+from .validators import connect_command_template_validator
 
 logger = getLogger(__name__)
 
@@ -100,6 +102,25 @@ class Notification(TimeStampedModel):
         self.message_data = None if value is None else value.to_dict()
 
 
+class ConnectCommand(Model):
+    user = ForeignKey(User, related_name='command_set')
+    access_method = CharField(max_length=10, choices=ACCESS_METHODS,
+                              verbose_name=_('access method'),
+                              help_text=_('Type of the remote access method.'))
+    name = CharField(max_length="128", verbose_name=_('name'), blank=False,
+                     help_text=_("Name of your custom command."))
+    template = CharField(blank=True, null=True, max_length=256,
+                         verbose_name=_('command template'),
+                         help_text=_('Template for connection command string. '
+                                     'Available parameters are: '
+                                     'username, password, '
+                                     'host, port.'),
+                         validators=[connect_command_template_validator])
+
+    def __unicode__(self):
+        return self.template
+
+
 class Profile(Model):
     user = OneToOneField(User)
     preferred_language = CharField(verbose_name=_('preferred language'),
@@ -129,6 +150,25 @@ class Profile(Model):
         default=2048 * 1024 * 1024,
         help_text=_('Disk quota in mebibytes.'))
 
+    def get_connect_commands(self, instance, use_ipv6=False):
+        """ Generate connection command based on template."""
+        single_command = instance.get_connect_command(use_ipv6)
+        if single_command:  # can we even connect to that VM
+            commands = self.user.command_set.filter(
+                access_method=instance.access_method)
+            if commands.count() < 1:
+                return [single_command]
+            else:
+                return [
+                    command.template % {
+                        'port': instance.get_connect_port(use_ipv6=use_ipv6),
+                        'host':  instance.get_connect_host(use_ipv6=use_ipv6),
+                        'password': instance.pw,
+                        'username': 'cloud',
+                    } for command in commands]
+        else:
+            return []
+
     def notify(self, subject, template, context=None, valid_until=None,
                **kwargs):
         if context is not None:

circle/dashboard/static/dashboard/dashboard.css

@@ -654,7 +654,8 @@ textarea[name="list-new-namelist"] {
   width: 130px;
 }
 
-#vm-details-connection-string-copy {
+.vm-details-connection-string-copy,
+#vm-details-pw-show {
   cursor: pointer;
 }
 
@@ -681,10 +682,9 @@ textarea[name="list-new-namelist"] {
   max-width: 200px;
 }
 
-#dashboard-vm-details-connect-command {
+.dashboard-vm-details-connect-command {
   /* for mobile view */
   margin-bottom: 20px;
-
 }
 
 #store-list-list {
@@ -867,3 +867,92 @@ textarea[name="list-new-namelist"] {
   border-bottom: 1px dotted #aaa;
   padding: 5px 0px;
 }
+
+#profile-key-list-table td:last-child, #profile-key-list-table th:last-child,
+#profile-command-list-table td:last-child, #profile-command-list-table th:last-child,
+#profile-command-list-table td:nth-child(2), #profile-command-list-table th:nth-child(2) {
+  text-align: center;
+  vertical-align: middle;
+}
+
+#vm-list-table .migrating-icon {
+  -webkit-animation: passing 2s linear infinite;
+  animation: passing 2s linear infinite;
+}
+
+@-webkit-keyframes passing {
+  0% {
+    -webkit-transform: translateX(50%);
+    transform: translateX(50%);
+    opacity: 0;
+  }
+
+  50% {
+    -webkit-transform: translateX(0%);
+    transform: translateX(0%);
+    opacity: 1;
+  }
+
+  100% {
+    -webkit-transform: translateX(-50%);
+    transform: translateX(-50%);
+    opacity: 0;
+  }
+}
+
+@keyframes passing {
+  0% {
+    -webkit-transform: translateX(50%);
+    -ms-transform: translateX(50%);
+    transform: translateX(50%);
+    opacity: 0;
+  }
+
+  50% {
+    -webkit-transform: translateX(0%);
+    -ms-transform: translateX(0%);
+    transform: translateX(0%);
+    opacity: 1;
+  }
+
+  100% {
+    -webkit-transform: translateX(-50%);
+    -ms-transform: translateX(-50%);
+    transform: translateX(-50%);
+    opacity: 0;
+  }
+}
+
+.mass-migrate-node {
+  cursor: pointer;
+}
+
+.mass-op-panel {
+  padding: 6px 10px;
+}
+
+.mass-op-panel .check {
+  color: #449d44;
+}
+
+.mass-op-panel .minus {
+  color: #d9534f;
+}
+
+.mass-op-panel .status-icon {
+  font-size: .8em;
+}
+
+#vm-list-search, #vm-mass-ops {
+  margin-top: 8px;
+}
+
+#vm-list-search-checkbox {
+  margin-top: -1px;
+  display: inline-block;
+  vertical-align: middle;
+}
+
+#vm-list-search-checkbox-span {
+  cursor: pointer
+}

circle/dashboard/static/dashboard/dashboard.js

@@ -258,14 +258,15 @@ $(function () {
       html += '<div class="list-group-item list-group-item-last">' + gettext("No result") + '</div>';
     $("#dashboard-vm-list").html(html);
     $('.title-favourite').tooltip({'placement': 'right'});
+  });
 
-    // if there is only one result and ENTER is pressed redirect
-    if(e.keyCode == 13 && search_result.length == 1) {
-      window.location.href = "/dashboard/vm/" + search_result[0].pk + "/";
-    }
-    if(e.keyCode == 13 && search_result.length > 1 && input.length > 0) {
-      window.location.href = "/dashboard/vm/list/?s=" + input;
+  $("#dashboard-vm-search-form").submit(function() {
+    var vm_list_items = $("#dashboard-vm-list .list-group-item");
+    if(vm_list_items.length == 1 && vm_list_items.first().prop("href")) {
+      window.location.href = vm_list_items.first().prop("href");
+      return false;
     }
+    return true;
   });
 
   /* search for nodes */
@@ -494,14 +495,19 @@ function addSliderMiscs() {
     ram_fire = true;
     $(".ram-slider").simpleSlider("setValue", parseInt(val));
   });
-  $(".cpu-priority-input").trigger("change");
-  $(".cpu-count-input, .ram-input").trigger("input");
+
+  setDefaultSliderValues();
 
   $(".cpu-priority-slider").simpleSlider("setDisabled", $(".cpu-priority-input").prop("disabled"));
   $(".cpu-count-slider").simpleSlider("setDisabled", $(".cpu-count-input").prop("disabled"));
   $(".ram-slider").simpleSlider("setDisabled", $(".ram-input").prop("disabled"));
 }
 
+function setDefaultSliderValues() {
+  $(".cpu-priority-input").trigger("change");
+  $(".ram-input, .cpu-count-input").trigger("input");
+}
+
 
 /* deletes the VM with the pk
  * if dir is true, then redirect to the dashboard landing page
@@ -632,3 +638,11 @@ function noJS() {
   $('.no-js-hidden').show();
   $('.js-hidden').hide();
 }
+
+
+function getParameterByName(name) {
+    name = name.replace(/[\[]/, "\\[").replace(/[\]]/, "\\]");
+    var regex = new RegExp("[\\?&]" + name + "=([^&#]*)"),
+        results = regex.exec