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}