def create_func(self, solace_config, vpn, topic, settings=None):
"""Create a Topic/Endpoint"""
defaults = {}
mandatory = {'msgVpnName': vpn, 'topicEndpointName': topic}
data = su.merge_dicts(defaults, mandatory, settings)
path_array = [su.SEMP_V2_CONFIG, su.MSG_VPNS, vpn, su.TOPIC_ENDPOINTS]
return su.make_post_request(solace_config, path_array, data)
def create_func(self, solace_config, vpn, settings=None):
"""Create a VPN"""
defaults = {"enabled": True}
mandatory = {"msgVpnName": vpn}
data = su.merge_dicts(defaults, mandatory, settings)
path = "/".join([su.SEMP_V2_CONFIG, su.MSG_VPNS])
return su.make_post_request(solace_config, path, data)
def create_func(self, solace_config, vpn, queue, settings=None):
"""Create a Queue"""
defaults = {}
mandatory = {'msgVpnName': vpn, 'queueName': queue}
data = su.merge_dicts(defaults, mandatory, settings)
path_array = [su.SEMP_V2_CONFIG, su.MSG_VPNS, vpn, su.QUEUES]
return su.make_post_request(solace_config, path_array, data)
def create_func(self,
solace_config,
vpn,
acl_profile_name,
topic_syntax,
subscribe_topic_exception,
settings=None):
# vmr_sempVersion: <=2.13 : POST /msgVpns/{msgVpnName}/aclProfiles/{aclProfileName}/subscribeExceptions
# vmr_sempVersion: >=2.14: POST /msgVpns/{msgVpnName}/aclProfiles/{aclProfileName}/subscribeTopicExceptions
defaults = {
'msgVpnName':
vpn,
'aclProfileName':
acl_profile_name,
self.get_semp_version_key(self.SEMP_VERSION_KEY_LOOKUP, solace_config.vmr_sempVersion, self.KEY_TOPIC_SYNTAX_KEY):
topic_syntax
}
mandatory = {
self.get_semp_version_key(self.SEMP_VERSION_KEY_LOOKUP, solace_config.vmr_sempVersion, self.KEY_LOOKUP_ITEM_KEY):
subscribe_topic_exception
}
data = su.merge_dicts(defaults, mandatory, settings)
uri_subscr_ex = self.get_semp_version_key(
self.SEMP_VERSION_KEY_LOOKUP, solace_config.vmr_sempVersion,
self.KEY_URI_SUBSCR_EX)
path_array = [
su.SEMP_V2_CONFIG, su.MSG_VPNS, vpn, su.ACL_PROFILES,
acl_profile_name, uri_subscr_ex
]
return su.make_post_request(solace_config, path_array, data)
def _update_func_solace_cloud(self, solace_config, lookup_item_value,
delta_settings, current_settings):
# POST /{paste-your-serviceId-here}/requests/clientProfileRequests
# for POST: add the current_settings, override with delta_settings
# current_settings come as a nested dict, extract to flat dict
profile_names = [x for x in current_settings]
if len(profile_names) != 1:
resp = dict(
error=
"Error parsing Solace Cloud Client Profile current settings.",
current_settings=current_settings)
return False, resp
else:
curr_settings = current_settings[profile_names[0]]
# inconsistency in Solace Cloud API:
# elidingEnabled:
# create: must be provided as boolean (true or false)
# get: returns it as null if it was false
# update: must be provided as true or false
if curr_settings and curr_settings['elidingEnabled'] is None:
curr_settings['elidingEnabled'] = False
mandatory = {
self.LOOKUP_ITEM_KEY: lookup_item_value,
}
data = su.merge_dicts(curr_settings, mandatory, delta_settings)
body = su.compose_solace_cloud_body('update', 'clientProfile', data)
path_array = [
su.SOLACE_CLOUD_API_SERVICES_BASE_PATH,
solace_config.solace_cloud_config['service_id'],
su.SOLACE_CLOUD_REQUESTS, su.SOLACE_CLOUD_CLIENT_PROFILE_REQUESTS
]
return su.make_post_request(solace_config, path_array, body)
def create_func(self,
solace_config,
vpn,
bridge_virtual_router,
bridge_name,
remote_vpn_location,
remote_vpn_interface,
remote_vpn,
settings=None):
# POST /msgVpns/{msgVpnName}/bridges/{bridgeName},{bridgeVirtualRouter}/remoteMsgVpns
defaults = {
'msgVpnName':
vpn,
'remoteMsgVpnLocation':
remote_vpn_location,
**({
'remoteMsgVpnInterface': remote_vpn_interface
} if remote_vpn_interface is not None else {})
}
mandatory = {
'bridgeName': bridge_name,
self.LOOKUP_ITEM_KEY: remote_vpn
}
data = su.merge_dicts(defaults, mandatory, settings)
bridge_uri = ','.join([bridge_name, bridge_virtual_router])
path_array = [
su.SEMP_V2_CONFIG, su.MSG_VPNS, vpn, su.BRIDGES, bridge_uri,
su.BRIDGES_REMOTE_MSG_VPNS
]
return su.make_post_request(solace_config, path_array, data)
def create_func(self, solace_config, vpn, acl_profile, settings=None):
defaults = {
'msgVpnName': vpn,
}
mandatory = {self.LOOKUP_ITEM_KEY: acl_profile}
data = su.merge_dicts(defaults, mandatory, settings)
path_array = [su.SEMP_V2_CONFIG, su.MSG_VPNS, vpn, su.ACL_PROFILES]
return su.make_post_request(solace_config, path_array, data)
def create_func(self, solace_config, vpn, queue, settings=None):
"""Create a Queue"""
defaults = {}
mandatory = {"msgVpnName": vpn, "queueName": queue}
data = su.merge_dicts(defaults, mandatory, settings)
path = "/".join([su.SEMP_V2_CONFIG, su.MSG_VPNS, vpn, su.QUEUES])
return su.make_post_request(solace_config, path, data)
def create_func(self, solace_config, dmr, settings=None):
defaults = {
'enabled': True,
'authenticationBasicPassword': solace_config.vmr_auth[1]
}
mandatory = {'dmrClusterName': dmr}
data = su.merge_dicts(defaults, mandatory, settings)
path_array = [su.SEMP_V2_CONFIG, su.DMR_CLUSTERS]
return su.make_post_request(solace_config, path_array, data)
def create_func(self, solace_config, vpn, name, settings=None):
"""Create a RDP"""
defaults = {}
mandatory = {'msgVpnName': vpn, 'restDeliveryPointName': name}
data = su.merge_dicts(defaults, mandatory, settings)
path_array = [
su.SEMP_V2_CONFIG, su.MSG_VPNS, vpn, su.RDP_REST_DELIVERY_POINTS
]
return su.make_post_request(solace_config, path_array, data)
def create_func(self, solace_config, vpn, client_profile, settings=None):
"""Create a Client Profile"""
defaults = {}
mandatory = {"clientProfileName": client_profile}
data = su.merge_dicts(defaults, mandatory, settings)
path = "/".join(
[su.SEMP_V2_CONFIG, su.MSG_VPNS, vpn, su.CLIENT_PROFILES])
return su.make_post_request(solace_config, path, data)
def create_func(self, solace_config, vpn, client, settings=None):
"""Create a Client"""
# POST /msgVpns/{msgVpnName}/clientUsernames
defaults = {'enabled': True}
mandatory = {
'clientUsername': client,
}
data = su.merge_dicts(defaults, mandatory, settings)
path_array = [su.SEMP_V2_CONFIG, su.MSG_VPNS, vpn, su.CLIENT_USERNAMES]
return su.make_post_request(solace_config, path_array, data)
def create_func(self, solace_config, vpn, queue, topic, settings=None):
# POST /msgVpns/{msgVpnName}/queues/{queueName}/subscriptions
defaults = {}
mandatory = {self.LOOKUP_ITEM_KEY: topic}
data = su.merge_dicts(defaults, mandatory, settings)
path_array = [
su.SEMP_V2_CONFIG, su.MSG_VPNS, vpn, su.QUEUES, queue,
su.SUBSCRIPTIONS
]
return su.make_post_request(solace_config, path_array, data)
def _create_func_solace_cloud(self, solace_config, client_profile_name,
data):
# POST /{paste-your-serviceId-here}/requests/clientProfileRequests
body = su.compose_solace_cloud_body('create', 'clientProfile', data)
path_array = [
su.SOLACE_CLOUD_API_SERVICES_BASE_PATH,
solace_config.solace_cloud_config['service_id'],
su.SOLACE_CLOUD_REQUESTS, su.SOLACE_CLOUD_CLIENT_PROFILE_REQUESTS
]
return su.make_post_request(solace_config, path_array, body)
def create_func(self, solace_config, dmr, link, address, settings=None):
# POST /dmrClusters/{dmrClusterName}/links/{remoteNodeName}/remoteAddresses
defaults = {'dmrClusterName': dmr, 'remoteNodeName': link}
mandatory = {'remoteAddress': address}
data = su.merge_dicts(defaults, mandatory, settings)
path_array = [
su.SEMP_V2_CONFIG, su.DMR_CLUSTERS, dmr, su.LINKS, link,
su.REMOTE_ADDRESSES
]
return su.make_post_request(solace_config, path_array, data)
def create_func(self, solace_config, vpn, queue, topic, settings=None):
"""Create a Subscription for a Topic/Endpoint on a Queue"""
defaults = {}
mandatory = {
"subscriptionTopic": topic
}
data = su.merge_dicts(defaults, mandatory, settings)
path = "/".join([su.SEMP_V2_CONFIG, su.MSG_VPNS, vpn, su.QUEUES, queue, su.SUBSCRIPTIONS])
return su.make_post_request(solace_config, path, data)
def create_func(self, solace_config, vpn, settings=None):
"""Create a VPN"""
defaults = {
'enabled': True
}
mandatory = {
'msgVpnName': vpn
}
data = su.merge_dicts(defaults, mandatory, settings)
path_array = [su.SEMP_V2_CONFIG, su.MSG_VPNS]
return su.make_post_request(solace_config, path_array, data)
def create_func(self, solace_config, dmr, link, settings=None):
"""Create a DMR Cluster"""
defaults = {
'dmrClusterName': dmr
}
mandatory = {
'remoteNodeName': link
}
data = su.merge_dicts(defaults, mandatory, settings)
path_array = [su.SEMP_V2_CONFIG, su.DMR_CLUSTERS, dmr, su.LINKS]
return su.make_post_request(solace_config, path_array, data)
def create_func(self, solace_config, vpn, client, settings=None):
"""Create a Client"""
defaults = {"enabled": True}
mandatory = {
"clientUsername": client,
}
data = su.merge_dicts(defaults, mandatory, settings)
path = "/".join(
[su.SEMP_V2_CONFIG, su.MSG_VPNS, vpn, su.CLIENT_USERNAMES])
return su.make_post_request(solace_config, path, data)
def create_func(self,
solace_config,
cert_content,
cert_authority,
settings=None):
defaults = {'certContent': cert_content}
mandatory = {
'certAuthorityName': cert_authority,
}
data = su.merge_dicts(defaults, mandatory, settings)
path_array = [su.SEMP_V2_CONFIG, su.CERT_AUTHORITIES]
return su.make_post_request(solace_config, path_array, data)
def create_func(self, solace_config, dmr, link, trusted_cn, settings=None):
"""Create a DMR Cluster"""
defaults = {
'dmrClusterName': dmr,
'remoteNodeName': link
}
mandatory = {
'tlsTrustedCommonName': trusted_cn
}
data = su.merge_dicts(defaults, mandatory, settings)
path_array = [su.SEMP_V2_CONFIG, su.DMR_CLUSTERS, dmr, su.LINKS, link, su.TLS_TRUSTED_COMMON_NAMES]
return su.make_post_request(solace_config, path_array, data)
def create_func(self, solace_config, vpn, virtual_router, mqtt_session_client_id, settings=None):
# POST /msgVpns/{msgVpnName}/mqttSessions
defaults = {
'msgVpnName': vpn,
'mqttSessionVirtualRouter': virtual_router
}
mandatory = {
self.LOOKUP_ITEM_KEY: mqtt_session_client_id
}
data = su.merge_dicts(defaults, mandatory, settings)
path_array = [su.SEMP_V2_CONFIG, su.MSG_VPNS, vpn, su.MQTT_SESSIONS]
return su.make_post_request(solace_config, path_array, data)
def create_func(self,
solace_config,
vpn,
virtual_router,
bridge_name,
settings=None):
# POST /msgVpns/{msgVpnName}/bridges
defaults = {'msgVpnName': vpn, 'bridgeVirtualRouter': virtual_router}
mandatory = {self.LOOKUP_ITEM_KEY: bridge_name}
data = su.merge_dicts(defaults, mandatory, settings)
path_array = [su.SEMP_V2_CONFIG, su.MSG_VPNS, vpn, su.BRIDGES]
return su.make_post_request(solace_config, path_array, data)
def create_func(self,
solace_config,
vpn,
acl_profile_name,
client_connect_exception_address,
settings=None):
defaults = {'msgVpnName': vpn, 'aclProfileName': acl_profile_name}
mandatory = {self.LOOKUP_ITEM_KEY: client_connect_exception_address}
data = su.merge_dicts(defaults, mandatory, settings)
path_array = [
su.SEMP_V2_CONFIG, su.MSG_VPNS, vpn, su.ACL_PROFILES,
acl_profile_name, su.ACL_PROFILES_CLIENT_CONNECT_EXCEPTIONS
]
return su.make_post_request(solace_config, path_array, data)
def create_func(self, solace_config, vpn, rdp_name, name, settings=None):
"""Create a rest consumer for an RDP"""
# POST /msgVpns/{msgVpnName}/restDeliveryPoints/{restDeliveryPointName}/restConsumers
defaults = {}
mandatory = {
'msgVpnName': vpn,
'restConsumerName': name,
'restDeliveryPointName': rdp_name
}
data = su.merge_dicts(defaults, mandatory, settings)
path_array = [
su.SEMP_V2_CONFIG, su.MSG_VPNS, vpn, su.RDP_REST_DELIVERY_POINTS,
rdp_name, su.RDP_REST_CONSUMERS
]
return su.make_post_request(solace_config, path_array, data)
def create_func(self, solace_config, vpn, client_id, virtual_router, topic, settings=None):
# POST /msgVpns/{msgVpnName}/mqttSessions/{mqttSessionClientId},{mqttSessionVirtualRouter}/subscriptions
defaults = {
'msgVpnName': vpn,
'mqttSessionClientId': client_id,
'mqttSessionVirtualRouter': virtual_router
}
mandatory = {
self.LOOKUP_ITEM_KEY: topic
}
data = su.merge_dicts(defaults, mandatory, settings)
uri_ext = ','.join([client_id, virtual_router])
path_array = [su.SEMP_V2_CONFIG, su.MSG_VPNS, vpn, su.MQTT_SESSIONS, uri_ext, su.MQTT_SESSION_SUBSCRIPTIONS]
ok, resp = su.make_post_request(solace_config, path_array, data)
if not ok:
return False, resp
# QoS==1? ==> ensure magic queue is ON/ON
if settings and settings['subscriptionQos'] == 1:
# search = "#mqtt/" + client_id + "/does-not-exist"
search = "#mqtt/" + client_id + "/*"
ok_gmq, resp_gmq = self.get_magic_queue(search, vpn)
if not ok_gmq:
resp['error'] = dict(
msg="error retrieving magic queue: {}".format(search),
details=resp_gmq
)
return False, resp
elif len(resp_gmq) != 1:
resp['error'] = dict(
msg="could not find magic queue: {}".format(search)
)
return False, resp
# make sure magic queue is ON/ON
# depending on Broker version, no-shutdown is allowed or not.
# here: ignore error
mq_name = resp_gmq[0]['name']
ok_no_shut, resp_no_shut = self.execute_queue_no_shutdown(mq_name, vpn)
# if not ok_no_shut:
# resp['error'] = dict(
# msg="error executing no-shutdown for magic queue: {}".format(mq_name),
# details=resp_no_shut
# )
# return False, resp
return True, resp
def create_func(self,
solace_config,
vpn,
virtual_router,
bridge_name,
trusted_common_name,
settings=None):
"""Create a Bridge"""
defaults = {'msgVpnName': vpn, 'bridgeVirtualRouter': virtual_router}
mandatory = {
'bridgeName': bridge_name,
'tlsTrustedCommonName': trusted_common_name
}
data = su.merge_dicts(defaults, mandatory, settings)
bridge_uri = ','.join([bridge_name, virtual_router])
path_array = [
su.SEMP_V2_CONFIG, su.MSG_VPNS, vpn, su.BRIDGES, bridge_uri,
su.BRIDGES_TRUSTED_COMMON_NAMES
]
return su.make_post_request(solace_config, path_array, data)
def create_func(self,
solace_config,
vpn,
virtual_router,
bridge_name,
topic,
settings=None):
# POST /msgVpns/{msgVpnName}/bridges/{bridgeName},{bridgeVirtualRouter}/remoteSubscriptions
defaults = {}
mandatory = {
'msgVpnName': vpn,
'bridgeName': bridge_name,
'bridgeVirtualRouter': virtual_router,
self.LOOKUP_ITEM_KEY: topic
}
data = su.merge_dicts(defaults, mandatory, settings)
bridge_uri = ','.join([bridge_name, virtual_router])
path_array = [
su.SEMP_V2_CONFIG, su.MSG_VPNS, vpn, su.BRIDGES, bridge_uri,
su.BRIDGES_REMOTE_SUBSCRIPTIONS
]
return su.make_post_request(solace_config, path_array, data)
def create_func(self,
solace_config,
vpn,
rdp_name,
rest_consumer_name,
name,
settings=None):
"""Add a trusted common name"""
# POST /msgVpns/{msgVpnName}/restDeliveryPoints/{restDeliveryPointName}/restConsumers/{restConsumerName}/tlsTrustedCommonNames
defaults = {}
mandatory = {
'msgVpnName': vpn,
'restConsumerName': rest_consumer_name,
'restDeliveryPointName': rdp_name,
'tlsTrustedCommonName': name
}
data = su.merge_dicts(defaults, mandatory, settings)
path_array = [
su.SEMP_V2_CONFIG, su.MSG_VPNS, vpn, su.RDP_REST_DELIVERY_POINTS,
rdp_name, su.RDP_REST_CONSUMERS, rest_consumer_name,
su.RDP_TLS_TRUSTED_COMMON_NAMES
]
return su.make_post_request(solace_config, path_array, data)
def create_func(self, solace_config, vpn, remote_node, settings=None):
defaults = {'msgVpnName': vpn, 'remoteMsgVpnName': 'default'}
mandatory = {'remoteNodeName': remote_node}
data = su.merge_dicts(defaults, mandatory, settings)
path_array = [su.SEMP_V2_CONFIG, su.MSG_VPNS, vpn, su.DMR_BRIDGES]
return su.make_post_request(solace_config, path_array, data)
