def load_module(self, fullname):
if fullname in sys.modules:
return sys.modules[fullname]
self._loading.add(fullname)
try:
mod = sys.modules[fullname] = patcher.import_patched(fullname)
return mod
finally:
self._loading.remove(fullname)
def load_module(self, fullname):
if fullname in sys.modules:
return sys.modules[fullname]
self._loading.add(fullname)
try:
mod = sys.modules[fullname] = patcher.import_patched(fullname)
return mod
finally:
self._loading.remove(fullname)
def import_patched(module_name):
# Import cycle note: it's crucial to use _socket_nodns here because
# regular evenlet.green.socket imports *this* module and if we imported
# it back we'd end with an import cycle (socket -> greendns -> socket).
# We break this import cycle by providing a restricted socket module.
return patcher.import_patched(module_name,
select=select,
time=time,
os=os,
socket=_socket_nodns)
def _patch():
from eventlet import patcher
from eventlet.green import select
from eventlet.green import socket
from eventlet.green import threading
from eventlet.green import time
protocol = patcher.import_patched('pg8000.interface',
socket=socket,
threading=threading)
interface = patcher.import_patched('pg8000.protocol',
protocol=protocol,
socket=socket,
select=select,
threading=threading)
return patcher.import_patched('pg8000.dbapi',
time=time,
interface=interface,
threading=threading)
def import_patched(module_name):
# Import cycle note: it's crucial to use _socket_nodns here because
# regular evenlet.green.socket imports *this* module and if we imported
# it back we'd end with an import cycle (socket -> greendns -> socket).
# We break this import cycle by providing a restricted socket module.
modules = {
'select': select,
'time': time,
'os': os,
'socket': _socket_nodns,
}
return patcher.import_patched(module_name, **modules)
def import_patched(module_name):
# Import cycle note: it's crucial to use _socket_nodns here because
# regular evenlet.green.socket imports *this* module and if we imported
# it back we'd end with an import cycle (socket -> greendns -> socket).
# We break this import cycle by providing a restricted socket module.
modules = {
'select': select,
'time': time,
'os': os,
'socket': _socket_nodns,
}
return patcher.import_patched(module_name, **modules)
# 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.
import collections
import socket
import time
from eventlet import patcher
from murano.common.messaging import message
kombu = patcher.import_patched('kombu')
class Subscription(object):
def __init__(self, connection, queue, prefetch_count=1):
self._buffer = collections.deque()
self._connection = connection
self._queue = kombu.Queue(name=queue, exchange=None)
self._consumer = kombu.Consumer(self._connection, auto_declare=False)
self._consumer.register_callback(self._receive)
self._consumer.qos(prefetch_count=prefetch_count)
def __enter__(self):
self._consumer.add_queue(self._queue)
self._consumer.consume()
return self
import logging
import socket
from urllib import quote
from eventlet import patcher
from eventlet.green.httplib import HTTPConnection, HTTPResponse, _UNKNOWN, \
CONTINUE, HTTPMessage
from oio.common.utils import json
requests = patcher.import_patched('requests.__init__')
class CustomHTTPResponse(HTTPResponse):
def __init__(self, sock, debuglevel=0, strict=0, method=None):
self.sock = sock
self._actual_socket = sock.fd._sock
self.fp = sock.makefile('rb')
self.debuglevel = debuglevel
self.strict = strict
self._method = method
self.msg = None
self.version = _UNKNOWN
self.status = _UNKNOWN
self.reason = _UNKNOWN
self.chunked = _UNKNOWN
self.chunk_left = _UNKNOWN
self.length = _UNKNOWN
self.will_close = _UNKNOWN
from collections import namedtuple
from eventlet import patcher
amqplib = patcher.import_patched('amqplib.client_0_8')
EXCHANGE='processes'
HOST = 'localhost'
RoutingKey = namedtuple('RoutingKey', 'host supervisor_id process_name event_type')
def create_routing_key(host='*', supervisor_id='*', process_name='*', event_type='*'):
return "%s.%s.%s.%s" % (host.replace('.','|'), supervisor_id, process_name, event_type)
def deserialize_routing_key(routing_key):
replace_star = lambda p: None if p == '*' else p
parts = [replace_star(p) for p in routing_key.split('.')]
host = parts[0]
if host:
parts[0] = host.replace('|', '.')
return RoutingKey(*parts)
def connect_to_amqp(hostname=HOST, exchange=EXCHANGE, durable=True, auto_delete=False):
conn = amqplib.Connection(hostname, userid='guest', password='******', ssl=False, insist=True)
ch = conn.channel()
ch.access_request('/data', active=True, read=True)
ch.exchange_declare(exchange, 'topic', durable=durable, auto_delete=auto_delete)
return ch
from zope.event import notify
from zope.interface import implements
from unittest import TestCase
from multivisor.interfaces import IWebsocketUpgradeRequest
from multivisor.server.factory import server_factory
from multivisor.server.websocket import WebSocketView, WebSocket
#from repoze.debug.responselogger import ResponseLoggingMiddleware
from logging import getLogger
import logging
import mock
import random
httplib2 = patcher.import_patched('httplib2')
class EchoWebsocket(WebSocketView):
def handle_websocket(self, ws):
self._ws = ws
return super(EchoWebsocket, self).handle_websocket(ws)
def handler(self, ws):
while True:
m = ws.wait()
# import ipdb; ipdb.set_trace()
if m is None:
break
ws.send('%s says %s' % (ws.origin, m))
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
import struct
from eventlet import patcher
from eventlet.green import _socket_nodns
from eventlet.green import os
from eventlet.green import time
from eventlet.support import six
dns = patcher.import_patched('dns')
dns.resolver = patcher.import_patched('dns.resolver')
for pkg in ('dns.entropy', 'dns.inet', 'dns.query'):
setattr(dns, pkg.split('.')[1], patcher.import_patched(pkg))
import dns.rdtypes
for pkg in ['dns.rdtypes.IN', 'dns.rdtypes.ANY']:
setattr(dns.rdtypes, pkg.split('.')[-1], patcher.import_patched(pkg))
for pkg in ['dns.rdtypes.IN.A', 'dns.rdtypes.IN.AAAA']:
setattr(dns.rdtypes.IN, pkg.split('.')[-1], patcher.import_patched(pkg))
for pkg in ['dns.rdtypes.ANY.CNAME']:
setattr(dns.rdtypes.ANY, pkg.split('.')[-1], patcher.import_patched(pkg))
socket = _socket_nodns
DNS_QUERY_TIMEOUT = 10.0
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
import struct
import sys
from eventlet import patcher
from eventlet.green import _socket_nodns
from eventlet.green import time
from eventlet.green import select
dns = patcher.import_patched('dns',
socket=_socket_nodns,
time=time,
select=select)
for pkg in ('dns.query', 'dns.exception', 'dns.inet', 'dns.message',
'dns.rdatatype', 'dns.resolver', 'dns.reversename'):
setattr(
dns,
pkg.split('.')[1],
patcher.import_patched(pkg,
socket=_socket_nodns,
time=time,
select=select))
socket = _socket_nodns
DNS_QUERY_TIMEOUT = 10.0
# 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.
import anyjson
import logging
import ssl as ssl_module
from eventlet import patcher
kombu = patcher.import_patched("kombu")
from subscription import Subscription
log = logging.getLogger("murano-common.messaging")
class MqClient(object):
def __init__(self, login, password, host, port, virtual_host, ssl=False, ca_certs=None):
ssl_params = None
if ssl is True:
ssl_params = {"ca_certs": ca_certs, "cert_reqs": ssl_module.CERT_REQUIRED}
self._connection = kombu.Connection(
"amqp://{0}:{1}@{2}:{3}/{4}".format(login, password, host, port, virtual_host), ssl=ssl_params
#
# This content is made available according to terms specified in
# License.zenoss under the directory where your Zenoss product is installed.
#
##############################################################################
import zlib
import logging
from zope.component import getAdapter
from zenoss.protocols import hydrateQueueMessage
from zenoss.protocols.interfaces import IAMQPChannelAdapter
from zenoss.protocols.queueschema import SchemaException
from zenoss.protocols.exceptions import ChannelClosedError
from eventlet import patcher
from eventlet.green import socket
amqp = patcher.import_patched('amqplib.client_0_8')
import eventlet
from ..amqp import set_keepalive
DELIVERY_NONPERSISTENT = 1
DELIVERY_PERSISTENT = 2
# basic_qos parameters
UNLIMITED_MESSAGE_SIZE = 0
MESSAGES_PER_WORKER = 1
GLOBAL_QOS = False
__doc__ = """
An eventlet based AMQP publisher/subscriber (consumer).
"""
import logging
import re
import socket
from urllib import quote
from eventlet import patcher
from eventlet.green.httplib import HTTPConnection, HTTPResponse, _UNKNOWN, \
CONTINUE, HTTPMessage
from oio.common.utils import json
requests = patcher.import_patched('requests.__init__')
class CustomHTTPResponse(HTTPResponse):
def __init__(self, sock, debuglevel=0, strict=0,
method=None):
self.sock = sock
self._actual_socket = sock.fd._sock
self.fp = sock.makefile('rb')
self.debuglevel = debuglevel
self.strict = strict
self._method = method
self.msg = None
self.version = _UNKNOWN
self.status = _UNKNOWN
self.reason = _UNKNOWN
self.chunked = _UNKNOWN
self.chunk_left = _UNKNOWN
self.length = _UNKNOWN
import logging
import re
import socket
from urllib import quote, quote_plus
from eventlet import patcher
from eventlet.green.httplib import HTTPConnection, HTTPResponse, _UNKNOWN, \
CONTINUE, HTTPMessage
from oio.common.utils import json
from oio.common.constants import chunk_headers
requests = patcher.import_patched('requests.__init__')
requests_adapters = patcher.import_patched('requests.adapters')
CONNECTION_TIMEOUT = 2.0
READ_TIMEOUT = 30.0
class CustomHTTPResponse(HTTPResponse):
def __init__(self, sock, debuglevel=0, strict=0, method=None):
self.sock = sock
self._actual_socket = sock.fd._sock
self.fp = sock.makefile('rb')
self.debuglevel = debuglevel
self.strict = strict
self._method = method
self.msg = None
self.version = _UNKNOWN
self.status = _UNKNOWN
from eventlet import patcher
from multivisor.amqp import (connect_to_amqp, EXCHANGE, amqplib,
create_routing_key)
from json import dumps
from pprint import pformat
import baker
import psutil
import socket
import sys
import os
childutils = patcher.import_patched('supervisor.childutils')
#logging.basicConfig(filename='/tmp/listener.log', level=logging.INFO)
HOST = socket.gethostname()
class WrongEventType(TypeError):
"""Raised by :class:`EventParser` trying to process the wrong event"""
class EventParser(object):
"""Base class for handling supervisor events"""
#: The event type being listened to
EVENT_NAME = 'EVENT'
#: A :class:`supervisor.childutils.EventListenerProtocol` instance
PROTOCOL = childutils.EventListenerProtocol()
#: The ``delivery_mode`` of messages (1 == Non persistent)
DELIVERY_MODE = 1
# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
from eventlet import patcher
from eventlet.green import _socket_nodns
from eventlet.green import time
from eventlet.green import select
dns = patcher.import_patched('dns',
socket=_socket_nodns,
time=time,
select=select)
for pkg in ('dns.query', 'dns.exception', 'dns.inet', 'dns.message',
'dns.rdatatype','dns.resolver', 'dns.reversename'):
setattr(dns, pkg.split('.')[1], patcher.import_patched(pkg,
socket=_socket_nodns,
time=time,
select=select))
socket = _socket_nodns
DNS_QUERY_TIMEOUT = 10.0
#
# Resolver instance used to perfrom DNS lookups.
#
# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
import struct
from eventlet import patcher
from eventlet.green import _socket_nodns
from eventlet.green import os
from eventlet.green import time
from eventlet.green import select
from eventlet.support import six
dns = patcher.import_patched('dns',
select=select,
time=time,
os=os,
socket=_socket_nodns)
dns.resolver = patcher.import_patched('dns.resolver',
select=select,
time=time,
os=os,
socket=_socket_nodns)
for pkg in ('dns.entropy', 'dns.inet', 'dns.query'):
setattr(dns, pkg.split('.')[1], patcher.import_patched(pkg,
select=select,
time=time,
os=os,
socket=_socket_nodns))
import dns.rdtypes
# 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.
import anyjson
import ssl as ssl_module
from eventlet import patcher
kombu = patcher.import_patched('kombu')
from subscription import Subscription
class MqClient(object):
def __init__(self, login, password, host, port, virtual_host,
ssl=False, ca_certs=None):
ssl_params = None
if ssl is True:
ssl_params = {
'ca_certs': ca_certs,
'cert_reqs': ssl_module.CERT_REQUIRED
}
self._connection = kombu.Connection(
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library.
import logging
import re
import socket
from urllib import quote, quote_plus
from eventlet import patcher
from eventlet.green.httplib import HTTPConnection, HTTPResponse, _UNKNOWN, \
CONTINUE, HTTPMessage
from oio.common.constants import chunk_headers
urllib3 = patcher.import_patched('urllib3.__init__')
CONNECTION_TIMEOUT = 2.0
READ_TIMEOUT = 30.0
DEFAULT_POOLSIZE = 32
DEFAULT_RETRIES = 0
class CustomHTTPResponse(HTTPResponse):
def __init__(self, sock, debuglevel=0, strict=0, method=None):
self.sock = sock
self._actual_socket = sock.fd._sock
self.fp = sock.makefile('rb')
self.debuglevel = debuglevel
self.strict = strict
