class SimpleIO(AdminSIO):
request_elem = 'zato_service_get_request_response_request'
response_elem = 'zato_service_request_response_response'
input_required = ('cluster_id', 'name')
output_required = ('service_id', Integer('sample_req_resp_freq'))
output_optional = (
'sample_cid',
'sample_req_ts',
'sample_resp_ts',
'sample_req',
'sample_resp',
)
class SimpleIO:
output_required = ('id', 'name', 'is_active', 'is_internal',
'url_path')
output_optional = ('service_id', 'service_name', 'security_id',
'security_name', 'sec_type', 'method',
'soap_action', 'soap_version', 'data_format',
'host', 'ping_method', 'pool_size',
'merge_url_params_req', 'url_params_pri',
'params_pri', 'serialization_type', 'timeout',
'sec_tls_ca_cert_id',
Boolean('has_rbac'), 'content_type',
Boolean('sec_use_rbac'), 'cache_id', 'cache_name',
Integer('cache_expiry'), 'cache_type')
class SimpleIO:
input_required = (AsIs('is_a'), Boolean('b'), Bool('c'), CSV('d'),
Dict('e'), Float('f'), Int('g'), Integer('h'),
List('i'), ListOfDicts('j'), Nested('k'),
Opaque('l'), Unicode('m'), UTC('n'))
input_optional = (AsIs('is_aa'), Boolean('bb'), Bool('cc'), CSV('dd'),
Dict('ee'), Float('ff'), Int('gg'), Integer('hh'),
List('ii'), ListOfDicts('jj'), Nested('kk'),
Opaque('ll'), Unicode('mm'), UTC('nn'))
output_required = (AsIs('is_aaa'), Boolean('bbb'), Bool('ccc'),
CSV('ddd'), Dict('eee'), Float('fff'), Int('ggg'),
Integer('hhh'), List('iii'), ListOfDicts('jjj'),
Nested('kkk'), Opaque('lll'), Unicode('mmm'),
UTC('nnn'))
output_optional = (AsIs('is_aaaa'), Boolean('bbbb'), Bool('cccc'),
CSV('dddd'), Dict('eeee'), Float('ffff'),
Int('gggg'), Integer('hhhh'), List('iiii'),
ListOfDicts('jjjj'), Nested('kkkk'), Opaque('llll'),
Unicode('mmmm'), UTC('nnnn'))
def test_sio(self):
self.assertEquals(self.sio.request_elem, 'zato_definition_jms_wmq_get_list_request')
self.assertEquals(self.sio.response_elem, 'zato_definition_jms_wmq_get_list_response')
self.assertEquals(self.sio.input_required, ('cluster_id',))
self.assertEquals(self.sio.output_required, ('id', 'name', 'host', 'port', 'queue_manager', 'channel',
self.wrap_force_type(Boolean('cache_open_send_queues')),
self.wrap_force_type(Boolean('cache_open_receive_queues')),
self.wrap_force_type(Boolean('use_shared_connections')),
self.wrap_force_type(Boolean('ssl')), 'needs_mcd',
self.wrap_force_type(Integer('max_chars_printed'))))
self.assertEquals(self.sio.output_optional,('ssl_cipher_spec', 'ssl_key_repository'))
self.assertEquals(self.sio.namespace, zato_namespace)
self.assertRaises(AttributeError, getattr, self.sio, 'input_optional')
class SimpleIO(AdminSIO):
request_elem = 'zato_definition_jms_wmq_get_by_id_request'
response_elem = 'zato_definition_jms_wmq_get_by_id_response'
input_required = (
'id',
'cluster_id',
)
output_required = ('id', 'name', 'host', 'port', 'queue_manager',
'channel', Boolean('cache_open_send_queues'),
Boolean('cache_open_receive_queues'),
Boolean('use_shared_connections'), Boolean('ssl'),
'needs_mcd', Integer('max_chars_printed'))
output_optional = ('ssl_cipher_spec', 'ssl_key_repository')
class SimpleIO(AdminSIO):
request_elem = 'zato_http_soap_edit_request'
response_elem = 'zato_http_soap_edit_response'
input_required = ('id', 'cluster_id', 'name', 'is_active',
'connection', 'transport', 'url_path')
input_optional = ('service', 'security_id', 'method', 'soap_action',
'soap_version', 'data_format', 'host', 'ping_method',
'pool_size', Boolean('merge_url_params_req'),
'url_params_pri', 'params_pri', 'serialization_type',
'timeout', 'sec_tls_ca_cert_id',
Boolean('has_rbac'), 'content_type', 'cache_id',
Integer('cache_expiry'), 'content_encoding',
Boolean('match_slash'))
output_required = ('id', 'name')
def test_sio(self):
self.assertEquals(self.sio.request_elem,
'zato_security_get_list_request')
self.assertEquals(self.sio.response_elem,
'zato_security_get_list_response')
self.assertEquals(self.sio.input_required, ('cluster_id', ))
self.assertEquals(self.sio.output_required,
('id', 'name', 'is_active', 'sec_type'))
self.assertEquals(self.sio.output_repeated, True)
self.assertEquals(
self.sio.output_optional,
('username', 'realm', 'password_type',
self.wrap_force_type(Boolean('reject_empty_nonce_creat')),
self.wrap_force_type(Boolean('reject_stale_tokens')),
self.wrap_force_type(Integer('reject_expiry_limit')),
self.wrap_force_type(
Integer('nonce_freshness_time')), 'proto_version',
'sig_method', self.wrap_force_type(Integer('max_nonce_log'))))
self.assertEquals(self.sio.namespace, zato_namespace)
self.assertEquals(len(self.sio.input_optional), 2)
self.assertEquals(self.sio.input_optional[0].name, 'sec_type')
self.assertEquals(self.sio.input_optional[1].name, 'needs_internal')
def test_sio(self):
self.assertEquals(self.sio.input_required, (self.wrap_force_type(
UTC('start')), self.wrap_force_type(UTC('stop'))))
self.assertEquals(
self.sio.input_optional,
('service_name', self.wrap_force_type(Integer('n')), 'n_type'))
self.assertEquals(
self.sio.output_optional,
('service_name', 'usage', 'mean', 'rate', 'time', 'usage_trend',
'mean_trend', 'min_resp_time', 'max_resp_time',
'all_services_usage', 'all_services_time', 'mean_all_services',
'usage_perc_all_services', 'time_perc_all_services'))
self.assertEquals(self.sio.namespace, zato_namespace)
self.assertRaises(AttributeError, getattr, self.sio, 'output_required')
self.assertRaises(AttributeError, getattr, self.sio, 'output_repeated')
def test_sio(self):
self.assertEquals(self.sio.request_elem,
'zato_outgoing_amqp_edit_request')
self.assertEquals(self.sio.response_elem,
'zato_outgoing_amqp_edit_response')
self.assertEquals(
self.sio.input_required,
('id', 'cluster_id', 'name', 'is_active', 'def_id',
'delivery_mode', self.wrap_force_type(Integer('priority'))))
self.assertEquals(self.sio.input_optional,
('content_type', 'content_encoding', 'expiration',
self.wrap_force_type(AsIs('user_id')),
self.wrap_force_type(AsIs('app_id'))))
self.assertEquals(self.sio.output_required, ('id', 'name'))
self.assertEquals(self.sio.namespace, zato_namespace)
self.assertRaises(AttributeError, getattr, self.sio, 'output_optional')
self.assertRaises(AttributeError, getattr, self.sio, 'output_repeated')
class SimpleIO(StatsReturningService.SimpleIO):
input_required = (UTC('start'), Integer('n'), 'n_type')
class SimpleIO(AdminSIO):
request_elem = 'zato_service_invoke_request'
response_elem = 'zato_service_invoke_response'
input_optional = ('id', 'name', 'payload', 'channel', 'data_format', 'transport', Boolean('async'),
Integer('expiration'), Integer('pid'), Boolean('all_pids'), Integer('timeout'))
output_optional = ('response',)
class SimpleIO:
input_required = (Integer('id'))
class SimpleIO(StatsReturningService.SimpleIO):
request_elem = 'zato_stats_get_trends_request'
response_elem = 'zato_stats_get_trends_response'
input_required = StatsReturningService.SimpleIO.input_required + (
Integer('n'), 'n_type')
input_optional = ('service_name', )
class SimpleIO(AdminSIO):
request_elem = 'zato_outgoing_jms_wmq_create_request'
response_elem = 'zato_outgoing_jms_wmq_create_response'
input_required = ('cluster_id', 'name', 'is_active', 'def_id', Integer('delivery_mode'), Integer('priority'))
input_optional = ('expiration',)
output_required = ('id', 'name')
class SimpleIO:
output_required = ('name', 'is_active', 'impl_name', 'is_internal',
Integer('slow_threshold'))
class SimpleIO:
input_required = (Integer('id'))
# Passwords never travel back to the client side
output_optional = ('id', 'username', 'name', 'surname', 'email',
'is_admin')
skip_empty_keys = True
class SimpleIO(AdminSIO):
request_elem = 'zato_security_jwt_create_request'
response_elem = 'zato_security_jwt_create_response'
input_required = ('cluster_id', 'name', 'is_active', 'username',
Integer('ttl'))
output_required = ('id', 'name')
class SimpleIO(AdminSIO):
request_elem = 'zato_security_oauth_edit_request'
response_elem = 'zato_security_oauth_edit_response'
input_required = ('id', 'cluster_id', 'name', 'is_active', 'username',
'proto_version', 'sig_method', Integer('max_nonce_log'))
output_required = ('id', 'name')
from __future__ import absolute_import, division, print_function, unicode_literals
# stdlib
from contextlib import closing
from traceback import format_exc
# Zato
from zato.common.broker_message import OUTGOING
from zato.common.odb.model import ConnDefWMQ, OutgoingWMQ
from zato.common.odb.query import out_wmq, out_wmq_list
from zato.server.service import AsIs, Integer
from zato.server.service.internal import AdminService, AdminSIO, GetListAdminSIO
# ################################################################################################################################
_base_required = ('id', Integer('delivery_mode'), Integer('priority'))
_get_required = _base_required + ('name', 'is_active', 'def_id', 'def_name')
_optional = (Integer('expiration'),)
# ################################################################################################################################
class _GetSIO(AdminSIO):
output_required = _get_required
output_optional = _optional + ('def_id', 'def_name_full_text')
# ################################################################################################################################
class Get(AdminService):
""" Returns details of a single outgoing WebSphere MQ connection.
"""
class SimpleIO(AdminSIO):
request_elem = 'zato_security_jwt_create_request'
response_elem = 'zato_security_jwt_create_response'
input_required = 'cluster_id', 'name', 'is_active', 'username', Integer('ttl')
input_optional = 'is_rate_limit_active', 'rate_limit_type', 'rate_limit_def', Boolean('rate_limit_check_parent_def')
output_required = 'id', 'name'
class SimpleIO(object):
input_required = (Integer('id'))
output_optional = ('id', 'date_from', 'date_to', 'base_price',
'bed_price', 'published', 'days')
skip_empty_keys = True
class SimpleIO(AdminSIO):
request_elem = 'zato_http_soap_get_audit_config_request'
response_elem = 'zato_http_soap_get_audit_config_response'
input_required = ('id',)
output_required = (Boolean('audit_enabled'), Integer('audit_back_log'),
Integer('audit_max_payload'), 'audit_repl_patt_type')
class SimpleIO(StatsReturningService.SimpleIO):
input_required = (UTC('start'), Integer('n'), 'n_type')
input_optional = ('service_name',)
class SimpleIO:
input_required = (Integer('int1'), Integer('int2'))
output_required = (Integer('int3'), Integer('int4'))
class SimpleIO:
input_required = (Integer('bits'),)
output_required = ('secret',)
class SimpleIO(AdminSIO):
request_elem = 'zato_service_configure_request_response_request'
response_elem = 'zato_service_configure_request_response_response'
input_required = ('cluster_id', 'name',
Integer('sample_req_resp_freq'))
class SimpleIO(AdminSIO):
request_elem = 'zato_http_soap_set_audit_config_request'
response_elem = 'zato_http_soap_set_audit_config_response'
input_required = ('id', Integer('audit_max_payload'))
class SimpleIO:
input_required = (Integer('bits'),)
output_required = ('password',)
class SimpleIO(AdminSIO):
request_elem = 'zato_service_slow_response_get_request'
response_elem = 'zato_service_slow_response_get_response'
input_required = ('cid', 'name')
output_optional = ('cid', 'req_ts', 'resp_ts', Integer('proc_time'),
'req', 'resp')
class SimpleIO(AdminSIO):
request_elem = 'zato_service_edit_request'
response_elem = 'zato_service_edit_response'
input_required = ('id', 'is_active', Integer('slow_threshold'))
output_required = ('id', 'name', 'impl_name', 'is_internal',
Boolean('may_be_deleted'))