Exemple #1
0
 def test_site(self):
     self.assertEqual(unicode(Horizon), "Horizon")
     self.assertEqual(repr(Horizon), "<Site: Horizon>")
     dash = Horizon.get_dashboard('nova')
     self.assertEqual(Horizon.get_default_dashboard(), dash)
     user = users.User()
     self.assertEqual(Horizon.get_user_home(user), dash.get_absolute_url())
Exemple #2
0
def horizon_all_nav(context):
    """ Generates top-level dashboard navigation entries. """
    if 'request' not in context:
        return {}
    current_dashboard = context['request'].horizon.get('dashboard')
    paneldashboard = context['request'].horizon['dashboard']
    panel_groups = paneldashboard.get_panel_groups()
    non_empty_groups = []
    dashboards = []  

    allowed_panels = []
    for dash in Horizon.get_dashboards(): 
        if callable(dash.nav) and dash.nav(context):
          dashboards.append(dash)
        elif dash.nav:
            dashboards.append(dash)
    for group in panel_groups.values():
        allowed_panels = []
        for panel in group:
            if callable(panel.nav) and panel.nav(context):
                allowed_panels.append(panel)
            elif not callable(panel.nav) and panel.nav:
                allowed_panels.append(panel)
        if allowed_panels:
            non_empty_groups.append((paneldashboard.name, allowed_panels)) 
     
    return {'components': dashboards,
             'groups':SortedDict(non_empty_groups),
            'user': context['request'].user,
            'current': current_dashboard,
            'request': context['request']}
Exemple #3
0
def switch_tenants(request, tenant_id):
    """
    Swaps a user from one tenant to another using the unscoped token from
    Keystone to exchange scoped tokens for the new tenant.
    """
    form, handled = LoginWithTenant.maybe_handle(
            request, initial={'tenant': tenant_id,
                              'username': request.user.username})
    if handled:
        return handled

    unscoped_token = request.session.get('unscoped_token', None)
    if unscoped_token:
        try:
            token = api.token_create_scoped(request,
                                            tenant_id,
                                            unscoped_token)
            _set_session_data(request, token)
            user = users.User(users.get_user_from_request(request))
            return shortcuts.redirect(Horizon.get_user_home(user))
        except:
            exceptions.handle(request,
                              _("You are not authorized for that tenant."))

    return shortcuts.redirect("horizon:auth_login")
Exemple #4
0
def switch_tenants(request, tenant_id):
    """
    Swaps a user from one tenant to another using the unscoped token from
    Keystone to exchange scoped tokens for the new tenant.
    """
    form, handled = LoginWithTenant.maybe_handle(
            request, initial={'tenant': tenant_id,
                              'username': request.user.username})
    if handled:
        return handled

    unscoped_token = request.session.get('unscoped_token', None)
    if unscoped_token:
        try:
            token = api.token_create_scoped(request,
                                            tenant_id,
                                            unscoped_token)
            _set_session_data(request, token)
            user = users.User(users.get_user_from_request(request))
            return shortcuts.redirect(Horizon.get_user_home(user))
        except exceptions.Unauthorized as e:
            messages.error(_("You are not authorized for that tenant."))

    # FIXME(gabriel): we don't ship switch_tenants.html
    return shortcuts.render(request,
                            'switch_tenants.html', {
                                'to_tenant': tenant_id,
                                'form': form})
Exemple #5
0
def horizon_nav(context):
    if 'request' not in context:
        return {}
    current_dashboard = context['request'].horizon.get('dashboard', None)
    current_panel = context['request'].horizon.get('panel', None)
    dashboards = []
    for dash in Horizon.get_dashboards():
        panel_groups = dash.get_panel_groups()
        non_empty_groups = []
        for group in panel_groups.values():
            allowed_panels = []
            for panel in group:
                if callable(panel.nav) and panel.nav(context) and \
                   panel.can_access(context):
                    allowed_panels.append(panel)
                elif not callable(panel.nav) and panel.nav and \
                         panel.can_access(context):
                    allowed_panels.append(panel)
            if allowed_panels:
                non_empty_groups.append((group.name, allowed_panels))
        if callable(dash.nav) and dash.nav(context) and \
           dash.can_access(context):
            dashboards.append((dash, SortedDict(non_empty_groups)))
        elif not callable(dash.nav) and dash.nav and \
             dash.can_access(context):
            dashboards.append((dash, SortedDict(non_empty_groups)))
    return {
        'components': dashboards,
        'user': context['request'].user,
        'current': current_dashboard,
        'current_panel': current_panel.slug if current_panel else '',
        'request': context['request']
    }
Exemple #6
0
def switch_tenants(request, tenant_id):
    """
    Swaps a user from one tenant to another using the unscoped token from
    Keystone to exchange scoped tokens for the new tenant.
    """
    form, handled = LoginWithTenant.maybe_handle(request,
                                                 initial={
                                                     'tenant':
                                                     tenant_id,
                                                     'username':
                                                     request.user.username
                                                 })
    if handled:
        return handled

    unscoped_token = request.session.get('unscoped_token', None)
    if unscoped_token:
        try:
            token = api.token_create_scoped(request, tenant_id, unscoped_token)
            _set_session_data(request, token)
            user = users.User(users.get_user_from_request(request))
            return shortcuts.redirect(Horizon.get_user_home(user))
        except exceptions.Unauthorized as e:
            messages.error(_("You are not authorized for that tenant."))

    # FIXME(gabriel): we don't ship switch_tenants.html
    return shortcuts.render(request, 'switch_tenants.html', {
        'to_tenant': tenant_id,
        'form': form
    })
Exemple #7
0
def horizon_nav(context):
    if "request" not in context:
        return {}
    current_dashboard = context["request"].horizon.get("dashboard", None)
    current_panel = context["request"].horizon.get("panel", None)
    dashboards = []
    for dash in Horizon.get_dashboards():
        panel_groups = dash.get_panel_groups()
        non_empty_groups = []
        for group in panel_groups.values():
            allowed_panels = []
            for panel in group:
                if callable(panel.nav) and panel.nav(context):
                    allowed_panels.append(panel)
                elif not callable(panel.nav) and panel.nav:
                    allowed_panels.append(panel)
            if allowed_panels:
                non_empty_groups.append((group.name, allowed_panels))
        if callable(dash.nav) and dash.nav(context):
            dashboards.append((dash, SortedDict(non_empty_groups)))
        elif not callable(dash.nav) and dash.nav:
            dashboards.append((dash, SortedDict(non_empty_groups)))
    return {
        "components": dashboards,
        "user": context["request"].user,
        "current": current_dashboard,
        "current_panel": current_panel.slug if current_panel else "",
        "request": context["request"],
    }
Exemple #8
0
def horizon_nav(context):
    if 'request' not in context:
        return {}
    current_dashboard = context['request'].horizon.get('dashboard', None)
    current_panel = context['request'].horizon.get('panel', None)
    dashboards = []
    for dash in Horizon.get_dashboards():
        panel_groups = dash.get_panel_groups()
        non_empty_groups = []
        for group in panel_groups.values():
            allowed_panels = []
            for panel in group:
                if callable(panel.nav) and panel.nav(context):
                    allowed_panels.append(panel)
                elif not callable(panel.nav) and panel.nav:
                    allowed_panels.append(panel)
            if allowed_panels:
                non_empty_groups.append((group.name, allowed_panels))
        if callable(dash.nav) and dash.nav(context):
            dashboards.append((dash, SortedDict(non_empty_groups)))
        elif not callable(dash.nav) and dash.nav:
            dashboards.append((dash, SortedDict(non_empty_groups)))
    return {'components': dashboards,
            'user': context['request'].user,
            'current': current_dashboard,
            'current_panel': current_panel.slug if current_panel else '',
            'request': context['request']}
Exemple #9
0
def switch_tenants(request, tenant_id):
    """
    Swaps a user from one tenant to another using the unscoped token from
    Keystone to exchange scoped tokens for the new tenant.
    """
    form, handled = LoginWithTenant.maybe_handle(request,
                                                 initial={
                                                     'tenant':
                                                     tenant_id,
                                                     'username':
                                                     request.user.username
                                                 })
    if handled:
        return handled

    unscoped_token = request.session.get('unscoped_token', None)
    if unscoped_token:
        try:
            token = api.token_create_scoped(request, tenant_id, unscoped_token)
            _set_session_data(request, token)
            user = users.User(users.get_user_from_request(request))
            return shortcuts.redirect(Horizon.get_user_home(user))
        except:
            exceptions.handle(request,
                              _("You are not authorized for that tenant."))

    return shortcuts.redirect("horizon:auth_login")
Exemple #10
0
def dashboard_register_mock(cls, panel):

    dashboard = horizon.get_dashboard(cls.slug)

    panel_policy_rules = []

    # apply common rules
    if cls.slug in policy_rules:
        if '*' in policy_rules[cls.slug]:
            panel_policy_rules.extend(policy_rules[cls.slug]['*'])
        # apply required permissions/policy_rules
        if cls.slug in policy_rules and panel.slug in policy_rules[cls.slug]:
            panel_policy_rules.extend(policy_rules[cls.slug][panel.slug])
        if len(panel_policy_rules) > 0:
            panel.policy_rules = panel_policy_rules

    # apply dashboard default panel
    if cls.slug in default_panel:
        dashboard.default_panel = default_panel[cls.slug]

    # register panel (original code)
    '''Registers a :class:`~horizon.Panel` with this dashboard.'''
    panel_class = Horizon.register_panel(cls, panel)
    # Support template loading from panel template directories.
    panel_mod = import_module(panel.__module__)
    panel_dir = os.path.dirname(panel_mod.__file__)
    template_dir = os.path.join(panel_dir, 'templates')
    if os.path.exists(template_dir):
        key = os.path.join(cls.slug, panel.slug)
        loaders.panel_template_dirs[key] = template_dir
    return panel_class
Exemple #11
0
    def process_exception(self, request, exception):
        """Catches internal Horizon exception classes.

        Exception classes such as NotAuthorized, NotFound and Http302
        are caught and handles them gracefully.
        """
        if isinstance(exception, exceptions.NotAuthenticated) or not \
                request.user.is_authenticated():
            auth_url = settings.LOGIN_URL
            next_url = iri_to_uri(request.get_full_path())
            if next_url != auth_url:
                field_name = REDIRECT_FIELD_NAME
            else:
                field_name = None
            login_url = request.build_absolute_uri(auth_url)
            response = redirect_to_login(next_url,
                                         login_url=login_url,
                                         redirect_field_name=field_name)

            if request.is_ajax():
                response_401 = http.HttpResponse(status=401)
                response_401['X-Horizon-Location'] = response['location']
                response = response_401

            login_user = request.COOKIES.get("login_user")
            if login_user:
                LOG.info("process_exception logout user %s", login_user)
                auth_utils.handle_user_logout(login_user)
                response.set_cookie("login_user")

            return response

        if isinstance(exception, exceptions.NotAuthorized):
            """ Not authorized could be a result of project context switching.
                redirect to dashboard page if it is possible or to homepage
            """
            if hasattr(request.horizon, 'dashboard'):
                url = request.horizon.dashboard.get_absolute_url()
            else:
                # go home if there isn't dashboard
                url = Horizon.get_user_home(request.user)

            response = shortcuts.redirect(url)
            if request.is_ajax():
                response_403 = http.HttpResponse(status=403)
                response_403['X-Horizon-Location'] = response['location']
                return response_403

            LOG.info('Access is not authorized, redirect to: %s', url)
            return response

        # If an internal "NotFound" error gets this far, return a real 404.
        if isinstance(exception, exceptions.NotFound):
            raise http.Http404(exception)

        if isinstance(exception, exceptions.Http302):
            # TODO(gabriel): Find a way to display an appropriate message to
            # the user *on* the login form...
            return shortcuts.redirect(exception.location)
def horizon_nav(context):
    if 'request' not in context:
        return {}
    current_dashboard = context['request'].horizon.get('dashboard', None)
    current_panel_group = None
    current_panel = context['request'].horizon.get('panel', None)
    dashboards = []

    try:
        Horizon.get_project_id(context)
    except:
        pass

    for dash in Horizon.get_dashboards():
        panel_groups = dash.get_panel_groups()
        non_empty_groups = []
        for group in panel_groups.values():
            allowed_panels = []
            for panel in group:
                if (callable(panel.nav) and panel.nav(context)
                        and panel.can_access(context)):
                    allowed_panels.append(panel)
                elif (not callable(panel.nav) and panel.nav
                      and panel.can_access(context)):
                    allowed_panels.append(panel)
                if panel == current_panel:
                    current_panel_group = group.slug
            if allowed_panels:
                non_empty_groups.append((group, allowed_panels))
        if (callable(dash.nav) and dash.nav(context)
                and dash.can_access(context)):
            dashboards.append((dash, OrderedDict(non_empty_groups)))
        elif (not callable(dash.nav) and dash.nav
              and dash.can_access(context)):
            dashboards.append((dash, OrderedDict(non_empty_groups)))
    return {
        'components': dashboards,
        'user': context['request'].user,
        'current': current_dashboard,
        'current_panel_group': current_panel_group,
        'current_panel': current_panel.slug if current_panel else '',
        'request': context['request']
    }
Exemple #13
0
def horizon_main_nav(context):
    """ Generates top-level dashboard navigation entries. """
    if 'request' not in context:
        return {}
    current_dashboard = context['request'].horizon.get('dashboard', None)
    dashboards = []
    for dash in Horizon.get_dashboards():
        if callable(dash.nav) and dash.nav(context):
            dashboards.append(dash)
        elif dash.nav:
            dashboards.append(dash)
    return {'components': dashboards,
            'user': context['request'].user,
            'current': getattr(current_dashboard, 'slug', None)}
Exemple #14
0
def login(request):
    """
    Logs in a user and redirects them to the URL specified by
    :func:`horizon.get_user_home`.
    """
    if request.user.is_authenticated():
        user = users.User(users.get_user_from_request(request))
        return shortcuts.redirect(Horizon.get_user_home(user))

    form, handled = Login.maybe_handle(request)
    if handled:
        return handled

    # FIXME(gabriel): we don't ship a view named splash
    return shortcuts.render(request, 'splash.html', {'form': form})
Exemple #15
0
def login(request):
    """
    Logs in a user and redirects them to the URL specified by
    :func:`horizon.get_user_home`.
    """
    if request.user.is_authenticated():
        user = users.User(users.get_user_from_request(request))
        return shortcuts.redirect(Horizon.get_user_home(user))

    form, handled = Login.maybe_handle(request)
    if handled:
        return handled

    # FIXME(gabriel): we don't ship a view named splash
    return shortcuts.render(request, 'splash.html', {'form': form})
Exemple #16
0
def horizon_main_nav(context):
    """ Generates top-level dashboard navigation entries. """
    if 'request' not in context:
        return {}
    current_dashboard = context['request'].horizon.get('dashboard', None)
    dashboards = []
    for dash in Horizon.get_dashboards():
        if callable(dash.nav) and dash.nav(context):
            dashboards.append(dash)
        elif dash.nav:
            dashboards.append(dash)
    return {'components': dashboards,
            'user': context['request'].user,
            'current': current_dashboard,
            'request': context['request']}
def horizon_main_nav(context):
    """ Generates top-level dashboard navigation entries. """
    if "request" not in context:
        return {}
    current_dashboard = context["request"].horizon.get("dashboard", None)
    dashboards = []
    for dash in Horizon.get_dashboards():
        if callable(dash.nav) and dash.nav(context):
            dashboards.append(dash)
        elif dash.nav:
            dashboards.append(dash)
    return {
        "components": dashboards,
        "user": context["request"].user,
        "current": getattr(current_dashboard, "slug", None),
    }
Exemple #18
0
# Author: DreamHost, LLC
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.


from horizon.base import Horizon


nova_dashboard = Horizon.get_dashboard("project")
compute_panel_group = nova_dashboard.get_panel_group("network")
compute_panel_group.panels.append("networking")

#
# Manually override the definition of the router detail view method
# to properly look up port data w/ akanda. May God have mercy on my soul.
#
from openstack_dashboard.dashboards.project.routers import views
from akanda.horizon.routers.views import get_interfaces_data

views.DetailView.get_interfaces_data = get_interfaces_data
Exemple #19
0
from horizon.base import Horizon


nova_dashboard = Horizon.get_dashboard('nova')
compute_panel_group = nova_dashboard.get_panel_group('compute')
compute_panel_group.panels.append('networking')
Exemple #20
0
from horizon.base import Horizon

nova_dashboard = Horizon.get_dashboard('project')
compute_panel_group = nova_dashboard.get_panel_group('network')
compute_panel_group.panels.append('networking')
Exemple #21
0
from horizon.base import Horizon


nova_dashboard = Horizon.get_dashboard('project')
compute_panel_group = nova_dashboard.get_panel_group('network')
compute_panel_group.panels.append('networking')