def handle(self, *args, **kwargs): with closing(self.server.odb.session()) as session: payload = kwargs.get('payload') core_params = ['cluster_id', 'name', 'is_active', 'def_id', 'delivery_mode', 'priority'] core_params = _get_params(payload, core_params, 'data.') optional_params = ['expiration'] optional_params = _get_params(payload, optional_params, 'data.', default_value=None) priority = int(core_params['priority']) if not(priority >= 0 and priority <= 9): msg = 'Priority should be between 0 and 9, not [{0}]'.format(repr(priority)) raise ValueError(msg) name = core_params['name'] cluster_id = core_params['cluster_id'] core_params['def_id'] = int(core_params['def_id']) existing_one = session.query(OutgoingWMQ.id).\ filter(ConnDefWMQ.cluster_id==cluster_id).\ filter(OutgoingWMQ.def_id==ConnDefWMQ.id).\ filter(OutgoingWMQ.name==name).\ first() if existing_one: raise Exception('An outgoing JMS WebSphere MQ connection [{0}] already exists on this cluster'.format(name)) created_elem = Element('out_jms_wmq') try: core_params['delivery_mode'] = int(core_params['delivery_mode']) core_params['priority'] = int(core_params['priority']) core_params['is_active'] = is_boolean(core_params['is_active']) item = OutgoingWMQ() item.name = core_params['name'] item.is_active = core_params['is_active'] item.def_id = core_params['def_id'] item.delivery_mode = core_params['delivery_mode'] item.priority = core_params['priority'] item.expiration = optional_params['expiration'] session.add(item) session.commit() created_elem.id = item.id start_connector(self.server.repo_location, item.id, item.def_id) return ZATO_OK, etree.tostring(created_elem) except Exception, e: msg = 'Could not create an outgoing JMS WebSphere MQ connection, e=[{e}]'.format(e=format_exc(e)) self.logger.error(msg) session.rollback() raise
def handle(self, *args, **kwargs): params = _get_params(kwargs.get('payload'), ['cluster_id', 'connection', 'transport'], 'data.') with closing(self.server.odb.session()) as session: item_list = Element('item_list') db_items = http_soap_list(session, params['cluster_id'], params['connection'], params['transport']) for db_item in db_items: item = Element('item') item.id = db_item.id item.name = db_item.name item.is_active = db_item.is_active item.is_internal = db_item.is_internal item.url_path = db_item.url_path item.method = db_item.method item.soap_action = db_item.soap_action item.soap_version = db_item.soap_version item.service_id = db_item.service_id item.service_name = db_item.service_name item.security_id = db_item.security_id item.security_name = db_item.security_name item.security_def_type = db_item.security_def_type item_list.append(item) return ZATO_OK, etree.tostring(item_list)
def handle(self, *args, **kwargs): params = _get_params(kwargs.get('payload'), ['id', 'cluster_id'], 'data.') with closing(self.server.odb.session()) as session: definition = def_jms_wmq(session, params['cluster_id'], params['id']) definition_elem = Element('definition') definition_elem.id = definition.id definition_elem.name = definition.name definition_elem.host = definition.host definition_elem.port = definition.port definition_elem.queue_manager = definition.queue_manager definition_elem.channel = definition.channel definition_elem.cache_open_send_queues = definition.cache_open_send_queues definition_elem.cache_open_receive_queues = definition.cache_open_receive_queues definition_elem.use_shared_connections = definition.use_shared_connections definition_elem.ssl = definition.ssl definition_elem.ssl_cipher_spec = definition.ssl_cipher_spec definition_elem.ssl_key_repository = definition.ssl_key_repository definition_elem.needs_mcd = definition.needs_mcd definition_elem.max_chars_printed = definition.max_chars_printed return ZATO_OK, etree.tostring(definition_elem)
def handle(self, *args, **kwargs): with closing(self.server.odb.session()) as session: params = _get_params(kwargs.get('payload'), ['cluster_id'], 'data.') definition_list = Element('definition_list') definitions = job_list(session, params['cluster_id']) for definition in definitions: definition_elem = Element('definition') definition_elem.id = definition.id definition_elem.name = definition.name definition_elem.is_active = definition.is_active definition_elem.job_type = definition.job_type definition_elem.start_date = definition.start_date definition_elem.extra = definition.extra.decode('utf-8') definition_elem.service_id = definition.service_id definition_elem.service_name = definition.service_name.decode('utf-8') definition_elem.weeks = definition.weeks if definition.weeks else '' definition_elem.days = definition.days if definition.days else '' definition_elem.hours = definition.hours if definition.hours else '' definition_elem.minutes = definition.minutes if definition.minutes else '' definition_elem.seconds = definition.seconds if definition.seconds else '' definition_elem.repeats = definition.repeats if definition.repeats else '' definition_elem.cron_definition = (definition.cron_definition.decode('utf-8') if definition.cron_definition else '') definition_list.append(definition_elem) return ZATO_OK, etree.tostring(definition_list)
def handle(self, *args, **kwargs): params = _get_params(kwargs.get('payload'), ['cluster_id'], 'data.') with closing(self.server.odb.session()) as session: item_list = Element('item_list') db_items = out_amqp_list(session, params['cluster_id']) for db_item in db_items: item = Element('item') item.id = db_item.id item.name = db_item.name item.is_active = db_item.is_active item.delivery_mode = db_item.delivery_mode item.priority = db_item.priority item.content_type = db_item.content_type item.content_encoding = db_item.content_encoding item.expiration = db_item.expiration item.user_id = db_item.user_id item.app_id = db_item.app_id item.def_name = db_item.def_name item.def_id = db_item.def_id item_list.append(item) return ZATO_OK, etree.tostring(item_list)
def handle(self, *args, **kwargs): with closing(self.server.odb.session()) as session: payload = kwargs.get('payload') core_params = ['id', 'cluster_id', 'name', 'is_active', 'host', 'port', 'dircache'] core_params = _get_params(payload, core_params, 'data.') optional_params = ['user', 'acct', 'timeout'] optional_params = _get_params(payload, optional_params, 'data.', default_value=None) id = core_params['id'] name = core_params['name'] cluster_id = core_params['cluster_id'] existing_one = session.query(OutgoingFTP.id).\ filter(OutgoingFTP.cluster_id==cluster_id).\ filter(OutgoingFTP.name==name).\ filter(OutgoingFTP.id!=core_params['id']).\ first() if existing_one: raise Exception('An outgoing FTP connection [{0}] already exists on this cluster'.format(name)) xml_item = Element('out_ftp') try: core_params['id'] = int(core_params['id']) core_params['is_active'] = is_boolean(core_params['is_active']) core_params['dircache'] = is_boolean(core_params['dircache']) item = session.query(OutgoingFTP).filter_by(id=id).one() old_name = item.name item.name = core_params['name'] item.is_active = core_params['is_active'] item.cluster_id = core_params['cluster_id'] item.dircache = core_params['dircache'] item.host = core_params['host'] item.port = core_params['port'] item.user = optional_params['user'] item.acct = optional_params['acct'] item.timeout = optional_params['timeout'] session.add(item) session.commit() xml_item.id = item.id self.update_facade(core_params, optional_params, old_name) return ZATO_OK, etree.tostring(xml_item) except Exception, e: msg = 'Could not update the outgoing FTP connection, e=[{e}]'.format(e=format_exc(e)) self.logger.error(msg) session.rollback() raise
def handle(self, *args, **kwargs): with closing(self.server.odb.session()) as session: payload = kwargs.get('payload') core_params = ['id', 'cluster_id', 'name', 'is_active', 'url_path', 'connection', 'transport'] core_params = _get_params(payload, core_params, 'data.') optional_params = ['method', 'soap_action', 'soap_version'] optional_params = _get_params(payload, optional_params, 'data.', default_value=None) id = core_params['id'] name = core_params['name'] cluster_id = core_params['cluster_id'] existing_one = session.query(HTTPSOAP.id).\ filter(HTTPSOAP.cluster_id==cluster_id).\ filter(HTTPSOAP.id!=id).\ filter(HTTPSOAP.name==name).\ first() if existing_one: raise Exception('An object of that name [{0}] already exists on this cluster'.format(name)) xml_item = Element('http_soap') try: core_params['id'] = int(core_params['id']) core_params['is_active'] = is_boolean(core_params['is_active']) item = session.query(HTTPSOAP).filter_by(id=id).one() item.name = core_params['name'] item.is_active = core_params['is_active'] item.url_path = core_params['url_path'] item.connection = core_params['connection'] item.transport = core_params['transport'] item.cluster_id = core_params['cluster_id'] item.method = optional_params.get('method') item.soap_action = optional_params.get('soap_action') item.soap_version = optional_params.get('soap_version') session.add(item) session.commit() xml_item.id = item.id return ZATO_OK, etree.tostring(xml_item) except Exception, e: msg = 'Could not update the object, e=[{e}]'.format(e=format_exc(e)) self.logger.error(msg) session.rollback() raise
def handle(self, *args, **kwargs): with closing(self.server.odb.session()) as session: payload = kwargs.get('payload') request_params = ['cluster_id', 'name', 'host', 'port', 'queue_manager', 'channel', 'cache_open_send_queues', 'cache_open_receive_queues', 'use_shared_connections', 'ssl', 'ssl_cipher_spec', 'ssl_key_repository', 'needs_mcd', 'max_chars_printed'] params = _get_params(payload, request_params, 'data.') name = params['name'] params['port'] = int(params['port']) params['cache_open_send_queues'] = is_boolean(params['cache_open_send_queues']) params['cache_open_receive_queues'] = is_boolean(params['cache_open_receive_queues']) params['use_shared_connections'] = is_boolean(params['use_shared_connections']) params['ssl'] = is_boolean(params['ssl']) params['needs_mcd'] = is_boolean(params['needs_mcd']) params['max_chars_printed'] = int(params['max_chars_printed']) cluster_id = params['cluster_id'] cluster = session.query(Cluster).filter_by(id=cluster_id).first() # Let's see if we already have an object of that name before committing # any stuff into the database. existing_one = session.query(ConnDefWMQ).\ filter(ConnDefWMQ.cluster_id==Cluster.id).\ filter(ConnDefWMQ.name==name).\ first() if existing_one: raise Exception('JMS WebSphere MQ definition [{0}] already exists on this cluster'.format(name)) created_elem = Element('def_jms_wmq') try: def_ = ConnDefWMQ(None, name, params['host'], params['port'], params['queue_manager'], params['channel'], params['cache_open_send_queues'], params['cache_open_receive_queues'], params['use_shared_connections'], params['ssl'], params['ssl_cipher_spec'], params['ssl_key_repository'], params['needs_mcd'], params['max_chars_printed'], cluster_id) session.add(def_) session.commit() created_elem.id = def_.id return ZATO_OK, etree.tostring(created_elem) except Exception, e: msg = "Could not create a JMS WebSphere MQ definition, e=[{e}]".format(e=format_exc(e)) self.logger.error(msg) session.rollback() raise
def handle(self, *args, **kwargs): with closing(self.server.odb.session()) as session: payload = kwargs.get('payload') core_params = ['id', 'cluster_id', 'name', 'is_active', 'address', 'socket_type'] core_params = _get_params(payload, core_params, 'data.') id = core_params['id'] name = core_params['name'] cluster_id = core_params['cluster_id'] existing_one = session.query(OutgoingZMQ.id).\ filter(OutgoingZMQ.cluster_id==cluster_id).\ filter(OutgoingZMQ.name==name).\ filter(OutgoingZMQ.id!=core_params['id']).\ first() if existing_one: raise Exception('An outgoing ZeroMQ connection [{0}] already exists on this cluster'.format(name)) xml_item = Element('out_zmq') try: core_params['id'] = int(core_params['id']) core_params['is_active'] = is_boolean(core_params['is_active']) item = session.query(OutgoingZMQ).filter_by(id=id).one() old_name = item.name item.name = name item.is_active = core_params['is_active'] item.address = core_params['address'] item.socket_type = core_params['socket_type'] session.add(item) session.commit() xml_item.id = item.id core_params['action'] = OUTGOING.ZMQ_EDIT core_params['old_name'] = old_name self.broker_client.send_json(core_params, msg_type=MESSAGE_TYPE.TO_ZMQ_CONNECTOR_SUB) return ZATO_OK, etree.tostring(xml_item) except Exception, e: msg = 'Could not update the outgoing ZeroMQ connection, e=[{e}]'.format(e=format_exc(e)) self.logger.error(msg) session.rollback() raise
def handle(self, *args, **kwargs): with closing(self.server.odb.session()) as session: payload = kwargs.get('payload') request_params = ['id', 'is_active', 'name', 'username', 'password_type', 'reject_empty_nonce_ts', 'reject_stale_username', 'expiry_limit', 'nonce_freshness', 'cluster_id'] new_params = _get_params(payload, request_params, 'data.') def_id = new_params['id'] name = new_params['name'] cluster_id = new_params['cluster_id'] existing_one = session.query(WSSDefinition).\ filter(Cluster.id==cluster_id).\ filter(WSSDefinition.name==name).\ filter(WSSDefinition.id != def_id).\ first() if existing_one: raise Exception('WS-Security definition [{0}] already exists on this cluster'.format(name)) wss_elem = Element('wss') try: wss = session.query(WSSDefinition).filter_by(id=def_id).one() old_name = wss.name wss.name = name wss.is_active = new_params['is_active'] wss.username = new_params['username'] wss.password_type = new_params['password_type'] wss.reject_empty_nonce_ts = new_params['reject_empty_nonce_ts'] wss.reject_stale_username = new_params['reject_stale_username'] wss.expiry_limit = new_params['expiry_limit'] wss.nonce_freshness = new_params['nonce_freshness'] session.add(wss) session.commit() wss_elem.id = wss.id except Exception, e: msg = "Could not update the WS-Security definition, e=[{e}]".format(e=format_exc(e)) self.logger.error(msg) session.rollback() raise else:
def handle(self, *args, **kwargs): with closing(self.server.odb.session()) as session: payload = kwargs.get('payload') request_params = ['cluster_id', 'name', 'host', 'port', 'vhost', 'username', 'frame_max', 'heartbeat'] params = _get_params(payload, request_params, 'data.') name = params['name'] params['port'] = int(params['port']) params['frame_max'] = int(params['frame_max']) params['heartbeat'] = int(params['heartbeat']) cluster_id = params['cluster_id'] cluster = session.query(Cluster).filter_by(id=cluster_id).first() password = uuid4().hex params['password'] = password # Let's see if we already have an account of that name before committing # any stuff into the database. existing_one = session.query(ConnDefAMQP).\ filter(ConnDefAMQP.cluster_id==Cluster.id).\ filter(ConnDefAMQP.def_type=='amqp').\ filter(ConnDefAMQP.name==name).\ first() if existing_one: raise Exception('AMQP definition [{0}] already exists on this cluster'.format(name)) created_elem = Element('def_amqp') try: def_ = ConnDefAMQP(None, name, 'amqp', params['host'], params['port'], params['vhost'], params['username'], password, params['frame_max'], params['heartbeat'], cluster_id) session.add(def_) session.commit() created_elem.id = def_.id return ZATO_OK, etree.tostring(created_elem) except Exception, e: msg = "Could not create an AMQP definition, e=[{e}]".format(e=format_exc(e)) self.logger.error(msg) session.rollback() raise
def handle(self, *args, **kwargs): with closing(self.server.odb.session()) as session: payload = kwargs.get('payload') core_params = ['id', 'cluster_id', 'name', 'is_active', 'prefix', 'separator', 'key_sync_timeout'] core_params = _get_params(payload, core_params, 'data.') id = core_params['id'] name = core_params['name'] cluster_id = core_params['cluster_id'] existing_one = session.query(OutgoingS3.id).\ filter(OutgoingS3.cluster_id==cluster_id).\ filter(OutgoingS3.name==name).\ filter(OutgoingS3.id!=core_params['id']).\ first() if existing_one: raise Exception('An outgoing S3 connection [{0}] already exists on this cluster'.format(name)) xml_item = Element('out_s3') try: core_params['id'] = int(core_params['id']) core_params['is_active'] = is_boolean(core_params['is_active']) item = session.query(OutgoingS3).filter_by(id=id).one() old_name = item.name item.name = name item.is_active = core_params['is_active'] item.prefix = core_params['prefix'] item.separator = core_params['separator'] item.key_sync_timeout = core_params['key_sync_timeout'] session.add(item) session.commit() xml_item.id = item.id return ZATO_OK, etree.tostring(xml_item) except Exception, e: msg = 'Could not update the outgoing S3 connection, e=[{e}]'.format(e=format_exc(e)) self.logger.error(msg) session.rollback() raise
def handle(self, *args, **kwargs): with closing(self.server.odb.session()) as session: definition_list = Element("definition_list") params = _get_params(kwargs.get("payload"), ["cluster_id"], "data.") definitions = tech_acc_list(session, params["cluster_id"]) for definition in definitions: definition_elem = Element("definition") definition_elem.id = definition.id definition_elem.name = definition.name definition_elem.is_active = definition.is_active definition_list.append(definition_elem) return ZATO_OK, etree.tostring(definition_list)
def handle(self, *args, **kwargs): with closing(self.server.odb.session()) as session: payload = kwargs.get('payload') request_params = ['cluster_id', 'name', 'is_active', 'username', 'password_type', 'reject_empty_nonce_ts', 'reject_stale_username', 'expiry_limit', 'nonce_freshness'] params = _get_params(payload, request_params, 'data.') cluster_id = params['cluster_id'] name = params['name'] cluster = session.query(Cluster).filter_by(id=cluster_id).first() # Let's see if we already have a definition of that name before committing # any stuff into the database. existing_one = session.query(WSSDefinition).\ filter(Cluster.id==cluster_id).\ filter(WSSDefinition.name==name).first() if existing_one: raise Exception('WS-Security definition [{0}] already exists on this cluster'.format(name)) wss_elem = Element('wss') password = uuid4().hex try: wss = WSSDefinition(None, name, params['is_active'], params['username'], password, params['password_type'], params['reject_empty_nonce_ts'], params['reject_stale_username'], params['expiry_limit'], params['nonce_freshness'], cluster) session.add(wss) session.commit() wss_elem.id = wss.id except Exception, e: msg = "Could not create a WS-Security definition, e=[{e}]".format(e=format_exc(e)) self.logger.error(msg) session.rollback() raise else:
def handle(self, *args, **kwargs): params = _get_params(kwargs.get('payload'), ['id', 'cluster_id'], 'data.') with closing(self.server.odb.session()) as session: db_item = service(session, params['cluster_id'], params['id']) item = Element('item') item.id = db_item.id item.name = db_item.name item.is_active = db_item.is_active item.impl_name = db_item.impl_name item.is_internal = db_item.is_internal item.usage_count = 'TODO getbyid' return ZATO_OK, etree.tostring(item)
def handle(self, *args, **kwargs): with closing(self.server.odb.session()) as session: payload = kwargs.get('payload') core_params = ['cluster_id', 'name', 'is_active', 'address', 'socket_type'] core_params = _get_params(payload, core_params, 'data.') name = core_params['name'] cluster_id = core_params['cluster_id'] existing_one = session.query(OutgoingZMQ.id).\ filter(OutgoingZMQ.cluster_id==cluster_id).\ filter(OutgoingZMQ.name==name).\ first() if existing_one: raise Exception('An outgoing ZeroMQ connection [{0}] already exists on this cluster'.format(name)) created_elem = Element('out_zmq') try: core_params['is_active'] = is_boolean(core_params['is_active']) item = OutgoingZMQ() item.name = core_params['name'] item.is_active = core_params['is_active'] item.address = core_params['address'] item.socket_type = core_params['socket_type'] item.cluster_id = core_params['cluster_id'] session.add(item) session.commit() created_elem.id = item.id start_connector(self.server.repo_location, item.id) return ZATO_OK, etree.tostring(created_elem) except Exception, e: msg = 'Could not create an outgoing ZeroMQ connection, e=[{e}]'.format(e=format_exc(e)) self.logger.error(msg) session.rollback() raise
def handle(self, *args, **kwargs): with closing(self.server.odb.session()) as session: try: payload = kwargs.get('payload') request_params = ['id', 'is_active', 'name', 'username', 'domain', 'cluster_id'] new_params = _get_params(payload, request_params, 'data.') def_id = new_params['id'] name = new_params['name'] cluster_id = new_params['cluster_id'] existing_one = session.query(HTTPBasicAuth).\ filter(Cluster.id==cluster_id).\ filter(HTTPBasicAuth.name==name).\ filter(HTTPBasicAuth.id != def_id).\ first() if existing_one: raise Exception('HTTP Basic Auth definition [{0}] already exists on this cluster'.format(name)) auth_elem = Element('basic_auth') definition = session.query(HTTPBasicAuth).filter_by(id=def_id).one() old_name = definition.name definition.name = name definition.is_active = new_params['is_active'] definition.username = new_params['username'] definition.domain = new_params['domain'] session.add(definition) session.commit() auth_elem.id = definition.id except Exception, e: msg = "Could not update the HTTP Basic Auth definition, e=[{e}]".format(e=format_exc(e)) self.logger.error(msg) session.rollback() raise else:
def handle(self, *args, **kwargs): with closing(self.server.odb.session()) as session: payload = kwargs.get("payload") request_params = ["tech_account_id"] params = _get_params(payload, request_params, "data.") tech_account = ( session.query(TechnicalAccount.id, TechnicalAccount.name, TechnicalAccount.is_active) .filter(TechnicalAccount.id == params["tech_account_id"]) .one() ) tech_account_elem = Element("tech_account") tech_account_elem.id = tech_account.id tech_account_elem.name = tech_account.name tech_account_elem.is_active = tech_account.is_active return ZATO_OK, etree.tostring(tech_account_elem)
def handle(self, *args, **kwargs): with closing(self.server.odb.session()) as session: payload = kwargs.get("payload") request_params = ["cluster_id", "tech_account_id", "name", "is_active"] params = _get_params(payload, request_params, "data.") cluster_id = params["cluster_id"] tech_account_id = params["tech_account_id"] name = params["name"] existing_one = ( session.query(TechnicalAccount) .filter(Cluster.id == cluster_id) .filter(TechnicalAccount.name == name) .filter(TechnicalAccount.id != tech_account_id) .first() ) if existing_one: raise Exception("Technical account [{0}] already exists on this cluster".format(name)) tech_account = session.query(TechnicalAccount).filter(TechnicalAccount.id == tech_account_id).one() old_name = tech_account.name tech_account.name = name tech_account.is_active = is_boolean(params["is_active"]) tech_account_elem = Element("tech_account") try: session.add(tech_account) session.commit() tech_account_elem.id = tech_account.id except Exception, e: msg = "Could not update the technical account, e=[{e}]".format(e=format_exc(e)) self.logger.error(msg) session.rollback() raise else:
def handle(self, *args, **kwargs): with closing(self.server.odb.session()) as session: payload = kwargs.get("payload") request_params = ["cluster_id", "name", "is_active"] params = _get_params(payload, request_params, "data.") cluster_id = params["cluster_id"] name = params["name"] cluster = session.query(Cluster).filter_by(id=cluster_id).first() salt = uuid4().hex password = tech_account_password(uuid4().hex, salt) # Let's see if we already have an account of that name before committing # any stuff into the database. existing_one = ( session.query(TechnicalAccount) .filter(Cluster.id == cluster_id) .filter(TechnicalAccount.name == name) .first() ) if existing_one: raise Exception("Technical account [{0}] already exists on this cluster".format(name)) tech_account_elem = Element("tech_account") try: tech_account = TechnicalAccount(None, name, password, salt, params["is_active"], cluster=cluster) session.add(tech_account) session.commit() tech_account_elem.id = tech_account.id except Exception, e: msg = "Could not create a technical account, e=[{e}]".format(e=format_exc(e)) self.logger.error(msg) session.rollback() raise else:
def handle(self, *args, **kwargs): params = _get_params(kwargs.get('payload'), ['cluster_id'], 'data.') with closing(self.server.odb.session()) as session: definition_list = Element('definition_list') definitions = basic_auth_list(session, params['cluster_id']) for definition in definitions: definition_elem = Element('definition') definition_elem.id = definition.id definition_elem.name = definition.name definition_elem.is_active = definition.is_active definition_elem.username = definition.username definition_elem.domain = definition.domain definition_list.append(definition_elem) return ZATO_OK, etree.tostring(definition_list)
def handle(self, *args, **kwargs): params = _get_params(kwargs.get('payload'), ['cluster_id'], 'data.') with closing(self.server.odb.session()) as session: item_list = Element('item_list') db_items = out_s3_list(session, params['cluster_id']) for db_item in db_items: item = Element('item') item.id = db_item.id item.name = db_item.name item.is_active = db_item.is_active item.prefix_ = db_item.prefix item.separator = db_item.separator item.key_sync_timeout = db_item.key_sync_timeout item_list.append(item) return ZATO_OK, etree.tostring(item_list)
def handle(self, *args, **kwargs): params = _get_params(kwargs.get('payload'), ['cluster_id'], 'data.') with closing(self.server.odb.session()) as session: item_list = Element('item_list') db_items = service_list(session, params['cluster_id']) for db_item in db_items: item = Element('item') item.id = db_item.id item.name = db_item.name item.is_active = db_item.is_active item.impl_name = db_item.impl_name item.is_internal = db_item.is_internal item.usage_count = 'TODO getlist' item_list.append(item) return ZATO_OK, etree.tostring(item_list)
def handle(self, *args, **kwargs): with closing(self.server.odb.session()) as session: try: payload = kwargs.get('payload') request_params = ['cluster_id', 'name', 'is_active', 'username', 'domain'] params = _get_params(payload, request_params, 'data.') cluster_id = params['cluster_id'] name = params['name'] cluster = session.query(Cluster).filter_by(id=cluster_id).first() # Let's see if we already have a definition of that name before committing # any stuff into the database. existing_one = session.query(HTTPBasicAuth).\ filter(Cluster.id==cluster_id).\ filter(HTTPBasicAuth.name==name).first() if existing_one: raise Exception('HTTP Basic Auth definition [{0}] already exists on this cluster'.format(name)) auth_elem = Element('basic_auth') auth = HTTPBasicAuth(None, name, params['is_active'], params['username'], params['domain'], uuid4().hex, None, cluster) session.add(auth) session.commit() auth_elem.id = auth.id except Exception, e: msg = "Could not create an HTTP Basic Auth definition, e=[{e}]".format(e=format_exc(e)) self.logger.error(msg) session.rollback() raise else:
def handle(self, *args, **kwargs): params = _get_params(kwargs.get('payload'), ['cluster_id'], 'data.') with closing(self.server.odb.session()) as session: item_list = Element('item_list') db_items = channel_zmq_list(session, params['cluster_id']) for db_item in db_items: item = Element('item') item.id = db_item.id item.name = db_item.name item.is_active = db_item.is_active item.address = db_item.address item.socket_type = db_item.socket_type item.sub_key = db_item.sub_key item.service_name = db_item.service_name item_list.append(item) return ZATO_OK, etree.tostring(item_list)
def handle(self, *args, **kwargs): with closing(self.server.odb.session()) as session: payload = kwargs.get('payload') request_params = ['id', 'is_active', 'name'] params = _get_params(payload, request_params, 'data.') id = int(params['id']) is_active = is_boolean(params['is_active']) name = params['name'] service_elem = Element('service') try: service = session.query(Service).filter_by(id=id).one() service.is_active = is_active service.name = name session.add(service) session.commit() service_elem.id = service.id service_elem.name = service.name service_elem.impl_name = service.impl_name service_elem.is_internal = service.is_internal service_elem.usage_count = 'TODO edit' params['action'] = SERVICE.EDIT self.broker_client.send_json(params, msg_type=MESSAGE_TYPE.TO_PARALLEL_SUB) return ZATO_OK, etree.tostring(service_elem) except Exception, e: msg = 'Could not update the service, e=[{e}]'.format(e=format_exc(e)) self.logger.error(msg) session.rollback() raise
def handle(self, *args, **kwargs): with closing(self.server.odb.session()) as session: params = _get_params(kwargs.get('payload'), ['cluster_id'], 'data.') definition_list = Element('definition_list') definitions = wss_list(session, params['cluster_id']) for definition in definitions: definition_elem = Element('definition') definition_elem.id = definition.id definition_elem.name = definition.name definition_elem.is_active = definition.is_active definition_elem.password_type = definition.password_type definition_elem.username = definition.username definition_elem.reject_empty_nonce_ts = definition.reject_empty_nonce_ts definition_elem.reject_stale_username = definition.reject_stale_username definition_elem.expiry_limit = definition.expiry_limit definition_elem.nonce_freshness = definition.nonce_freshness definition_list.append(definition_elem) return ZATO_OK, etree.tostring(definition_list)
def handle(self, *args, **kwargs): params = _get_params(kwargs.get('payload'), ['cluster_id'], 'data.') with closing(self.server.odb.session()) as session: item_list = Element('item_list') db_items = channel_amqp_list(session, params['cluster_id']) for db_item in db_items: item = Element('item') item.id = db_item.id item.name = db_item.name item.is_active = db_item.is_active item.queue = db_item.queue item.consumer_tag_prefix = db_item.consumer_tag_prefix item.service_name = db_item.service_name item.def_name = db_item.def_name item.def_id = db_item.def_id item_list.append(item) return ZATO_OK, etree.tostring(item_list)
def handle(self, *args, **kwargs): params = _get_params(kwargs.get('payload'), ['cluster_id'], 'data.') with closing(self.server.odb.session()) as session: definition_list = Element('definition_list') definitions = def_amqp_list(session, params['cluster_id']) for definition in definitions: definition_elem = Element('definition') definition_elem.id = definition.id definition_elem.name = definition.name definition_elem.host = definition.host definition_elem.port = definition.port definition_elem.vhost = definition.vhost definition_elem.username = definition.username definition_elem.frame_max = definition.frame_max definition_elem.heartbeat = definition.heartbeat definition_list.append(definition_elem) return ZATO_OK, etree.tostring(definition_list)
def handle(self, *args, **kwargs): with closing(self.server.odb.session()) as session: params = _get_params(kwargs.get('payload'), ['cluster_id'], 'data.') definition_list = Element('definition_list') pairs = (('basic_auth', basic_auth_list), ('tech_acc', tech_acc_list), ('wss_username_password', wss_list)) for def_type, meth in pairs: definitions = meth(session, params['cluster_id']) for definition in definitions: definition_elem = Element('definition') definition_elem.id = definition.id definition_elem.name = definition.name definition_elem.def_type = def_type definition_list.append(definition_elem) return ZATO_OK, etree.tostring(definition_list)