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)
