Produits Entr'ouvert » Hobo

import json

import logging

import threading

from itertools import chain, islice

import requests

from django.db import connection, transaction

from django.urls import reverse

from django.utils.encoding import force_text

from django_rbac.utils import get_ou_model, get_role_model, get_role_parenting_model

from hobo.agent.common import notify_agents

        tenant = getattr(connection, 'tenant', None)

        assert tenant

        base_url = tenant.get_base_url()

    def pre_save(self, sender, instance, raw, using, update_fields, **kwargs):

        if not self.stack:

from django import forms

from django.core import validators

from django.core.exceptions import ValidationError

from django.utils.translation import ugettext_lazy as _

    def format_value(self, value):

        if not value:

            return ''

            return u', '.join(value)

        return value

import subprocess

import sys

import tempfile

import requests

from django.conf import settings

from django.core.management import call_command, get_commands

from django.core.management.base import BaseCommand, CommandError

from django.utils.encoding import force_text

from tenant_schemas.utils import tenant_context

from hobo.multitenant.middleware import TenantMiddleware, TenantNotFound

        if self.me.get('secondary') and self.early_secondary_exit:

            # early exit, we don't redeploy secondary services

            return

        legacy_domain = None

        try:

        except TenantNotFound:

            # might be a domain change request

            for legacy_urls in self.me.get('legacy_urls', []):

                try:

                    tenant = TenantMiddleware.get_tenant_by_hostname(old_domain)

                    legacy_domain = old_domain

import os

import subprocess

import sys

from django.utils.encoding import force_bytes

from . import settings

        patterns = settings.AGENT_HOST_PATTERNS.get(cls.service_id)

        if patterns is None:

            return True

        netloc = parsed_url.netloc

        match = False

        for pattern in patterns:

        tenants = list(cls.get_actual_tenants())

        if tenants:

            for audience in data.get('audience', []):

                netloc = parsed_url.netloc.split(':')[0]

                if netloc in tenants:

                    break

import logging

import os

import threading

import requests

from django.conf import settings

from django.template import Template

from django.utils.encoding import smart_bytes

from django.utils.http import urlencode

from hobo.scrutiny.wsgi.middleware import VersionMiddleware

    @property

    def cache_key(self):

        return hashlib.md5(

        ).hexdigest()

    def get_template(self):

    def update_all_pages_cache(self):

        # always cache root

        if not root_url in self.combo_skeleton_pages.values():

            self.combo_skeleton_pages['__root'] = root_url

import os

import string

import subprocess

from django.contrib.auth.models import User

from django.contrib.contenttypes.models import ContentType

from django.core.management.base import BaseCommand, CommandError

from django.db import connection

from django.db.models import Max

from django.utils.text import slugify

from hobo.agent.common.management.commands.hobo_deploy import Command as HoboDeployCommand

def get_domain(url):

class Command(BaseCommand):

        for step in recipe.get('steps', []):

            action, action_args = list(step.items())[0]

            for arg in action_args:

                    continue

                action_args[arg] = string.Template(action_args[arg]).substitute(variables)

            if not self.permissive:

import re

import socket

import time

import requests

from django.conf import settings

from django.core.exceptions import ValidationError

from django.core.validators import URLValidator

from django.db import models

from django.utils.crypto import get_random_string

from django.utils.encoding import force_text

from django.utils.timezone import now

from django.utils.translation import ugettext_lazy as _

        return (self.last_operational_check_timestamp - self.last_update_timestamp) < two_minutes

    def as_dict(self):

        as_dict['base_url'] = self.get_base_url_path()

        if self.legacy_urls:

            as_dict['legacy_urls'] = self.legacy_urls

    def is_resolvable(self):

        try:

            if netloc and socket.gethostbyname(netloc):

                return True

        except socket.gaierror:

import sys

import time

from django.conf import settings

from django.core.management.base import CommandError

from django.db import connection, transaction

from django.urls import reverse

from django.utils.encoding import force_text

from hobo.middleware.utils import StoreRequestMiddleware

from hobo.multitenant.settings_loaders import KnownServices

    Distinguish mutualised domains (matching a "-" in the first part of the netloc)

    from the normal scenario with a dedicated parent domain.

    """

    parts = ph.netloc.split('.')

    if '-' in parts[0]:

        netloc = '%s-%s.%s' % (service, parts[0].split('-')[1], '.'.join(parts[1:]))

from django.core.exceptions import ValidationError

from django.utils.translation import gettext_lazy as _

from hobo.environment.models import ServiceBase

        raise ValidationError(

            _('Error: %(netloc)s is not resolvable in URL %(url)s'),

            code='not-resolvable',

        )

    if not service.has_valid_certificate():

        raise ValidationError(

import traceback as _traceback

from syslog import LOG_ALERT, LOG_CRIT, LOG_DEBUG, LOG_ERR, LOG_INFO, LOG_WARNING

from systemd._journal import sendv

_IDENT_CHARACTER = set('ABCDEFGHIJKLMNOPQRTSUVWXYZ_0123456789')

def _make_line(field, value):

    if isinstance(value, bytes):

        return field.encode('utf-8') + b'=' + value

        return field + '=' + value

    else:

        return field + '=' + str(value)

import hashlib

import re

import string

from random import choice, randint

import requests

from django.core import exceptions

from django.db import connection

from django.utils.encoding import force_bytes

from lxml import etree

from hobo.environment.models import Combo, Fargo, Variable, Wcs

    tenant_name = None

    services = [x for x in Combo.objects.all() if 'portal-user' in x.template_name and not x.secondary]

    if services != [] and services[0] != '':

    services += [x for x in Wcs.objects.all() if not x.secondary]

    services += [x for x in Fargo.objects.all() if not x.secondary]

    site_urls = [x.base_url for x in services if x.base_url != '']

from django.core.management import call_command, get_commands, load_command_class

from django.core.management.base import BaseCommand, CommandError

from django.db import connection

from tenant_schemas.utils import get_public_schema_name

from hobo.multitenant.middleware import TenantMiddleware

from django.contrib.staticfiles.management.commands.runserver import Command as StaticRunserverCommand

from django.contrib.staticfiles.views import serve

from django.core.management.commands.runserver import Command as RunserverCommand

from django.views import static

from hobo.multitenant.middleware import TenantMiddleware, TenantNotFound

from django.core.management import call_command, get_commands, load_command_class

from django.core.management.base import BaseCommand, CommandError, SystemCheckError, handle_default_options

from django.db import connection, connections

from django.utils.encoding import force_text

from hobo.multitenant.management.commands import InteractiveTenantOption

def exception_to_text(e):

    try:

    except Exception:

        pass

import json

import os

from shutil import rmtree

from django.conf import settings

from django.db import connection

from django.utils import timezone

from tenant_schemas.models import TenantMixin

from tenant_schemas.postgresql_backend.base import _check_schema_name

from tenant_schemas.utils import django_is_in_test_mode, get_public_schema_name, schema_exists

        return 'https://%s' % self.domain_url

    def build_absolute_uri(self, location):

    def create_schema(self, check_if_exists=False, sync_schema=True, verbosity=1, legacy_schema_name=None):

        if not legacy_schema_name:

from django.conf import settings

from django.utils.encoding import force_bytes

from django.utils.http import urlencode

from hobo.theme.utils import get_theme

        services = hobo_json.get('services')

        this = [s for s in services if s.get('this')][0]

        base_url = this['base_url']

        secret = this['secret_key']

        for service in services:

            service_id = service.get('service-id')

            url = service.get('base_url')

            service_data = {

                'url': url,

                'backoffice-menu-url': service.get('backoffice-menu-url'),

            base_url = service.get('base_url')

            if not base_url:

                continue

            origin = '%s://%s' % (base_url.scheme, base_url.netloc)

            if not origin in whitelist:

                whitelist.append(origin)

from django.core.validators import RegexValidator

from django.db import models

from django.utils.translation import ugettext_lazy as _

validate_attribute_name = RegexValidator(

        ordering = ['order']

    def as_dict(self):

        return as_dict

    def get_real_kind_display(self):

import json

import logging

import sys

from django.conf import settings

from django.db import connection

from django.http import HttpResponseBadRequest, HttpResponseForbidden, JsonResponse

from django.utils.deprecation import MiddlewareMixin

from django.utils.encoding import force_bytes, force_text

from hobo.provisionning.utils import NotificationProcessing

from hobo.rest_authentication import PublikAuthentication, PublikAuthenticationFailed

            from hobo.multitenant.settings_loaders import KnownServices

            authentic = Authentic.objects.all().first()

            # create stub settings.KNOWN_SERVICES with just enough to get

            # authentication passing.

            idp_service = list(settings.KNOWN_SERVICES['authentic'].values())[0]

import json

import pkg_resources

from django.utils.deprecation import MiddlewareMixin

try:

    import apt.cache as apt_cache

    def __call__(self, environ, start_response):

        path = ''

        method = environ.get('REQUEST_METHOD', 'GET')

        if method == 'GET' and (path == '/__version__' or path == '/__version__/'):

            packages_version = self.get_packages_version()

import hmac

import random

import secrets

from django.utils.encoding import smart_bytes

from django.utils.http import quote, urlencode

'''Simple signature scheme for query strings'''

def sign_url(url, key, algo='sha256', timestamp=None, nonce=None):

    new_query = sign_query(parsed.query, key, algo, timestamp, nonce)

def sign_query(query, key, algo='sha256', timestamp=None, nonce=None):

def sign_string(s, key, algo='sha256'):

    digestmod = getattr(hashlib, algo)

        key = key.encode('utf-8')

    hash = hmac.HMAC(smart_bytes(key), digestmod=digestmod, msg=smart_bytes(s))

    return hash.digest()

def check_url(url, key, known_nonce=None, timedelta=30, raise_on_error=False):

    return check_query(

        parsed.query, key, known_nonce=known_nonce, timedelta=timedelta, raise_on_error=raise_on_error

    )

def check_query(query, key, known_nonce=None, timedelta=30, raise_on_error=False):

    parsed = {key: value[0] if len(value) == 1 else value for key, value in parsed.items()}

    signature = parsed.get('signature')

    if not signature or not isinstance(signature, str):

import os

from django.conf import settings

def get_themes():

    for variable in theme.get('variables', {}).keys():

        theme_variable, created = Variable.objects.get_or_create(name=variable, service_pk__isnull=True)

        theme_variable.auto = True

            theme_variable.value = theme['variables'][variable]

        else:

            theme_variable.value = json.dumps(theme['variables'][variable])

import json

import os

import pytest

from django.contrib.auth.models import User

from django.contrib.contenttypes.models import ContentType

from django.core.management.base import CommandError

from mock import Mock, call, mock_open, patch

from hobo.environment.management.commands.cook import Command

import json

import os

import sys

import pytest

from mock import Mock, call, patch

from requests import Response, exceptions

import datetime

from hobo import signature

    # Test timedelta parameter

    now = datetime.datetime.utcnow()

        URL, KEY, timestamp=now

    )

def byteify(input):

    if isinstance(input, dict):

        return {byteify(key): byteify(value) for key, value in input.items()}

    elif isinstance(input, list):

        return [byteify(element) for element in input]

        return input.encode('utf-8')

    else:

        return input

import os

from mock import mock_open, patch

# Debian defaults

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

import re

import pytest

from django.contrib.auth import get_user_model

from django.test import RequestFactory

from rest_framework import permissions

from rest_framework.response import Response

from rest_framework.views import APIView

        User = get_user_model()

        user = User.objects.create(username='foo', password='foo')

        ORIG = 'other.example.net'

        URL = '/api/?coucou=zob'

        factory = RequestFactory()

        assert result[1] is None

        # Test anonymous user

        request = factory.get(signature.sign_url(URL + AUTH_QUERY, key))

        publik_authentication = rest_authentication.PublikAuthentication()

        # Test user named after service orig

        service_user = User.objects.create(username=ORIG)

        request = factory.get(signature.sign_url(URL + AUTH_QUERY, key))

        publik_authentication = rest_authentication.PublikAuthentication()

import os.path

from mock import mock_open, patch

from hobo.settings import *

import os

from mock import mock_open, patch

LANGUAGE_CODE = 'en-us'

import os

from mock import mock_open, patch

# Debian defaults

import json

import os

import sys

from django.core.management import call_command

from django.db import connection

from passerelle.utils import export_site

from hobo.multitenant.middleware import TenantMiddleware