Tryag File Manager - Edit By Mr.SaHr

//opt/nydus/pyvenv/lib64/python3.5/site-packages/nydus/util/__init__.py

# -*- coding: utf-8 -*-

from datetime import timedelta
from urllib.parse import urlparse
from typing import Optional
import logging

from archon.datasource.aqueue import LinuxExt4Queue, PostgresQueue, Queue, WindowsQueue
from archon.datasource.store import LinuxExt4Store, PostgresStore, Store, WindowsStore
from primordial.config import Config

from nydus.util.database import postgres_url
from nydus.util.dqueue import delayqueue

__all__ = [
    "JobStatus", "delayqueue", "first", "queue", "store"
]

LOG = logging.getLogger(__name__)

def first(predicate, iterable, default=None):
    return next(filter(predicate, iterable), default)

def queue(config: Config) -> Optional[Queue]:
    """Return an Archon queue configured according to the provided config.

:param config: String, config to get queue configuration from.

:returns: archon.datasource.aqueue.Queue. The configured Archon queue.

"""
    queue_type = config.get('queue.type')

if queue_type == 'PostgresQueue':
        return _postgres_queue(config)  # type: ignore
    if queue_type == 'LinuxExt4Queue':
        return _ext4_queue(config)
    if queue_type == 'WindowsQueue':
        return _win_queue(config)
    LOG.error('Unknown queue type "%s"', queue_type)
    return None

def _postgres_queue(config: Config) -> PostgresQueue:
    url_parts = {
        var: config.get('queue.%s' % var, None) for var in
        ['port', 'database', 'schema', 'username', 'password', 'lock_timeout']
    }
    url_parts['hostname'] = config.get('queue.server')
    url = postgres_url(**url_parts)
    visibility_timeout = config.get_int('queue.visibility_timeout')
    return PostgresQueue(
        config.get('queue.name'),
        timedelta(seconds=visibility_timeout),
        url)

def _ext4_queue(config: Config) -> LinuxExt4Queue:
    visibility_timeout = config.get_int('queue.visibility_timeout')
    return LinuxExt4Queue(
        config.get('queue.name'),
        timedelta(seconds=visibility_timeout),
        config.get('queue.path'),
        safe_to_reconnect_to_path=True,
        file_owner=config.get('service_user'),
        file_group=config.get('service_group'))

def _win_queue(config: Config) -> WindowsQueue:
    visibility_timeout = config.get_int('queue.visibility_timeout')
    return WindowsQueue(
        config.get('queue.name'),
        timedelta(seconds=visibility_timeout),
        config.get('queue.path'),
        safe_to_reconnect_to_path=True,
        all_access_user=config.get('service_user'),
    )

def store(config: Config, store_url: str = None) -> Optional[Store]:
    """Return an Archon store configured according to the provided config.

:param config: config to get store configuration from.
    :param store_url: An optional URL-style spec for the store location; e.g.,
        * postgres://user:pass@host:port/database/
        * ext4:///filename
        * windows:///filename
    :returns: The configured Archon store.
    """
    if not store_url:
        store_type = config.get('store.type')

if store_type == 'PostgresStore':
            return _postgres_store(config)  # type: ignore
        if store_type == 'LinuxExt4Store':
            return _ext4_store(config)
        if store_type == 'WindowsStore':
            return _win_store(config)
    else:
        parts = urlparse(store_url)
        if parts.scheme == 'postgres':
            return _postgres_store(config, store_url)  # type: ignore
        raise NotImplementedError('Only postgres URLs are currently supported.')

LOG.error('Unknown store type "%s"', store_type)
    return None

def _postgres_store(config: Config, store_url: str = None) -> PostgresStore:
    if not store_url:
        url_parts = {
            var: config.get('store.%s' % var, None) for var in
            ['port', 'database', 'schema', 'username', 'password', 'lock_timeout']
        }
        url_parts['hostname'] = config.get('store.server')
        store_url = postgres_url(**url_parts)
    return PostgresStore(
        config.get('store.name'),
        store_url)

def _ext4_store(config: Config) -> LinuxExt4Store:
    return LinuxExt4Store(
        config.get('store.name'),
        config.get('store.path'),
        safe_to_reconnect_to_path=True,
        file_owner=config.get('service_user'),
        file_group=config.get('service_group'))

def _win_store(config: Config) -> WindowsStore:
    return WindowsStore(
        config.get('store.name'),
        config.get('store.path'),
        safe_to_reconnect_to_path=True,
        all_access_user=config.get('service_user'),
    )

class JobStatus:
    QUEUED = 'QUEUED'
    RUNNING = 'RUNNING'
    COMPLETE = 'COMPLETE'
    BOTCHED = 'BOTCHED'  # Errors due to bugs or other permanent error conditions. Not retryable.
    MISFORTUNE = 'MISFORTUNE'  # Processing failures due to the environment. Retryable.