Merge remote-tracking branch 'origin/master' into issue-218

.gitignore

@@ -39,3 +39,4 @@ circle/static_collected
 
 # jsi18n files
 jsi18n
+scripts.rc

circle/circle/settings/base.py

@@ -161,7 +161,7 @@ STATICFILES_FINDERS = (
 )
 ########## END STATIC FILE CONFIGURATION
 
-p = join(dirname(SITE_ROOT), 'site-circle/static')
+p = normpath(join(SITE_ROOT, '../../site-circle/static'))
 if exists(p):
     STATICFILES_DIRS = (p, )
 
@@ -211,8 +211,8 @@ TEMPLATE_LOADERS = (
 
 # See: https://docs.djangoproject.com/en/dev/ref/settings/#template-dirs
 TEMPLATE_DIRS = (
+    normpath(join(SITE_ROOT, '../../site-circle/templates')),
     normpath(join(SITE_ROOT, 'templates')),
-    join(dirname(SITE_ROOT), 'site-circle/templates'),
 )
 ########## END TEMPLATE CONFIGURATION
 
@@ -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',
@@ -465,3 +465,6 @@ SESSION_COOKIE_NAME = "csessid%x" % (((getnode() // 139) ^
                                       (getnode() % 983)) & 0xffff)
 
 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/')

circle/circle/settings/production.py

@@ -20,22 +20,17 @@
 
 
 from os import environ
+from sys import argv
 
 from base import *  # noqa
 
-
-def get_env_setting(setting):
-    """ Get the environment setting or return exception """
-    try:
-        return environ[setting]
-    except KeyError:
-        error_msg = "Set the %s env variable" % setting
-        raise ImproperlyConfigured(error_msg)
+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/
 #      #allowed-hosts-required-in-production
-ALLOWED_HOSTS = get_env_setting('DJANGO_ALLOWED_HOSTS').split(',')
+ALLOWED_HOSTS = get_env_variable('DJANGO_ALLOWED_HOSTS').split(',')
 ########## END HOST CONFIGURATION
 
 ########## EMAIL CONFIGURATION
@@ -44,18 +39,18 @@ EMAIL_BACKEND = 'django.core.mail.backends.smtp.EmailBackend'
 
 try:
     # See: https://docs.djangoproject.com/en/dev/ref/settings/#email-host
-    EMAIL_HOST = environ.get('EMAIL_HOST')
+    EMAIL_HOST = get_env_variable('EMAIL_HOST')
 except ImproperlyConfigured:
-    pass
+    EMAIL_HOST = 'localhost'
 else:
     # https://docs.djangoproject.com/en/dev/ref/settings/#email-host-password
-    EMAIL_HOST_PASSWORD = environ.get('EMAIL_HOST_PASSWORD', '')
+    EMAIL_HOST_PASSWORD = get_env_variable('EMAIL_HOST_PASSWORD', '')
 
     # See: https://docs.djangoproject.com/en/dev/ref/settings/#email-host-user
-    EMAIL_HOST_USER = environ.get('EMAIL_HOST_USER', 'your_email@example.com')
+    EMAIL_HOST_USER = get_env_variable('EMAIL_HOST_USER', 'your_email@example.com')
 
     # See: https://docs.djangoproject.com/en/dev/ref/settings/#email-port
-    EMAIL_PORT = environ.get('EMAIL_PORT', 587)
+    EMAIL_PORT = get_env_variable('EMAIL_PORT', 587)
 
     # See: https://docs.djangoproject.com/en/dev/ref/settings/#email-use-tls
     EMAIL_USE_TLS = True
@@ -64,7 +59,8 @@ else:
 EMAIL_SUBJECT_PREFIX = '[%s] ' % SITE_NAME
 
 # See: https://docs.djangoproject.com/en/dev/ref/settings/#server-email
-SERVER_EMAIL = EMAIL_HOST_USER
+DEFAULT_FROM_EMAIL = get_env_variable('DEFAULT_FROM_EMAIL')
+SERVER_EMAIL = get_env_variable('SERVER_EMAIL', DEFAULT_FROM_EMAIL)
 ########## END EMAIL CONFIGURATION
 
 
@@ -83,5 +79,12 @@ CACHES = {
 
 ########## SECRET CONFIGURATION
 # See: https://docs.djangoproject.com/en/dev/ref/settings/#secret-key
-SECRET_KEY = get_env_setting('SECRET_KEY')
+SECRET_KEY = get_env_variable('SECRET_KEY')
 ########## END SECRET CONFIGURATION
+
+level = environ.get('LOGLEVEL', 'INFO')
+LOGGING['handlers']['syslog']['level'] = level
+for i in LOCAL_APPS:
+    LOGGING['loggers'][i] = {'handlers': ['syslog'], 'level': level}
+LOGGING['loggers']['djangosaml2'] = {'handlers': ['syslog'], 'level': level}
+LOGGING['loggers']['django'] = {'handlers': ['syslog'], 'level': level}

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__)
@@ -211,6 +214,46 @@ class ActivityModel(TimeStampedModel):
 
         self.result_data = None if value is None else value.to_dict()
 
+    @classmethod
+    def construct_activity_code(cls, code_suffix, sub_suffix=None):
+        code = join_activity_code(cls.ACTIVITY_CODE_BASE, code_suffix)
+        if sub_suffix:
+            return join_activity_code(code, sub_suffix)
+        else:
+            return code
+
+
+@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 +276,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 +299,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 +422,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 +464,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,
@@ -431,17 +496,38 @@ class HumanReadableException(HumanReadableObject, Exception):
                     "Level should be the name of an attribute of django."
                     "contrib.messages (and it should be callable with "
                     "(request, message)). Like 'error', 'warning'.")
-        else:
+        elif not hasattr(self, "level"):
             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.
@@ -256,3 +273,4 @@ def register_operation(op_cls, op_id=None, target_cls=None):
         setattr(target_cls, operation_registry_name, dict())
 
     getattr(target_cls, operation_registry_name)[op_id] = op_cls
+    return op_cls

circle/common/views.py

@@ -25,9 +25,9 @@ def handler500(request):
                     ctx['error'] = exception.get_admin_text()
             except:
                 pass
-        try:
-            resp = render_to_response("500.html", ctx, RequestContext(request))
-        except:
-            resp = render_to_response("500.html", ctx)
-        resp.status_code = 500
-        return resp
+    try:
+        resp = render_to_response("500.html", ctx, RequestContext(request))
+    except:
+        resp = render_to_response("500.html", ctx)
+    resp.status_code = 500
+    return resp

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/autocomplete_light_registry.py

 import autocomplete_light
+from django.contrib.auth.models import User
+from django.utils.html import escape
 from django.utils.translation import ugettext as _
 
 from .views import AclUpdateView
+from .models import Profile
 
 
-class AclUserAutocomplete(autocomplete_light.AutocompleteGenericBase):
+def highlight(field, q, none_wo_match=True):
+    """
+    >>> highlight('<b>Akkount Krokodil', 'kro', False)
+    u'&lt;b&gt;Akkount <span class="autocomplete-hl">Kro</span>kodil'
+    """
+
+    if not field:
+        return None
+    try:
+        match = field.lower().index(q.lower())
+    except ValueError:
+        match = None
+    if q and match is not None:
+        match_end = match + len(q)
+        return (escape(field[:match])
+                + '<span class="autocomplete-hl">'
+                + escape(field[match:match_end])
+                + '</span>' + escape(field[match_end:]))
+    elif none_wo_match:
+        return None
+    else:
+        return escape(field)
+
+
+class AclUserGroupAutocomplete(autocomplete_light.AutocompleteGenericBase):
     search_fields = (
-        ('^first_name', 'last_name', 'username', '^email', 'profile__org_id'),
-        ('^name', 'groupprofile__org_id'),
+        ('first_name', 'last_name', 'username', 'email', 'profile__org_id'),
+        ('name', 'groupprofile__org_id'),
     )
-    autocomplete_js_attributes = {'placeholder': _("Name of group or user")}
-    choice_html_format = u'<span data-value="%s"><span>%s</span> %s</span>'
+    choice_html_format = (u'<span data-value="%s"><span style="display:none"'
+                          u'>%s</span>%s</span>')
 
-    def choice_html(self, choice):
-        try:
-            name = choice.get_full_name()
-        except AttributeError:
-            name = _('group')
-        if name:
-            name = u'(%s)' % name
+    def choice_displayed_text(self, choice):
+        q = unicode(self.request.GET.get('q', ''))
+        name = highlight(unicode(choice), q, False)
+        if isinstance(choice, User):
+            extra_fields = [highlight(choice.get_full_name(), q, False),
+                            highlight(choice.email, q)]
+            try:
+                extra_fields.append(highlight(choice.profile.org_id, q))
+            except Profile.DoesNotExist:
+                pass
+            return '%s (%s)' % (name, ', '.join(f for f in extra_fields
+                                                if f))
+        else:
+            return _('%s (group)') % name
 
+    def choice_html(self, choice):
         return self.choice_html_format % (
-            self.choice_value(choice), self.choice_label(choice), name)
+            self.choice_value(choice), self.choice_label(choice),
+            self.choice_displayed_text(choice))
 
     def choices_for_request(self):
         user = self.request.user
         self.choices = (AclUpdateView.get_allowed_users(user),
                         AclUpdateView.get_allowed_groups(user))
-        return super(AclUserAutocomplete, self).choices_for_request()
+        return super(AclUserGroupAutocomplete, self).choices_for_request()
+
+    def autocomplete_html(self):
+        html = []
+
+        for choice in self.choices_for_request():
+            html.append(self.choice_html(choice))
+
+        if not html:
+            html = self.empty_html_format % _('no matches found').capitalize()
+
+        return self.autocomplete_html_format % ''.join(html)
+
+
+class AclUserAutocomplete(AclUserGroupAutocomplete):
+    def choices_for_request(self):
+        user = self.request.user
+        self.choices = (AclUpdateView.get_allowed_users(user), )
+        return super(AclUserGroupAutocomplete, self).choices_for_request()
 
 
+autocomplete_light.register(AclUserGroupAutocomplete)
 autocomplete_light.register(AclUserAutocomplete)

circle/dashboard/fixtures/test-vm-fixture.json

@@ -1383,7 +1383,6 @@
     "time_of_suspend": null, 
     "ram_size": 200, 
     "priority": 10, 
-    "active_since": null, 
     "template": null, 
     "access_method": "nx", 
     "lease": 1, 
@@ -1413,7 +1412,6 @@
     "time_of_suspend": null, 
     "ram_size": 200, 
     "priority": 10, 
-    "active_since": null, 
     "template": null, 
     "access_method": "nx", 
     "lease": 1, 

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 .store_api import Store, NoStoreException, NotOkException, Timeout
+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:
@@ -161,6 +201,11 @@ class Profile(Model):
     def __unicode__(self):
         return self.get_display_name()
 
+    def save(self, *args, **kwargs):
+        if self.org_id == "":
+            self.org_id = None
+        super(Profile, self).save(*args, **kwargs)
+
     class Meta:
         permissions = (
             ('use_autocomplete', _('Can use autocomplete.')),
@@ -216,7 +261,7 @@ def get_or_create_profile(self):
 Group.profile = property(get_or_create_profile)
 
 
-def create_profile(sender, user, request, **kwargs):
+def create_profile(user):
     if not user.pk:
         return False
     profile, created = Profile.objects.get_or_create(user=user)
@@ -227,7 +272,11 @@ def create_profile(sender, user, request, **kwargs):
         logger.exception("Can't create user %s", unicode(user))
     return created
 
-user_logged_in.connect(create_profile)
+
+def create_profile_hook(sender, user, request, **kwargs):
+    return create_profile(user)
+
+user_logged_in.connect(create_profile_hook)
 
 if hasattr(settings, 'SAML_ORG_ID_ATTRIBUTE'):
     logger.debug("Register save_org_id to djangosaml2 pre_user_save")
@@ -301,7 +350,7 @@ def update_store_profile(sender, **kwargs):
                       profile.disk_quota)
     except NoStoreException:
         logger.debug("Store is not available.")
-    except NotOkException:
+    except (NotOkException, Timeout):
         logger.critical("Store is not accepting connections.")
 
 

circle/dashboard/static/dashboard/dashboard.css

@@ -591,11 +591,15 @@ footer a, footer a:hover, footer a:visited {
   width: 100px;
 }
 
+#group-detail-user-table tr:last-child td:nth-child(2) {
+  text-align: left;
+}
+
 #group-detail-perm-header {
   margin-top: 25px;
 }
 
-textarea[name="list-new-namelist"] {
+textarea[name="new_members"] {
   max-width: 500px;
   min-height: 80px;
   margin-bottom: 10px;
@@ -654,7 +658,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 +686,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 +871,135 @@ textarea[name="list-new-namelist"] {
   border-bottom: 1px dotted #aaa;
   padding: 5px 0px;
 }
+
+