def add_pubsub_service_endpoint(self,
_name=PUBSUB.SERVICE_SUBSCRIBER.NAME):
existing = self.session.query(PubSubEndpoint.id).\
filter(PubSubEndpoint.name==_name).\
first()
if not existing:
endpoint = PubSubEndpoint()
endpoint.name = _name
endpoint.is_internal = True
endpoint.role = PUBSUB.ROLE.SUBSCRIBER.id
endpoint.topic_patterns = PUBSUB.SERVICE_SUBSCRIBER.TOPICS_ALLOWED
endpoint.endpoint_type = PUBSUB.ENDPOINT_TYPE.SERVICE.id
if self.cluster:
endpoint.cluster = self.cluster
else:
endpoint.cluster_id = self.cluster_id
self.session.add(endpoint)
def handle(self):
input = self.request.input
with closing(self.odb.session()) as session:
existing_one = session.query(PubSubEndpoint.id).\
filter(PubSubEndpoint.cluster_id==input.cluster_id).\
filter(PubSubEndpoint.name==input.name).\
first()
if existing_one:
raise Conflict(
self.cid,
'Endpoint `{}` already exists'.format(input.name))
endpoint = PubSubEndpoint()
endpoint.cluster_id = input.cluster_id
endpoint.name = input.name
endpoint.is_active = input.is_active
endpoint.is_internal = input.is_internal
endpoint.endpoint_type = input.endpoint_type
endpoint.role = input.role
endpoint.topic_patterns = input.topic_patterns
endpoint.security_id = input.security_id
endpoint.service_id = input.service_id
endpoint.ws_channel_id = input.ws_channel_id
session.add(endpoint)
session.commit()
input.action = PUBSUB.ENDPOINT_CREATE.value
input.id = endpoint.id
self.broker_client.publish(input)
self.response.payload.id = endpoint.id
self.response.payload.name = self.request.input.name
def add_pubsub_sec_endpoints(self, session, cluster):
from zato.common.api import CONNECTION, DATA_FORMAT, PUBSUB, URL_TYPE
from zato.common.json_internal import dumps
from zato.common.odb.model import HTTPBasicAuth, HTTPSOAP, PubSubEndpoint, PubSubSubscription, PubSubTopic, \
Service
from zato.common.pubsub import new_sub_key
from zato.common.util.time_ import utcnow_as_ms
sec_demo = HTTPBasicAuth(
None, 'zato.pubsub.demo.secdef', True, 'zato.pubsub.demo', 'Zato pub/sub demo', new_password(), cluster)
session.add(sec_demo)
sec_default_internal = HTTPBasicAuth(None, 'zato.pubsub.internal.secdef', True, 'zato.pubsub.internal',
'Zato pub/sub internal', new_password(), cluster)
session.add(sec_default_internal)
impl_name1 = 'zato.server.service.internal.pubsub.pubapi.TopicService'
impl_name2 = 'zato.server.service.internal.pubsub.pubapi.SubscribeService'
impl_name3 = 'zato.server.service.internal.pubsub.pubapi.MessageService'
impl_demo = 'zato.server.service.internal.helpers.JSONRawRequestLogger'
service_topic = Service(None, 'zato.pubsub.pubapi.topic-service', True, impl_name1, True, cluster)
service_sub = Service(None, 'zato.pubsub.pubapi.subscribe-service', True, impl_name2, True, cluster)
service_msg = Service(None, 'zato.pubsub.pubapi.message-service', True, impl_name3, True, cluster)
service_demo = Service(None, 'zato.pubsub.helpers.json-raw-request-logger', True, impl_demo, True, cluster)
# Opaque data that lets clients use topic contain slash characters
opaque = dumps({'match_slash':True})
chan_topic = HTTPSOAP(None, 'zato.pubsub.topic.topic_name', True, True, CONNECTION.CHANNEL,
URL_TYPE.PLAIN_HTTP, None, '/zato/pubsub/topic/{topic_name}',
None, '', None, DATA_FORMAT.JSON, security=None, service=service_topic, opaque=opaque,
cluster=cluster)
chan_sub = HTTPSOAP(None, 'zato.pubsub.subscribe.topic.topic_name', True, True, CONNECTION.CHANNEL,
URL_TYPE.PLAIN_HTTP, None, '/zato/pubsub/subscribe/topic/{topic_name}',
None, '', None, DATA_FORMAT.JSON, security=None, service=service_sub, opaque=opaque,
cluster=cluster)
chan_msg = HTTPSOAP(None, 'zato.pubsub.msg.msg_id', True, True, CONNECTION.CHANNEL,
URL_TYPE.PLAIN_HTTP, None, '/zato/pubsub/msg/{msg_id}',
None, '', None, DATA_FORMAT.JSON, security=None, service=service_msg, opaque=opaque,
cluster=cluster)
chan_demo = HTTPSOAP(None, 'pubsub.demo.sample.channel', True, True, CONNECTION.CHANNEL,
URL_TYPE.PLAIN_HTTP, None, '/zato/pubsub/zato.demo.sample',
None, '', None, DATA_FORMAT.JSON, security=sec_demo, service=service_demo, opaque=opaque,
cluster=cluster)
outconn_demo = HTTPSOAP(None, 'pubsub.demo.sample.outconn', True, True, CONNECTION.OUTGOING,
URL_TYPE.PLAIN_HTTP, 'http://localhost:11223', '/zato/pubsub/zato.demo.sample',
None, '', None, DATA_FORMAT.JSON, security=sec_demo, opaque=opaque,
cluster=cluster)
endpoint_default_internal = PubSubEndpoint()
endpoint_default_internal.name = PUBSUB.DEFAULT.INTERNAL_ENDPOINT_NAME
endpoint_default_internal.is_internal = True
endpoint_default_internal.role = PUBSUB.ROLE.PUBLISHER_SUBSCRIBER.id
endpoint_default_internal.topic_patterns = 'pub=/*\nsub=/*'
endpoint_default_internal.security = sec_default_internal
endpoint_default_internal.cluster = cluster
endpoint_default_internal.endpoint_type = PUBSUB.ENDPOINT_TYPE.INTERNAL.id
endpoint_demo = PubSubEndpoint()
endpoint_demo.name = 'zato.pubsub.demo.endpoint'
endpoint_demo.is_internal = True
endpoint_demo.role = PUBSUB.ROLE.PUBLISHER_SUBSCRIBER.id
endpoint_demo.topic_patterns = 'pub=/zato/demo/*\nsub=/zato/demo/*'
endpoint_demo.security = sec_demo
endpoint_demo.cluster = cluster
endpoint_demo.endpoint_type = PUBSUB.ENDPOINT_TYPE.REST.id
topic = PubSubTopic()
topic.name = '/zato/demo/sample'
topic.is_active = True
topic.is_api_sub_allowed = True
topic.is_internal = True
topic.max_depth = 100
topic.has_gd = False
topic.cluster = cluster
sub = PubSubSubscription()
sub.creation_time = utcnow_as_ms()
sub.topic = topic
sub.endpoint = endpoint_demo
sub.sub_key = new_sub_key(endpoint_demo.endpoint_type)
sub.has_gd = False
sub.sub_pattern_matched = 'sub=/zato/demo/*'
sub.active_status = PUBSUB.QUEUE_ACTIVE_STATUS.FULLY_ENABLED.id
sub.cluster = cluster
sub.wrap_one_msg_in_list = False
sub.delivery_err_should_block = False
sub.out_http_soap = outconn_demo
session.add(endpoint_default_internal)
session.add(endpoint_demo)
session.add(topic)
session.add(sub)
session.add(service_topic)
session.add(service_sub)
session.add(service_msg)
session.add(chan_topic)
session.add(chan_sub)
session.add(chan_msg)
session.add(chan_demo)
session.add(outconn_demo)