Python register_type Exemples

Exemple #1

    def __init__(self, url, auth=None, workers=20, agent_id=None,
                 queue_depth=Config.queue_depth()):
        if url.endswith("/schemas"):
            url = url[0:len(url)-len("/schemas")]
        self._url = url + "/subscribe"
        self._auth = auth
        self._workers = int(workers)
        self._children = []
        self._agent_id = agent_id
        self._queue = Queue(queue_depth)
        self._ping_queue = Queue(queue_depth)

        type_manager.register_type(type_manager.PUBLISHER,
                                   Publisher(url + "/publish", auth))

Exemple #2

from cattle.type_manager import register_type, LIFECYCLE

from .host_api import HostApi

register_type(LIFECYCLE, HostApi())

Exemple #3

from cattle.type_manager import register_type, LIFECYCLE
from .cadvisor import Cadvisor

register_type(LIFECYCLE, Cadvisor())

Exemple #4

Fichier : __init__.py Projet : m4ce/python-agent

try:
    from docker import Client
except:
    log.info('Disabling docker, docker-py not found')
    _ENABLED = False

try:
    if _ENABLED:
        docker_client().info()
except Exception, e:
    log.exception('Disabling docker, could not contact docker')
    _ENABLED = False

if _ENABLED and DockerConfig.docker_enabled():
    from .storage import DockerPool
    from .compute import DockerCompute
    from .delegate import DockerDelegate
    from cattle import type_manager

    _DOCKER_POOL = DockerPool()
    _DOCKER_COMPUTE = DockerCompute()
    _DOCKER_DELEGATE = DockerDelegate()
    type_manager.register_type(type_manager.STORAGE_DRIVER, _DOCKER_POOL)
    type_manager.register_type(type_manager.COMPUTE_DRIVER, _DOCKER_COMPUTE)
    type_manager.register_type(type_manager.PRE_REQUEST_HANDLER,
                               _DOCKER_DELEGATE)

if not _ENABLED and DockerConfig.docker_required():
    raise Exception('Failed to initialize Docker')

Exemple #5

Fichier : __init__.py Projet : th3architect/cattle

    log.info('Failed to find libvirt python')
    pass

LIBVIRT_KIND = 'libvirt'
LIBVIRT_COMPUTE_LISTENER = 'libvirt_compute_listener'

if _ENABLED:
    from cattle.type_manager import register_type
    from cattle.type_manager import COMPUTE_DRIVER, STORAGE_DRIVER, LIFECYCLE

    from .storage import LibvirtStorage
    from .compute import LibvirtCompute
    from .utils import *  # NOQA

    _LIBVIRT_COMPUTE = LibvirtCompute()
    register_type(COMPUTE_DRIVER, _LIBVIRT_COMPUTE)
    register_type(LIFECYCLE, _LIBVIRT_COMPUTE)
    register_type(STORAGE_DRIVER, LibvirtStorage())
    log.info('Enabling libvirt')
else:
    from .config import LibvirtConfig
    if LibvirtConfig.libvirt_required():
        raise Exception('Failed to initialize libvirt')
    else:
        log.info('Disabling libvirt')

from qemu_img import QemuImg  # NOQA


def enabled():
    return _ENABLED

Exemple #6

Fichier : __init__.py Projet : th3architect/cattle

        docker_client().info()
except Exception, e:
    log.exception('Disabling docker, could not contact docker')
    _ENABLED = False

if _ENABLED and DockerConfig.docker_enabled():
    from .storage import DockerPool
    from .compute import DockerCompute
    from .network.setup import NetworkSetup
    from .network.links import LinkSetup
    from .network.ipsec_tunnel import IpsecTunnelSetup
    from .network.ports import PortSetup
    from .delegate import DockerDelegate
    from cattle import type_manager

    _DOCKER_POOL = DockerPool()
    _DOCKER_COMPUTE = DockerCompute()
    _DOCKER_DELEGATE = DockerDelegate()
    type_manager.register_type(type_manager.STORAGE_DRIVER, _DOCKER_POOL)
    type_manager.register_type(type_manager.COMPUTE_DRIVER, _DOCKER_COMPUTE)
    type_manager.register_type(DOCKER_COMPUTE_LISTENER, _DOCKER_DELEGATE)
    type_manager.register_type(DOCKER_COMPUTE_LISTENER, NetworkSetup())
    type_manager.register_type(DOCKER_COMPUTE_LISTENER, LinkSetup())
    type_manager.register_type(DOCKER_COMPUTE_LISTENER, IpsecTunnelSetup())
    type_manager.register_type(DOCKER_COMPUTE_LISTENER, PortSetup())
    type_manager.register_type(type_manager.PRE_REQUEST_HANDLER,
                               _DOCKER_DELEGATE)

if not _ENABLED and DockerConfig.docker_required():
    raise Exception('Failed to initialize Docker')

Exemple #7

from cattle.type_manager import register_type
from cattle.plugins.libvirt import enabled, LIBVIRT_COMPUTE_LISTENER
from cattle.plugins.libvirt.config import LibvirtConfig
from cattle.utils import get_command_output

from listener import ConfigDriveComputeListener

import logging

log = logging.getLogger('libvirt-config-drive')

if enabled():
    try:
        get_command_output([LibvirtConfig.genisoimage(), '--version'])
        log.info('Enabling config drive support')
        register_type(LIBVIRT_COMPUTE_LISTENER, ConfigDriveComputeListener())
    except:
        log.info('genisoimage not found, disabling config drive support')

Exemple #8

Fichier : docker_common.py Projet : timbutler/python-agent

def responses():
    r = ResponseHolder()
    type_manager.register_type(type_manager.PUBLISHER, r)
    return r

Exemple #9

Fichier : utils.py Projet : th3architect/cattle

def register_pool_driver(driver):
    register_type(_LIBVIRT_POOL_DRIVER, driver)

Exemple #10

Fichier : utils.py Projet : th3architect/cattle

def register_volume_driver(driver):
    register_type(_LIBVIRT_VOLUME_DRIVER, driver)

Exemple #11

Fichier : utils.py Projet : assimilator101/cattle

def register_pool_driver(driver):
    register_type(_LIBVIRT_POOL_DRIVER, driver)

Exemple #12

Fichier : utils.py Projet : assimilator101/cattle

def register_volume_driver(driver):
    register_type(_LIBVIRT_VOLUME_DRIVER, driver)

Exemple #13

Fichier : __init__.py Projet : dx9/python-agent

from cattle.type_manager import register_type, LIFECYCLE, REQUEST_HANDLER

from .volmgr import Volmgr
from .handler import SnapshotHandler

register_type(LIFECYCLE, Volmgr())
register_type(REQUEST_HANDLER, SnapshotHandler())

Exemple #14

        self._do_cleanup()

        t = Thread(target=self.cleanup)
        t.setDaemon(True)
        t.start()

        LibvirtConfig.set_console_enabled(True)


if LibvirtConfig.websockify_enabled() and enabled():
    if Config.is_eventlet():
        try:
            import websockify
            from websockify import ProxyRequestHandler
            from cattle.plugins.libvirt.compute import LibvirtCompute
            ws = WebsockifyProxy()
            register_type(LIFECYCLE, ws)
            register_type(REQUEST_HANDLER, ws)

            class RequestHandler(ProxyRequestHandler):
                def new_websocket_client(self):
                    if Config.is_eventlet():
                        from eventlet import hubs
                        hubs.use_hub()

                    return ProxyRequestHandler.new_websocket_client(self)
        except:
            log.exception('Not starting websocket proxy for VNC')
    else:
        log.error('Can only run websocket proxy for VNC with eventlets')

Exemple #15

Fichier : __init__.py Projet : cloudnautique/python-agent

from cattle.type_manager import register_type, LIFECYCLE

from .console_agent import ConsoleAgent

register_type(LIFECYCLE, ConsoleAgent())

Exemple #16

Fichier : docker_common.py Projet : m4ce/python-agent

def responses():
    r = ResponseHolder()
    type_manager.register_type(type_manager.PUBLISHER, r)
    return r

Exemple #17

from cattle.type_manager import register_type, LIFECYCLE
from .conntrack import Conntrack

register_type(LIFECYCLE, Conntrack())

Exemple #18

Fichier : __init__.py Projet : th3architect/cattle

import marshaller
import event_router
import event_handlers
import api_proxy
from cattle.type_manager import register_type, MARSHALLER, ROUTER
from cattle.type_manager import POST_REQUEST_HANDLER, LIFECYCLE

register_type(MARSHALLER, marshaller.Marshaller())
register_type(ROUTER, event_router.Router())
register_type(POST_REQUEST_HANDLER, event_handlers.PingHandler())
register_type(POST_REQUEST_HANDLER, event_handlers.ConfigUpdateHandler())
register_type(LIFECYCLE, api_proxy.ApiProxy())

Exemple #19

Fichier : __init__.py Projet : assimilator101/cattle

        docker_client().info()
except Exception, e:
    log.exception('Disabling docker, could not contact docker')
    _ENABLED = False

if _ENABLED and DockerConfig.docker_enabled():
    from .storage import DockerPool
    from .compute import DockerCompute
    from .network.setup import NetworkSetup
    from .network.links import LinkSetup
    from .network.ipsec_tunnel import IpsecTunnelSetup
    from .network.ports import PortSetup
    from .delegate import DockerDelegate
    from cattle import type_manager

    _DOCKER_POOL = DockerPool()
    _DOCKER_COMPUTE = DockerCompute()
    _DOCKER_DELEGATE = DockerDelegate()
    type_manager.register_type(type_manager.STORAGE_DRIVER, _DOCKER_POOL)
    type_manager.register_type(type_manager.COMPUTE_DRIVER, _DOCKER_COMPUTE)
    type_manager.register_type(DOCKER_COMPUTE_LISTENER, _DOCKER_DELEGATE)
    type_manager.register_type(DOCKER_COMPUTE_LISTENER, NetworkSetup())
    type_manager.register_type(DOCKER_COMPUTE_LISTENER, LinkSetup())
    type_manager.register_type(DOCKER_COMPUTE_LISTENER, IpsecTunnelSetup())
    type_manager.register_type(DOCKER_COMPUTE_LISTENER, PortSetup())
    type_manager.register_type(type_manager.PRE_REQUEST_HANDLER,
                               _DOCKER_DELEGATE)

if not _ENABLED and DockerConfig.docker_required():
    raise Exception('Failed to initialize Docker')

Exemple #20

Fichier : __init__.py Projet : assimilator101/cattle

from cattle.type_manager import register_type
from cattle.plugins.libvirt import enabled, LIBVIRT_COMPUTE_LISTENER
from cattle.plugins.libvirt.config import LibvirtConfig
from cattle.utils import get_command_output

from listener import ConfigDriveComputeListener

import logging

log = logging.getLogger('libvirt-config-drive')


if enabled():
    try:
        get_command_output([LibvirtConfig.genisoimage(), '--version'])
        log.info('Enabling config drive support')
        register_type(LIBVIRT_COMPUTE_LISTENER, ConfigDriveComputeListener())
    except:
        log.info('genisoimage not found, disabling config drive support')