def setup(self):
self.test_id = uuid4()
self.broker = self.config.broker
try:
self.conn = self.setup_connection()
except ConnectError, e:
raise Skipped(e)
def __init__(self, url, domain="org.clacks", xquery=".", callback=None):
# Build connection
url = parseURL(url)
_url = "%s:%s" % (url['host'], url['port'])
self.__conn = Connection.establish(_url, reconnect=True,
username=url['user'],
password=url['password'],
transport=url['transport'],
reconnect_interval=3,
reconnect_limit=0)
# Do automatic broker failover if requested
#TODO: configure reconnect
#auto_fetch_reconnect_urls(self.__conn)
# Assemble subscription query
queue = 'event-listener-%s' % uuid4()
address = """%s; {
create: always,
delete:always,
node: {
durable: False,
x-declare: {
exclusive: True,
auto-delete: True }
},
link: {
x-bindings: [
{
exchange: '%s',
queue: %s,
key: event,
arguments: { xquery: %r}
}
]
}
}""" % (queue, domain, queue, xquery)
# Add processor for core.event queue
self.__callback = callback
self.__eventWorker = AMQPStandaloneWorker(
self.__conn,
r_address=address,
workers=1,
callback=self.__eventProcessor)
def start(self):
"""
Enable AMQP queueing. This method puts up the event processor and
sets it to "active".
"""
self.log.debug("enabling AMQP queueing")
# Evaluate username
user = self.config.get("amqp.id", default=None)
if not user:
user = self.env.uuid
password = self.config.get("amqp.key")
# Create initial broker connection
url = "%s:%s" % (self.url['host'], self.url['port'])
self._conn = Connection.establish(url, reconnect=self.reconnect,
username=user,
password=password,
transport=self.url['transport'],
reconnect_interval=self.reconnect_interval,
reconnect_limit=self.reconnect_limit)
# Do automatic broker failover if requested
if self.config.get('amqp.failover', False):
auto_fetch_reconnect_urls(self._conn)
# Create event exchange
socket = connect(self.url['host'], self.url['port'])
if self.url['scheme'][-1] == 's':
socket = ssl(socket)
user = self.config.get("amqp.id", default=None)
if not user:
user = self.env.uuid
connection = DirectConnection(sock=socket,
username=user,
password=self.config.get("amqp.key"))
connection.start()
session = connection.session(str(uuid4()))
# pylint: disable=E1103
session.exchange_declare(exchange=self.env.domain, type="xml")
connection.close()
# Create event provider
self._eventProvider = EventProvider(self.env, self.getConnection())
def __init__(self, url, domain="org.gosa", xquery=".", callback=None):
# Build connection
url = parseURL(url)
self.__conn = Connection(url['url'], transport=url['transport'], reconnect=True)
self.__conn.open()
# Assemble subscription query
queue = 'event-listener-%s' % uuid4()
address = """%s; {
create: always,
delete:always,
node: {
durable: False,
x-declare: {
exclusive: True,
auto-delete: True }
},
link: {
x-bindings: [
{
exchange: '%s',
queue: %s,
key: event,
arguments: { xquery: %r}
}
]
}
}""" % (queue, domain, queue, xquery)
# Add processor for core.event queue
self.__callback = callback
self.__eventWorker = AMQPStandaloneWorker(
self.__conn,
r_address=address,
workers=1,
callback=self.__eventProcessor)
def __init__(self, env, conn, xquery=".", callback=None):
self.env = env
self.log = logging.getLogger(__name__)
# Assemble subscription query
queue = 'event-listener-%s' % uuid4()
address = """%s; {
create: always,
delete:always,
node: {
durable: False,
x-declare: {
exclusive: True,
auto-delete: True }
},
link: {
x-bindings: [
{
exchange: '%s',
queue: %s,
key: event,
arguments: { xquery: %r}
}
]
}
}""" % (queue, self.env.domain, queue, xquery)
# Get session and create worker
self.__sess = conn.session()
# Add processor for core.event queue
self.__callback = callback
self.__eventWorker = AMQPWorker(self.env, connection=conn,
r_address=address,
workers=1,
callback=self.__eventProcessor)
def _uuid():
"""
Return an UUID
"""
return str(messaging.uuid4())
def _uuid():
"""
Return an UUID
"""
return str(messaging.uuid4())
def joinClient(self, user, device_uuid, mac, info=None):
"""
TODO
"""
uuid_check = re.compile(r"^[0-9a-f]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$", re.IGNORECASE)
if not uuid_check.match(device_uuid):
raise ValueError("join with invalid UUID %s" % device_uuid)
lh = LDAPHandler.get_instance()
# Handle info, if present
more_info = []
if info:
# Check string entries
for entry in filter(lambda x: x in info,
["serialNumber", "ou", "o", "l", "description"]):
if not re.match(r"^[\w\s]+$", info[entry]):
raise ValueError("invalid data (%s) provided for '%s'" % (info[entry], entry))
more_info.append((entry, info[entry]))
# Check desired device type if set
if "deviceType" in info:
if re.match(r"^(terminal|workstation|server|sipphone|switch|router|printer|scanner)$",
info["deviceType"]):
more_info.append(("deviceType", info["deviceType"]))
else:
raise ValueError("invalid device type '%s' specified" % info["deviceType"])
# Check owner for presence
if "owner" in info:
with lh.get_handle() as conn:
# Take a look at the directory to see if there's
# such an owner DN
try:
conn.search_s(info["owner"], ldap.SCOPE_BASE, attrlist=['dn'])
more_info.append(("owner", info["owner"]))
except Exception as e:
raise ValueError("owner %s not found: %s" % (info["owner"], str(e)))
# Generate random client key
random.seed()
key = ''.join(random.Random().sample(string.letters + string.digits, 32))
salt = os.urandom(4)
h = hashlib.sha1(key)
h.update(salt)
# Do LDAP operations to add the system
with lh.get_handle() as conn:
# Take a look at the directory to see if there's
# already a joined client with this uuid
res = conn.search_s(lh.get_base(), ldap.SCOPE_SUBTREE,
"(&(objectClass=registeredDevice)(macAddress=%s))" % mac, ["macAddress"])
# Already registered?
if res:
raise Exception("device with hardware address %s has already been joined" % mac)
# While the client is going to be joined, generate a random uuid and
# an encoded join key
cn = str(uuid4())
device_key = self.__encrypt_key(device_uuid.replace("-", ""), cn + key)
# Resolve manger
res = conn.search_s(lh.get_base(), ldap.SCOPE_SUBTREE,
"(uid=%s)" % user, [])
if len(res) != 1:
raise Exception("failed to get current users DN: %s" %
("not unique" if res else "not found"))
manager = res[0][0]
# Create new machine entry
record = [
('objectclass', ['device', 'ieee802Device', 'simpleSecurityObject', 'registeredDevice']),
('deviceUUID', cn),
('deviceKey', [device_key]),
('cn', [cn] ),
('manager', [manager] ),
('macAddress', [mac.encode("ascii", "ignore")] ),
('userPassword', ["{SSHA}" + encode(h.digest() + salt)])
]
record += more_info
# Evaluate base
#TODO: take hint from "info" parameter, to allow "joiner" to provide
# a target base
base = lh.get_base()
# Add record
dn = ",".join(["cn=" + cn, self.env.config.get("goto.machine-rdn",
default="ou=systems"), base])
conn.add_s(dn, record)
self.log.info("UUID '%s' joined as %s" % (device_uuid, dn))
return [key, cn]
def __init__(self, serviceURL, serviceAddress=None, serviceName=None,
conn=None, worker=None, methods=None):
self.__URL = url = parseURL(serviceURL)
self.__serviceURL = serviceURL
self.__serviceName = serviceName
self.__serviceAddress = serviceAddress
self.__worker = worker
self.__domain = url['path']
self.__methods = methods
# Prepare AMQP connection if not already there
if not conn:
_url = "%s:%s" % (url['host'], url['port'])
conn = Connection.establish(_url, reconnect=True,
username=url['user'],
password=url['password'],
transport=url['transport'],
reconnect_interval=3,
reconnect_limit=0)
#TODO: configure reconnect
#auto_fetch_reconnect_urls(conn)
# Prefill __serviceAddress correctly if domain is given
if self.__domain:
self.__serviceAddress = '%s.command.core' % self.__domain
if not self.__serviceAddress:
raise AMQPException("no serviceAddress or domain specified")
if not self.__worker:
self.__worker = {self.__serviceAddress: {}}
# Pre instanciate core sessions
for i in range(0, WORKERS):
ssn = conn.session(str(uuid4()))
self.__worker[self.__serviceAddress][i] = {
'ssn': ssn,
'sender': ssn.sender(self.__serviceAddress),
'receiver': ssn.receiver('reply-%s; {create:always, delete:always, node: { type: queue, durable: False, x-declare: { exclusive: False, auto-delete: True } }}' % ssn.name),
'locked': False}
# Store connection
self.__conn = conn
self.__ssn = None
self.__sender = None
self.__receiver = None
self.__sess = None
# Retrieve methods
if not self.__methods:
self.__serviceName = "getMethods"
self.__methods = self.__call__()
self.__serviceName = None
# If we've no direct queue, we need to push to different queues
if self.__domain:
queues = set([
x['target'] for x in self.__methods.itervalues()
if x['target'] != 'core'
])
# Pre instanciate queue sessions
for queue in queues:
for i in range(0, WORKERS):
ssn = conn.session(str(uuid4()))
self.__worker[queue] = {}
self.__worker[queue][i] = {
'ssn': ssn,
'sender': ssn.sender("%s.command.%s" %
(self.__domain, queue)),
'receiver': ssn.receiver('reply-%s; {create:always, delete:always, node: { type: queue, durable: False, x-declare: { exclusive: False, auto-delete: True } }}' % ssn.name),
'locked': False}
def __init__(self, serviceURL, serviceAddress=None, serviceName=None,
conn=None, workers=3):
self.__URL = url = parseURL(serviceURL)
self.__serviceURL = serviceURL
self.__serviceName = serviceName
self.__serviceAddress = serviceAddress
self.__workers = workers
domain = url['path']
# Prepare AMQP connection if not already there
if not conn:
conn = Connection(url['url'], transport=url['transport'], reconnect=True)
conn.open()
AMQPServiceProxy.domain= domain
# Prefill __serviceAddress correctly if domain is given
if AMQPServiceProxy.domain:
self.__serviceAddress = '%s.command.core' % AMQPServiceProxy.domain
if not self.__serviceAddress:
raise AMQPException("no serviceAddress or domain specified")
try:
AMQPServiceProxy.worker[self.__serviceAddress]
except KeyError:
AMQPServiceProxy.worker[self.__serviceAddress] = {}
# Pre instanciate core sessions
for i in range(0, workers):
ssn = conn.session(str(uuid4()))
AMQPServiceProxy.worker[self.__serviceAddress][i] = {
'ssn': ssn,
'sender': ssn.sender(self.__serviceAddress),
'receiver': ssn.receiver('reply-%s; {create:always, delete:always, node: { type: queue, durable: False, x-declare: { exclusive: False, auto-delete: True } }}' % ssn.name),
'locked': False}
# Store connection
self.__conn = conn
self.__ssn = None
self.__sender = None
self.__receiver = None
self.__worker = None
# Retrieve methods
try:
AMQPServiceProxy.methods
except AttributeError:
AMQPServiceProxy.methods = None
AMQPServiceProxy.methods = {}
# Retrieve methods
try:
AMQPServiceProxy.methods[self.__serviceAddress]
except KeyError:
AMQPServiceProxy.methods[self.__serviceAddress] = None
AMQPServiceProxy.methods[self.__serviceAddress] = self.getMethods()
# If we've no direct queue, we need to push to different queues
if AMQPServiceProxy.domain:
queues = set([
x['target'] for x in AMQPServiceProxy.methods[self.__serviceAddress].itervalues()
if x['target'] != 'core'
])
# Pre instanciate queue sessions
for queue in queues:
for i in range(0, workers):
ssn = conn.session(str(uuid4()))
AMQPServiceProxy.worker[queue] = {}
AMQPServiceProxy.worker[queue][i] = {
'ssn': ssn,
'sender': ssn.sender("%s.command.%s" %
(AMQPServiceProxy.domain, queue)),
'receiver': ssn.receiver('reply-%s; {create:always, delete:always, node: { type: queue, durable: False, x-declare: { exclusive: False, auto-delete: True } }}' % ssn.name),
'locked': False}
