def __init__(self, name, app, host='0.0.0.0', port=0, pool_size=None, protocol=eventlet.wsgi.HttpProtocol, backlog=128, use_ssl=False, max_url_len=None): """Initialize, but do not start, a WSGI server. :param name: Pretty name for logging. :param app: The WSGI application to serve. :param host: IP address to serve the application. :param port: Port number to server the application. :param pool_size: Maximum number of eventlets to spawn concurrently. :param backlog: Maximum number of queued connections. :param max_url_len: Maximum length of permitted URLs. :returns: None :raises: wormhole.exception.InvalidInput """ # Allow operators to customize http requests max header line size. eventlet.wsgi.MAX_HEADER_LINE = CONF.max_header_line self.name = name self.app = app self._server = None self._protocol = protocol self.pool_size = pool_size or self.default_pool_size self._pool = eventlet.GreenPool(self.pool_size) self._logger = logging.getLogger("wormhole.%s.wsgi.server" % self.name) self._wsgi_logger = logging.WritableLogger(self._logger) self._use_ssl = use_ssl self._max_url_len = max_url_len self.client_socket_timeout = CONF.client_socket_timeout or None if backlog < 1: raise exception.InvalidInput( reason='The backlog must be more than 1') bind_addr = (host, port) # TODO(dims): eventlet's green dns/socket module does not actually # support IPv6 in getaddrinfo(). We need to get around this in the # future or monitor upstream for a fix try: info = socket.getaddrinfo(bind_addr[0], bind_addr[1], socket.AF_UNSPEC, socket.SOCK_STREAM)[0] family = info[0] bind_addr = info[-1] except Exception: family = socket.AF_INET try: self._socket = eventlet.listen(bind_addr, family, backlog=backlog) except EnvironmentError: LOG.error(_("Could not bind to %(host)s:%(port)s"), {'host': host, 'port': port}) raise (self.host, self.port) = self._socket.getsockname()[0:2] LOG.info(_("%(name)s listening on %(host)s:%(port)s"), {'name': self.name, 'host': self.host, 'port': self.port})
from wormhole import exception from wormhole import wsgi from wormhole.tasks import addtask from wormhole.common import utils from wormhole.common import units from oslo.config import cfg from wormhole.common import log from wormhole.i18n import _ import functools import uuid import os CONF = cfg.CONF LOG = log.getLogger(__name__) volume_opts = [ cfg.StrOpt('volume_dd_blocksize', default='1M', help='The default block size used when copying volume'), ] CONF.register_opts(volume_opts) CONF.import_opt('container_volume_link_dir', 'wormhole.container') def volume_link_path(volume_id): return os.path.sep.join([CONF.get('container_volume_link_dir'), volume_id]) class VolumeController(wsgi.Application):
from wormhole.common import timeutils from wormhole.common import log as logging from oslo.config import cfg CONF = cfg.CONF utils_opt = [ cfg.BoolOpt('fake_execute', default=False, help='If passed, use fake network devices and addresses'), ] CONF.register_opts(utils_opt) LOG = logging.getLogger(__name__) class UndoManager(object): """Provides a mechanism to facilitate rolling back a series of actions when an exception is raised. """ def __init__(self): self.undo_stack = [] def undo_with(self, undo_func): self.undo_stack.append(undo_func) def _rollback(self): for undo_func in reversed(self.undo_stack): undo_func()