class SendReceiveMsg(object):
def __init__(self):
self.bus_service = ServiceBusService(
service_namespace='sb-test',
shared_access_key_name='RepertorySniffSend',
shared_access_key_value=
'h64zPhep/+8Aocl9DM+sm7AtkzzTDbzIqHW65iGIul0=',
host_base=".servicebus.chinacloudapi.cn")
# def __init__(self):
# self.bus_service = ServiceBusService(
# service_namespace='sb-test',
# shared_access_key_name='adsniff',
# shared_access_key_value='wrUBhluj4k1Nw2L/RVK+GYQg7H1qiwFLCXFpkFsbwnI=',
# host_base=".servicebus.chinacloudapi.cn"
# )
def send_msg(self):
for i in range(10):
if i % 2:
msg = Message('Msg {0}'.format(i).encode('utf-8'),
custom_properties={'num': '1'})
else:
msg = Message('Msg {0}'.format(i).encode('utf-8'),
custom_properties={'num': '2'})
self.bus_service.send_topic_message('repertorysniff', msg)
class SweetieMQ(object):
bus_service = None
topic = None
def __init__(self, config):
account_key = getattr(config, 'sb_account_key', None)
if account_key is None:
log.warn('sb_account_key is not set, skipping mq setup')
return
issuer = getattr(config, 'sb_issuer', 'owner')
service_namespace = getattr(config, 'sb_namespace', 'jabber-messages')
topic = getattr(config, 'sb_topic', 'test-topic')
self.bus_service = ServiceBusService(service_namespace=service_namespace,\
account_key=account_key, issuer=issuer)
self.topic = topic
def send(self, message):
if self.bus_service is None:
return
log.debug('Sending message ' + str(message))
msg = Message(message)
try:
self.bus_service.send_topic_message(self.topic, msg)
except Exception as e:
log.error("MESSAGE DELIVERY FAILED: " + str(e))
class SweetieMQ(object):
bus_service = None
topic = None
def __init__(self, config):
account_key = getattr(config, 'sb_account_key', None)
issuer = getattr(config, 'sb_issuer', None)
if issuer is None:
issuer = 'owner'
if account_key is None:
return
self.bus_service = ServiceBusService(service_namespace='jabber-fimsquad',\
account_key=account_key, issuer=issuer)
self.topic = 'chat-general'
def send(self, message):
if self.bus_service is None:
return
log.debug('Sending message '+str(message))
msg = Message(message)
try:
self.bus_service.send_topic_message(self.topic, msg)
except Exception as e:
log.error("MESSAGE DELIVERY FAILED: "+str(e))
class SendReceiveMsg(object):
def __init__(self):
self.bus_service = ServiceBusService(
service_namespace='sb-test',
shared_access_key_name='RepertorySniffSend',
shared_access_key_value='h64zPhep/+8Aocl9DM+sm7AtkzzTDbzIqHW65iGIul0=',
host_base=".servicebus.chinacloudapi.cn"
)
def send_data(self, data, name):
msg = Message(data, custom_properties={'type': name})
self.bus_service.send_topic_message('repertorysniff', msg)
class SendReceiveMsg():
def __init__(self):
self.bus_service = ServiceBusService(
service_namespace='sb-test',
shared_access_key_name='WifiSniffSend',
shared_access_key_value=
'23SmfgRdqHHTn7o38hG1wLDYskIF3T+DL29g54W/fhE=',
host_base=".servicebus.chinacloudapi.cn")
def send_msg(self, data):
msg = Message(data)
self.bus_service.send_topic_message('wifisniff', msg)
class AzureBroker(Thread):
def __init__(self):
Thread.__init__(self)
self._quit = Event()
self.daemon = True
self.log = logging.getLogger(__name__)
self.outgoing_topic = 'pending_jobs'
self.incoming_topic = 'finished_jobs'
self.notification_topic = 'jobs_changed'
self.subscription = 'AllMessages'
settings = Settings()
self.bus_service = ServiceBusService(
service_namespace=settings.azure_topic_namespace,
shared_access_key_name=settings.azure_topic_keyname,
shared_access_key_value=settings.azure_topic_key
)
self.bus_service.create_topic(self.incoming_topic)
self.bus_service.create_topic(self.outgoing_topic)
self.bus_service.create_topic(self.notification_topic)
self.bus_service.create_subscription(self.incoming_topic, self.subscription)
def run(self):
# dislike of unstoppable threads
while not self._quit.is_set():
msg = self.bus_service.receive_subscription_message(self.incoming_topic, self.subscription,
peek_lock=False, timeout=0.1)
if msg.body is not None:
self.log.info(msg.body + ":" + msg.custom_properties['job_id'])
notification_msg = Message('Finished'.encode('utf-8'), custom_properties={'job_id': msg.custom_properties['job_id']})
self.bus_service.send_topic_message(self.notification_topic, notification_msg)
sleep(3)
def transmit_job_created(self, job_id):
msg = Message('Created'.encode('utf-8'), custom_properties={'job_id': job_id})
self.bus_service.send_topic_message(self.outgoing_topic, msg)
self.bus_service.send_topic_message(self.notification_topic, msg)
self.log.info("Adding job " + job_id + " created to service bus.")
def transmit_job_assigned(self, job_id, machine_id):
msg = Message('Assigned'.encode('utf-8'), custom_properties={'job_id': job_id, 'machine_id': machine_id})
self.bus_service.send_topic_message(self.outgoing_topic, msg)
self.bus_service.send_topic_message(self.notification_topic, msg)
self.log.info("Adding job " + job_id + " assigned to " + machine_id + " to the service bus.")
def quit(self):
self._quit.set()
def azure_autheticate():
key_name = 'beardcavekey' # SharedAccessKeyName from Azure portal
key_value = 'qc4xkJJlpEiRpcwCiD56dh/oxJBlhmM0gCwUcYw10GM=' # SharedAccessKey from Azure portal
service_namespace = 'beardcave'
sbs = ServiceBusService(service_namespace,
shared_access_key_name=key_name,
shared_access_key_value=key_value)
print "authenticated"
msg = Message('g3 off')
sbs.send_topic_message('lighttopic', msg)
# msg = sbs.receive_subscription_message('lighttopic', 'lightsubscription', peek_lock=True)
print(msg.body)
print "sent"
def sendMessage(action, message):
#If Service bus feature is disabled just return
if not SB_ENABLED:
return
msg = Message(message,
custom_properties={
'sample': 'python',
'action': action
})
sb = ServiceBusService(service_namespace=SB_NAMESPACE,
account_key=SB_KEY,
issuer=SB_ISSUER)
sb.send_topic_message(SB_TOPIC, msg)
class MessageClient():
def __init__(self, namespace, keyname, keyval):
self._client = ServiceBusService(service_namespace=namespace,
shared_access_key_name=keyname,
shared_access_key_value=keyval)
def send(self, topic, num):
for i in range(num):
msg = Message('Msg {0}'.format(i).encode('utf-8'),
custom_properties={'messagenumber': i})
self._client.send_topic_message(topic, msg)
print('Sending message {0}'.format(i))
def receive(self, topic, subscription, num):
for i in range(num):
msg = self._client.receive_subscription_message(topic,
subscription,
peek_lock=False,
timeout=10)
print(msg.body)
class SendReceiveMsg(object):
# def __init__(self):
# self.bus_service = ServiceBusService(
# service_namespace='sb-test',
# shared_access_key_name='ordersniff',
# shared_access_key_value='FJGJ6dVsg4eaTMJt1eBMOTi2TSCBy42TRQ+dTaMpUII=',
# host_base=".servicebus.chinacloudapi.cn"
# )
def __init__(self):
self.bus_service = ServiceBusService(
service_namespace='sb-test',
shared_access_key_name='adsniff',
shared_access_key_value='wrUBhluj4k1Nw2L/RVK+GYQg7H1qiwFLCXFpkFsbwnI=',
host_base=".servicebus.chinacloudapi.cn"
)
def send_msg(self):
msg = "abc"
# self.bus_service.send_topic_message('odersniff', msg)
self.bus_service.send_topic_message('adsniff', msg)
class Notifier():
def __init__(self, args):
if args.service_bus_namespace:
if args.verbose:
print 'Notifying via Azure Service Bus'
self.topic = args.service_bus_topic
self.service_bus = ServiceBusService(
service_namespace=args.service_bus_namespace,
account_key=args.service_bus_account_key,
issuer=args.service_bus_issuer)
else:
self.service_bus = None
def notify(self, detail, image):
title = 'You have an incoming call'
priority = 1 # high
if self.service_bus:
properties = {
'title': title,
'priority': priority,
'image': base64.b64encode(image)
}
msg = Message(detail, custom_properties=properties)
self.service_bus.send_topic_message(self.topic, msg)
class AzureHook(CloudHook):
def __init__(self, serviceKeyValues=middle_earth):
# Call super class constructor
CloudHook.__init__(self, serviceKeyValues)
self.queue = pyqueue.Queue()
# Implement abstract methods
def setupHook(self, kv):
self.serviceBus = ServiceBusService(
service_namespace=kv['service_namespace'],
shared_access_key_name=kv['shared_access_key_name'],
shared_access_key_value=kv['shared_access_key_value'])
def createQueue(self, queueName, queueOptions=None):
if queueOptions is None:
queueOptions = Queue()
queueOptions.max_size_in_megabytes = '5120'
queueOptions.default_message_time_to_live = 'PT1M'
self.serviceBus.create_queue(queueName, queueOptions)
def sendQueueMessage(self, queueName, messageBody):
self.serviceBus.send_queue_message(queueName, Message(messageBody))
def receiveQueueMessage(self, queueName, peek_lock=False):
return self.serviceBus.receive_queue_message(queueName, peek_lock)
def createTopic(self, topicName, topicOptions=None):
if topicOptions is None:
topicOptions = Topic()
topicOptions.max_size_in_megabytes = '5120'
topicOptions.default_message_time_to_live = 'PT1M'
self.serviceBus.create_topic(topicName, topicOptions)
def publish(self, topicName, messageBody, extra=None):
if hasConnectivity():
self.flushQueue()
message = Message(messageBody, custom_properties=extra)
self.serviceBus.send_topic_message(topicName, message)
return True
else:
self.queue.put({
'topicName': topicName,
'messageBody': messageBody,
'extra': extra
})
return False
def subscribe(self, topicName, subscriptionName):
self.serviceBus.create_subscription(topicName, subscriptionName)
def getMessage(self,
topicName,
subscriptionName,
peek_lock=False,
timeout='60'):
return self.serviceBus.receive_subscription_message(
topicName, subscriptionName, peek_lock=peek_lock, timeout=timeout)
# We could persist the data in a local sqllite database, which would be easy
# but we feel that that goes beyond the scope of this project
def flushQueue(self):
while not self.queue.empty():
try:
dic = self.queue.get_nowait()
except Queue.Empty:
break
message = Message(dic['messageBody'],
custom_properties=dic['extra'])
self.serviceBus.send_topic_message(dic['topicName'], message)
# Create Microsoft Azure Service Bus Topic and Subscriptions
from azure.servicebus import ServiceBusService, Message, Topic, Rule, DEFAULT_RULE_NAME
# Import credentials
from AzureCredentials import svcbus_namespace, svcbus_keyname, svcbus_keyvalue
# Create a ServiceBusService object
bus_service = ServiceBusService(
service_namespace = svcbus_namespace,
shared_access_key_name = svcbus_keyname,
shared_access_key_value = svcbus_keyvalue)
# Test messages
msg = Message('Camera registration'.encode('utf-8'), custom_properties={'messagetype':'Registration'})
bus_service.send_topic_message('cameratopic', msg)
msg = Message('Camera sighting'.encode('utf-8'), custom_properties={'messagetype':'Sighting'})
bus_service.send_topic_message('cameratopic', msg)
msg = Message('Camera sighting - speeding'.encode('utf-8'), custom_properties={'messagetype':'Sighting', 'speeding':True})
bus_service.send_topic_message('cameratopic', msg)
class ServiceBusTest(AzureTestCase):
def setUp(self):
self.sbs = ServiceBusService(credentials.getServiceBusNamespace(),
credentials.getServiceBusKey(),
'owner')
self.sbs.set_proxy(credentials.getProxyHost(),
credentials.getProxyPort(),
credentials.getProxyUser(),
credentials.getProxyPassword())
__uid = getUniqueTestRunID()
queue_base_name = u'mytestqueue%s' % (__uid)
topic_base_name = u'mytesttopic%s' % (__uid)
self.queue_name = getUniqueNameBasedOnCurrentTime(queue_base_name)
self.topic_name = getUniqueNameBasedOnCurrentTime(topic_base_name)
self.additional_queue_names = []
self.additional_topic_names = []
def tearDown(self):
self.cleanup()
return super(ServiceBusTest, self).tearDown()
def cleanup(self):
try:
self.sbs.delete_queue(self.queue_name)
except:
pass
for name in self.additional_queue_names:
try:
self.sbs.delete_queue(name)
except:
pass
try:
self.sbs.delete_topic(self.topic_name)
except:
pass
for name in self.additional_topic_names:
try:
self.sbs.delete_topic(name)
except:
pass
#--Helpers-----------------------------------------------------------------
def _create_queue(self, queue_name):
self.sbs.create_queue(queue_name, None, True)
def _create_queue_and_send_msg(self, queue_name, msg):
self._create_queue(queue_name)
self.sbs.send_queue_message(queue_name, msg)
def _create_topic(self, topic_name):
self.sbs.create_topic(topic_name, None, True)
def _create_topic_and_subscription(self, topic_name, subscription_name):
self._create_topic(topic_name)
self._create_subscription(topic_name, subscription_name)
def _create_subscription(self, topic_name, subscription_name):
self.sbs.create_subscription(topic_name, subscription_name, None, True)
#--Test cases for service bus service -------------------------------------
def test_create_service_bus_missing_arguments(self):
# Arrange
if os.environ.has_key(AZURE_SERVICEBUS_NAMESPACE):
del os.environ[AZURE_SERVICEBUS_NAMESPACE]
if os.environ.has_key(AZURE_SERVICEBUS_ACCESS_KEY):
del os.environ[AZURE_SERVICEBUS_ACCESS_KEY]
if os.environ.has_key(AZURE_SERVICEBUS_ISSUER):
del os.environ[AZURE_SERVICEBUS_ISSUER]
# Act
with self.assertRaises(WindowsAzureError):
sbs = ServiceBusService()
# Assert
def test_create_service_bus_env_variables(self):
# Arrange
os.environ[
AZURE_SERVICEBUS_NAMESPACE] = credentials.getServiceBusNamespace()
os.environ[
AZURE_SERVICEBUS_ACCESS_KEY] = credentials.getServiceBusKey()
os.environ[AZURE_SERVICEBUS_ISSUER] = 'owner'
# Act
sbs = ServiceBusService()
if os.environ.has_key(AZURE_SERVICEBUS_NAMESPACE):
del os.environ[AZURE_SERVICEBUS_NAMESPACE]
if os.environ.has_key(AZURE_SERVICEBUS_ACCESS_KEY):
del os.environ[AZURE_SERVICEBUS_ACCESS_KEY]
if os.environ.has_key(AZURE_SERVICEBUS_ISSUER):
del os.environ[AZURE_SERVICEBUS_ISSUER]
# Assert
self.assertIsNotNone(sbs)
self.assertEquals(sbs.service_namespace,
credentials.getServiceBusNamespace())
self.assertEquals(sbs.account_key, credentials.getServiceBusKey())
self.assertEquals(sbs.issuer, 'owner')
#--Test cases for queues --------------------------------------------------
def test_create_queue_no_options(self):
# Arrange
# Act
created = self.sbs.create_queue(self.queue_name)
# Assert
self.assertTrue(created)
def test_create_queue_no_options_fail_on_exist(self):
# Arrange
# Act
created = self.sbs.create_queue(self.queue_name, None, True)
# Assert
self.assertTrue(created)
def test_create_queue_with_options(self):
# Arrange
# Act
queue_options = Queue()
queue_options.default_message_time_to_live = 'PT1M'
queue_options.duplicate_detection_history_time_window = 'PT5M'
queue_options.enable_batched_operations = False
queue_options.dead_lettering_on_message_expiration = False
queue_options.lock_duration = 'PT1M'
queue_options.max_delivery_count = 15
queue_options.max_size_in_megabytes = 5120
queue_options.message_count = 0
queue_options.requires_duplicate_detection = False
queue_options.requires_session = False
queue_options.size_in_bytes = 0
created = self.sbs.create_queue(self.queue_name, queue_options)
# Assert
self.assertTrue(created)
queue = self.sbs.get_queue(self.queue_name)
self.assertEquals('PT1M', queue.default_message_time_to_live)
self.assertEquals(
'PT5M', queue.duplicate_detection_history_time_window)
self.assertEquals(False, queue.enable_batched_operations)
self.assertEquals(False, queue.dead_lettering_on_message_expiration)
self.assertEquals('PT1M', queue.lock_duration)
self.assertEquals(15, queue.max_delivery_count)
self.assertEquals(5120, queue.max_size_in_megabytes)
self.assertEquals(0, queue.message_count)
self.assertEquals(False, queue.requires_duplicate_detection)
self.assertEquals(False, queue.requires_session)
self.assertEquals(0, queue.size_in_bytes)
def test_create_queue_with_already_existing_queue(self):
# Arrange
# Act
created1 = self.sbs.create_queue(self.queue_name)
created2 = self.sbs.create_queue(self.queue_name)
# Assert
self.assertTrue(created1)
self.assertFalse(created2)
def test_create_queue_with_already_existing_queue_fail_on_exist(self):
# Arrange
# Act
created = self.sbs.create_queue(self.queue_name)
with self.assertRaises(WindowsAzureError):
self.sbs.create_queue(self.queue_name, None, True)
# Assert
self.assertTrue(created)
def test_get_queue_with_existing_queue(self):
# Arrange
self._create_queue(self.queue_name)
# Act
queue = self.sbs.get_queue(self.queue_name)
# Assert
self.assertIsNotNone(queue)
self.assertEquals(queue.name, self.queue_name)
def test_get_queue_with_non_existing_queue(self):
# Arrange
# Act
with self.assertRaises(WindowsAzureError):
resp = self.sbs.get_queue(self.queue_name)
# Assert
def test_list_queues(self):
# Arrange
self._create_queue(self.queue_name)
# Act
queues = self.sbs.list_queues()
for queue in queues:
name = queue.name
# Assert
self.assertIsNotNone(queues)
self.assertNamedItemInContainer(queues, self.queue_name)
def test_list_queues_with_special_chars(self):
# Arrange
# Name must start and end with an alphanumeric and can only contain
# letters, numbers, periods, hyphens, forward slashes and underscores.
other_queue_name = self.queue_name + 'foo/.-_123'
self.additional_queue_names = [other_queue_name]
self._create_queue(other_queue_name)
# Act
queues = self.sbs.list_queues()
# Assert
self.assertIsNotNone(queues)
self.assertNamedItemInContainer(queues, other_queue_name)
def test_delete_queue_with_existing_queue(self):
# Arrange
self._create_queue(self.queue_name)
# Act
deleted = self.sbs.delete_queue(self.queue_name)
# Assert
self.assertTrue(deleted)
queues = self.sbs.list_queues()
self.assertNamedItemNotInContainer(queues, self.queue_name)
def test_delete_queue_with_existing_queue_fail_not_exist(self):
# Arrange
self._create_queue(self.queue_name)
# Act
deleted = self.sbs.delete_queue(self.queue_name, True)
# Assert
self.assertTrue(deleted)
queues = self.sbs.list_queues()
self.assertNamedItemNotInContainer(queues, self.queue_name)
def test_delete_queue_with_non_existing_queue(self):
# Arrange
# Act
deleted = self.sbs.delete_queue(self.queue_name)
# Assert
self.assertFalse(deleted)
def test_delete_queue_with_non_existing_queue_fail_not_exist(self):
# Arrange
# Act
with self.assertRaises(WindowsAzureError):
self.sbs.delete_queue(self.queue_name, True)
# Assert
def test_send_queue_message(self):
# Arrange
self._create_queue(self.queue_name)
sent_msg = Message('send message')
# Act
self.sbs.send_queue_message(self.queue_name, sent_msg)
# Assert
def test_receive_queue_message_read_delete_mode(self):
# Assert
sent_msg = Message('receive message')
self._create_queue_and_send_msg(self.queue_name, sent_msg)
# Act
received_msg = self.sbs.receive_queue_message(self.queue_name, False)
# Assert
self.assertIsNotNone(received_msg)
self.assertEquals(sent_msg.body, received_msg.body)
def test_receive_queue_message_read_delete_mode_throws_on_delete(self):
# Assert
sent_msg = Message('receive message')
self._create_queue_and_send_msg(self.queue_name, sent_msg)
# Act
received_msg = self.sbs.receive_queue_message(self.queue_name, False)
with self.assertRaises(WindowsAzureError):
received_msg.delete()
# Assert
def test_receive_queue_message_read_delete_mode_throws_on_unlock(self):
# Assert
sent_msg = Message('receive message')
self._create_queue_and_send_msg(self.queue_name, sent_msg)
# Act
received_msg = self.sbs.receive_queue_message(self.queue_name, False)
with self.assertRaises(WindowsAzureError):
received_msg.unlock()
# Assert
def test_receive_queue_message_peek_lock_mode(self):
# Arrange
sent_msg = Message('peek lock message')
self._create_queue_and_send_msg(self.queue_name, sent_msg)
# Act
received_msg = self.sbs.receive_queue_message(self.queue_name, True)
# Assert
self.assertIsNotNone(received_msg)
self.assertEquals(sent_msg.body, received_msg.body)
def test_receive_queue_message_delete(self):
# Arrange
sent_msg = Message('peek lock message delete')
self._create_queue_and_send_msg(self.queue_name, sent_msg)
# Act
received_msg = self.sbs.receive_queue_message(self.queue_name, True)
received_msg.delete()
# Assert
self.assertIsNotNone(received_msg)
self.assertEquals(sent_msg.body, received_msg.body)
def test_receive_queue_message_unlock(self):
# Arrange
sent_msg = Message('peek lock message unlock')
self._create_queue_and_send_msg(self.queue_name, sent_msg)
# Act
received_msg = self.sbs.receive_queue_message(self.queue_name, True)
received_msg.unlock()
# Assert
received_again_msg = self.sbs.receive_queue_message(
self.queue_name, True)
received_again_msg.delete()
self.assertIsNotNone(received_msg)
self.assertIsNotNone(received_again_msg)
self.assertEquals(sent_msg.body, received_msg.body)
self.assertEquals(received_again_msg.body, received_msg.body)
def test_send_queue_message_with_custom_message_type(self):
# Arrange
self._create_queue(self.queue_name)
# Act
sent_msg = Message(
'<text>peek lock message custom message type</text>', type='text/xml')
self.sbs.send_queue_message(self.queue_name, sent_msg)
received_msg = self.sbs.receive_queue_message(self.queue_name, True, 5)
received_msg.delete()
# Assert
self.assertIsNotNone(received_msg)
self.assertEquals('text/xml', received_msg.type)
def test_send_queue_message_with_custom_message_properties(self):
# Arrange
self._create_queue(self.queue_name)
# Act
props = {'hello': 'world',
'foo': 42,
'active': True,
'deceased': False,
'large': 8555111000,
'floating': 3.14,
'dob': datetime(2011, 12, 14)}
sent_msg = Message('message with properties', custom_properties=props)
self.sbs.send_queue_message(self.queue_name, sent_msg)
received_msg = self.sbs.receive_queue_message(self.queue_name, True, 5)
received_msg.delete()
# Assert
self.assertIsNotNone(received_msg)
self.assertEquals(received_msg.custom_properties['hello'], 'world')
self.assertEquals(received_msg.custom_properties['foo'], 42)
self.assertEquals(received_msg.custom_properties['active'], True)
self.assertEquals(received_msg.custom_properties['deceased'], False)
self.assertEquals(received_msg.custom_properties['large'], 8555111000)
self.assertEquals(received_msg.custom_properties['floating'], 3.14)
self.assertEquals(
received_msg.custom_properties['dob'], datetime(2011, 12, 14))
def test_receive_queue_message_timeout_5(self):
# Arrange
self._create_queue(self.queue_name)
# Act
start = time.clock()
received_msg = self.sbs.receive_queue_message(self.queue_name, True, 5)
duration = time.clock() - start
# Assert
self.assertTrue(duration > 3 and duration < 7)
self.assertIsNotNone(received_msg)
self.assertIsNone(received_msg.body)
def test_receive_queue_message_timeout_50(self):
# Arrange
self._create_queue(self.queue_name)
# Act
start = time.clock()
received_msg = self.sbs.receive_queue_message(
self.queue_name, True, 50)
duration = time.clock() - start
# Assert
self.assertTrue(duration > 48 and duration < 52)
self.assertIsNotNone(received_msg)
self.assertIsNone(received_msg.body)
#--Test cases for topics/subscriptions ------------------------------------
def test_create_topic_no_options(self):
# Arrange
# Act
created = self.sbs.create_topic(self.topic_name)
# Assert
self.assertTrue(created)
def test_create_topic_no_options_fail_on_exist(self):
# Arrange
# Act
created = self.sbs.create_topic(self.topic_name, None, True)
# Assert
self.assertTrue(created)
def test_create_topic_with_options(self):
# Arrange
# Act
topic_options = Topic()
topic_options.default_message_time_to_live = 'PT1M'
topic_options.duplicate_detection_history_time_window = 'PT5M'
topic_options.enable_batched_operations = False
topic_options.max_size_in_megabytes = 5120
topic_options.requires_duplicate_detection = False
topic_options.size_in_bytes = 0
# TODO: MaximumNumberOfSubscriptions is not supported?
created = self.sbs.create_topic(self.topic_name, topic_options)
# Assert
self.assertTrue(created)
topic = self.sbs.get_topic(self.topic_name)
self.assertEquals('PT1M', topic.default_message_time_to_live)
self.assertEquals(
'PT5M', topic.duplicate_detection_history_time_window)
self.assertEquals(False, topic.enable_batched_operations)
self.assertEquals(5120, topic.max_size_in_megabytes)
self.assertEquals(False, topic.requires_duplicate_detection)
self.assertEquals(0, topic.size_in_bytes)
def test_create_topic_with_already_existing_topic(self):
# Arrange
# Act
created1 = self.sbs.create_topic(self.topic_name)
created2 = self.sbs.create_topic(self.topic_name)
# Assert
self.assertTrue(created1)
self.assertFalse(created2)
def test_create_topic_with_already_existing_topic_fail_on_exist(self):
# Arrange
# Act
created = self.sbs.create_topic(self.topic_name)
with self.assertRaises(WindowsAzureError):
self.sbs.create_topic(self.topic_name, None, True)
# Assert
self.assertTrue(created)
def test_topic_backwards_compatibility_warning(self):
# Arrange
topic_options = Topic()
topic_options.max_size_in_megabytes = 5120
# Act
val = topic_options.max_size_in_mega_bytes
# Assert
self.assertEqual(val, 5120)
# Act
topic_options.max_size_in_mega_bytes = 1024
# Assert
self.assertEqual(topic_options.max_size_in_megabytes, 1024)
def test_get_topic_with_existing_topic(self):
# Arrange
self._create_topic(self.topic_name)
# Act
topic = self.sbs.get_topic(self.topic_name)
# Assert
self.assertIsNotNone(topic)
self.assertEquals(topic.name, self.topic_name)
def test_get_topic_with_non_existing_topic(self):
# Arrange
# Act
with self.assertRaises(WindowsAzureError):
self.sbs.get_topic(self.topic_name)
# Assert
def test_list_topics(self):
# Arrange
self._create_topic(self.topic_name)
# Act
topics = self.sbs.list_topics()
for topic in topics:
name = topic.name
# Assert
self.assertIsNotNone(topics)
self.assertNamedItemInContainer(topics, self.topic_name)
def test_list_topics_with_special_chars(self):
# Arrange
# Name must start and end with an alphanumeric and can only contain
# letters, numbers, periods, hyphens, forward slashes and underscores.
other_topic_name = self.topic_name + 'foo/.-_123'
self.additional_topic_names = [other_topic_name]
self._create_topic(other_topic_name)
# Act
topics = self.sbs.list_topics()
# Assert
self.assertIsNotNone(topics)
self.assertNamedItemInContainer(topics, other_topic_name)
def test_delete_topic_with_existing_topic(self):
# Arrange
self._create_topic(self.topic_name)
# Act
deleted = self.sbs.delete_topic(self.topic_name)
# Assert
self.assertTrue(deleted)
topics = self.sbs.list_topics()
self.assertNamedItemNotInContainer(topics, self.topic_name)
def test_delete_topic_with_existing_topic_fail_not_exist(self):
# Arrange
self._create_topic(self.topic_name)
# Act
deleted = self.sbs.delete_topic(self.topic_name, True)
# Assert
self.assertTrue(deleted)
topics = self.sbs.list_topics()
self.assertNamedItemNotInContainer(topics, self.topic_name)
def test_delete_topic_with_non_existing_topic(self):
# Arrange
# Act
deleted = self.sbs.delete_topic(self.topic_name)
# Assert
self.assertFalse(deleted)
def test_delete_topic_with_non_existing_topic_fail_not_exist(self):
# Arrange
# Act
with self.assertRaises(WindowsAzureError):
self.sbs.delete_topic(self.topic_name, True)
# Assert
def test_create_subscription(self):
# Arrange
self._create_topic(self.topic_name)
# Act
created = self.sbs.create_subscription(
self.topic_name, 'MySubscription')
# Assert
self.assertTrue(created)
def test_create_subscription_with_options(self):
# Arrange
self._create_topic(self.topic_name)
# Act
subscription_options = Subscription()
subscription_options.dead_lettering_on_filter_evaluation_exceptions = False
subscription_options.dead_lettering_on_message_expiration = False
subscription_options.default_message_time_to_live = 'PT15M'
subscription_options.enable_batched_operations = False
subscription_options.lock_duration = 'PT1M'
subscription_options.max_delivery_count = 15
#message_count is read-only
subscription_options.message_count = 0
subscription_options.requires_session = False
created = self.sbs.create_subscription(
self.topic_name, 'MySubscription', subscription_options)
# Assert
self.assertTrue(created)
subscription = self.sbs.get_subscription(
self.topic_name, 'MySubscription')
self.assertEquals(
False, subscription.dead_lettering_on_filter_evaluation_exceptions)
self.assertEquals(
False, subscription.dead_lettering_on_message_expiration)
self.assertEquals('PT15M', subscription.default_message_time_to_live)
self.assertEquals(False, subscription.enable_batched_operations)
self.assertEquals('PT1M', subscription.lock_duration)
# self.assertEquals(15, subscription.max_delivery_count) #no idea why
# max_delivery_count is always 10
self.assertEquals(0, subscription.message_count)
self.assertEquals(False, subscription.requires_session)
def test_create_subscription_fail_on_exist(self):
# Arrange
self._create_topic(self.topic_name)
# Act
created = self.sbs.create_subscription(
self.topic_name, 'MySubscription', None, True)
# Assert
self.assertTrue(created)
def test_create_subscription_with_already_existing_subscription(self):
# Arrange
self._create_topic(self.topic_name)
# Act
created1 = self.sbs.create_subscription(
self.topic_name, 'MySubscription')
created2 = self.sbs.create_subscription(
self.topic_name, 'MySubscription')
# Assert
self.assertTrue(created1)
self.assertFalse(created2)
def test_create_subscription_with_already_existing_subscription_fail_on_exist(self):
# Arrange
self._create_topic(self.topic_name)
# Act
created = self.sbs.create_subscription(
self.topic_name, 'MySubscription')
with self.assertRaises(WindowsAzureError):
self.sbs.create_subscription(
self.topic_name, 'MySubscription', None, True)
# Assert
self.assertTrue(created)
def test_list_subscriptions(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription2')
# Act
subscriptions = self.sbs.list_subscriptions(self.topic_name)
# Assert
self.assertIsNotNone(subscriptions)
self.assertEquals(len(subscriptions), 1)
self.assertEquals(subscriptions[0].name, 'MySubscription2')
def test_get_subscription_with_existing_subscription(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription3')
# Act
subscription = self.sbs.get_subscription(
self.topic_name, 'MySubscription3')
# Assert
self.assertIsNotNone(subscription)
self.assertEquals(subscription.name, 'MySubscription3')
def test_get_subscription_with_non_existing_subscription(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription3')
# Act
with self.assertRaises(WindowsAzureError):
self.sbs.get_subscription(self.topic_name, 'MySubscription4')
# Assert
def test_delete_subscription_with_existing_subscription(self):
# Arrange
self._create_topic(self.topic_name)
self._create_subscription(self.topic_name, 'MySubscription4')
self._create_subscription(self.topic_name, 'MySubscription5')
# Act
deleted = self.sbs.delete_subscription(
self.topic_name, 'MySubscription4')
# Assert
self.assertTrue(deleted)
subscriptions = self.sbs.list_subscriptions(self.topic_name)
self.assertIsNotNone(subscriptions)
self.assertEquals(len(subscriptions), 1)
self.assertEquals(subscriptions[0].name, 'MySubscription5')
def test_delete_subscription_with_existing_subscription_fail_not_exist(self):
# Arrange
self._create_topic(self.topic_name)
self._create_subscription(self.topic_name, 'MySubscription4')
self._create_subscription(self.topic_name, 'MySubscription5')
# Act
deleted = self.sbs.delete_subscription(
self.topic_name, 'MySubscription4', True)
# Assert
self.assertTrue(deleted)
subscriptions = self.sbs.list_subscriptions(self.topic_name)
self.assertIsNotNone(subscriptions)
self.assertEquals(len(subscriptions), 1)
self.assertEquals(subscriptions[0].name, 'MySubscription5')
def test_delete_subscription_with_non_existing_subscription(self):
# Arrange
self._create_topic(self.topic_name)
# Act
deleted = self.sbs.delete_subscription(
self.topic_name, 'MySubscription')
# Assert
self.assertFalse(deleted)
def test_delete_subscription_with_non_existing_subscription_fail_not_exist(self):
# Arrange
self._create_topic(self.topic_name)
# Act
with self.assertRaises(WindowsAzureError):
self.sbs.delete_subscription(
self.topic_name, 'MySubscription', True)
# Assert
def test_create_rule_no_options(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
# Act
created = self.sbs.create_rule(
self.topic_name, 'MySubscription', 'MyRule1')
# Assert
self.assertTrue(created)
def test_create_rule_no_options_fail_on_exist(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
# Act
created = self.sbs.create_rule(
self.topic_name, 'MySubscription', 'MyRule1', None, True)
# Assert
self.assertTrue(created)
def test_create_rule_with_already_existing_rule(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
# Act
created1 = self.sbs.create_rule(
self.topic_name, 'MySubscription', 'MyRule1')
created2 = self.sbs.create_rule(
self.topic_name, 'MySubscription', 'MyRule1')
# Assert
self.assertTrue(created1)
self.assertFalse(created2)
def test_create_rule_with_already_existing_rule_fail_on_exist(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
# Act
created = self.sbs.create_rule(
self.topic_name, 'MySubscription', 'MyRule1')
with self.assertRaises(WindowsAzureError):
self.sbs.create_rule(
self.topic_name, 'MySubscription', 'MyRule1', None, True)
# Assert
self.assertTrue(created)
def test_create_rule_with_options_sql_filter(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
# Act
rule1 = Rule()
rule1.filter_type = 'SqlFilter'
rule1.filter_expression = 'foo > 40'
created = self.sbs.create_rule(
self.topic_name, 'MySubscription', 'MyRule1', rule1)
# Assert
self.assertTrue(created)
def test_create_rule_with_options_true_filter(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
# Act
rule1 = Rule()
rule1.filter_type = 'TrueFilter'
rule1.filter_expression = '1=1'
created = self.sbs.create_rule(
self.topic_name, 'MySubscription', 'MyRule1', rule1)
# Assert
self.assertTrue(created)
def test_create_rule_with_options_false_filter(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
# Act
rule1 = Rule()
rule1.filter_type = 'FalseFilter'
rule1.filter_expression = '1=0'
created = self.sbs.create_rule(
self.topic_name, 'MySubscription', 'MyRule1', rule1)
# Assert
self.assertTrue(created)
def test_create_rule_with_options_correlation_filter(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
# Act
rule1 = Rule()
rule1.filter_type = 'CorrelationFilter'
rule1.filter_expression = 'myid'
created = self.sbs.create_rule(
self.topic_name, 'MySubscription', 'MyRule1', rule1)
# Assert
self.assertTrue(created)
def test_create_rule_with_options_empty_rule_action(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
# Act
rule1 = Rule()
rule1.action_type = 'EmptyRuleAction'
rule1.action_expression = ''
created = self.sbs.create_rule(
self.topic_name, 'MySubscription', 'MyRule1', rule1)
# Assert
self.assertTrue(created)
def test_create_rule_with_options_sql_rule_action(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
# Act
rule1 = Rule()
rule1.action_type = 'SqlRuleAction'
rule1.action_expression = "SET foo = 5"
created = self.sbs.create_rule(
self.topic_name, 'MySubscription', 'MyRule1', rule1)
# Assert
self.assertTrue(created)
def test_list_rules(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
resp = self.sbs.create_rule(
self.topic_name, 'MySubscription', 'MyRule2')
# Act
rules = self.sbs.list_rules(self.topic_name, 'MySubscription')
# Assert
self.assertEquals(len(rules), 2)
def test_get_rule_with_existing_rule(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
# Act
rule = self.sbs.get_rule(self.topic_name, 'MySubscription', '$Default')
# Assert
self.assertIsNotNone(rule)
self.assertEquals(rule.name, '$Default')
def test_get_rule_with_non_existing_rule(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
# Act
with self.assertRaises(WindowsAzureError):
self.sbs.get_rule(self.topic_name,
'MySubscription', 'NonExistingRule')
# Assert
def test_get_rule_with_existing_rule_with_options(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
sent_rule = Rule()
sent_rule.filter_type = 'SqlFilter'
sent_rule.filter_expression = 'foo > 40'
sent_rule.action_type = 'SqlRuleAction'
sent_rule.action_expression = 'SET foo = 5'
self.sbs.create_rule(
self.topic_name, 'MySubscription', 'MyRule1', sent_rule)
# Act
received_rule = self.sbs.get_rule(
self.topic_name, 'MySubscription', 'MyRule1')
# Assert
self.assertIsNotNone(received_rule)
self.assertEquals(received_rule.name, 'MyRule1')
self.assertEquals(received_rule.filter_type, sent_rule.filter_type)
self.assertEquals(received_rule.filter_expression,
sent_rule.filter_expression)
self.assertEquals(received_rule.action_type, sent_rule.action_type)
self.assertEquals(received_rule.action_expression,
sent_rule.action_expression)
def test_delete_rule_with_existing_rule(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
resp = self.sbs.create_rule(
self.topic_name, 'MySubscription', 'MyRule3')
resp = self.sbs.create_rule(
self.topic_name, 'MySubscription', 'MyRule4')
# Act
deleted1 = self.sbs.delete_rule(
self.topic_name, 'MySubscription', 'MyRule4')
deleted2 = self.sbs.delete_rule(
self.topic_name, 'MySubscription', '$Default')
# Assert
self.assertTrue(deleted1)
self.assertTrue(deleted2)
rules = self.sbs.list_rules(self.topic_name, 'MySubscription')
self.assertIsNotNone(rules)
self.assertEquals(len(rules), 1)
self.assertEquals(rules[0].name, 'MyRule3')
def test_delete_rule_with_existing_rule_fail_not_exist(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
resp = self.sbs.create_rule(
self.topic_name, 'MySubscription', 'MyRule3')
resp = self.sbs.create_rule(
self.topic_name, 'MySubscription', 'MyRule4')
# Act
deleted1 = self.sbs.delete_rule(
self.topic_name, 'MySubscription', 'MyRule4', True)
deleted2 = self.sbs.delete_rule(
self.topic_name, 'MySubscription', '$Default', True)
# Assert
self.assertTrue(deleted1)
self.assertTrue(deleted2)
rules = self.sbs.list_rules(self.topic_name, 'MySubscription')
self.assertIsNotNone(rules)
self.assertEquals(len(rules), 1)
self.assertEquals(rules[0].name, 'MyRule3')
def test_delete_rule_with_non_existing_rule(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
# Act
deleted = self.sbs.delete_rule(
self.topic_name, 'MySubscription', 'NonExistingRule')
# Assert
self.assertFalse(deleted)
def test_delete_rule_with_non_existing_rule_fail_not_exist(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
# Act
with self.assertRaises(WindowsAzureError):
self.sbs.delete_rule(
self.topic_name, 'MySubscription', 'NonExistingRule', True)
# Assert
def test_send_topic_message(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
sent_msg = Message('subscription message')
# Act
self.sbs.send_topic_message(self.topic_name, sent_msg)
# Assert
def test_receive_subscription_message_read_delete_mode(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
sent_msg = Message('subscription message')
self.sbs.send_topic_message(self.topic_name, sent_msg)
# Act
received_msg = self.sbs.receive_subscription_message(
self.topic_name, 'MySubscription', False)
# Assert
self.assertIsNotNone(received_msg)
self.assertEquals(sent_msg.body, received_msg.body)
def test_receive_subscription_message_read_delete_mode_throws_on_delete(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
sent_msg = Message('subscription message')
self.sbs.send_topic_message(self.topic_name, sent_msg)
# Act
received_msg = self.sbs.receive_subscription_message(
self.topic_name, 'MySubscription', False)
with self.assertRaises(WindowsAzureError):
received_msg.delete()
# Assert
def test_receive_subscription_message_read_delete_mode_throws_on_unlock(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
sent_msg = Message('subscription message')
self.sbs.send_topic_message(self.topic_name, sent_msg)
# Act
received_msg = self.sbs.receive_subscription_message(
self.topic_name, 'MySubscription', False)
with self.assertRaises(WindowsAzureError):
received_msg.unlock()
# Assert
def test_receive_subscription_message_peek_lock_mode(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
sent_msg = Message('subscription message')
self.sbs.send_topic_message(self.topic_name, sent_msg)
# Act
received_msg = self.sbs.receive_subscription_message(
self.topic_name, 'MySubscription', True, 5)
# Assert
self.assertIsNotNone(received_msg)
self.assertEquals(sent_msg.body, received_msg.body)
def test_receive_subscription_message_delete(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
sent_msg = Message('subscription message')
self.sbs.send_topic_message(self.topic_name, sent_msg)
# Act
received_msg = self.sbs.receive_subscription_message(
self.topic_name, 'MySubscription', True, 5)
received_msg.delete()
# Assert
self.assertIsNotNone(received_msg)
self.assertEquals(sent_msg.body, received_msg.body)
def test_receive_subscription_message_unlock(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
sent_msg = Message('subscription message')
self.sbs.send_topic_message(self.topic_name, sent_msg)
# Act
received_msg = self.sbs.receive_subscription_message(
self.topic_name, 'MySubscription', True)
received_msg.unlock()
# Assert
received_again_msg = self.sbs.receive_subscription_message(
self.topic_name, 'MySubscription', True)
received_again_msg.delete()
self.assertIsNotNone(received_msg)
self.assertIsNotNone(received_again_msg)
self.assertEquals(sent_msg.body, received_msg.body)
self.assertEquals(received_again_msg.body, received_msg.body)
def test_with_filter(self):
# Single filter
called = []
def my_filter(request, next):
called.append(True)
return next(request)
sbs = self.sbs.with_filter(my_filter)
sbs.create_topic(self.topic_name + '0', None, True)
self.assertTrue(called)
del called[:]
sbs.delete_topic(self.topic_name + '0')
self.assertTrue(called)
del called[:]
# Chained filters
def filter_a(request, next):
called.append('a')
return next(request)
def filter_b(request, next):
called.append('b')
return next(request)
sbs = self.sbs.with_filter(filter_a).with_filter(filter_b)
sbs.create_topic(self.topic_name + '0', None, True)
self.assertEqual(called, ['b', 'a'])
sbs.delete_topic(self.topic_name + '0')
self.assertEqual(called, ['b', 'a', 'b', 'a'])
def test_two_identities(self):
# In order to run this test, 2 service bus service identities are created using
# the sbaztool available at:
# http://code.msdn.microsoft.com/windowsazure/Authorization-SBAzTool-6fd76d93
#
# Use the following commands to create 2 identities and grant access rights.
# Replace <servicebusnamespace> with the namespace specified in the test .json file
# Replace <servicebuskey> with the key specified in the test .json file
# This only needs to be executed once, after the service bus namespace is created.
#
# sbaztool makeid user1 NoHEoD6snlvlhZm7yek9Etxca3l0CYjfc19ICIJZoUg= -n <servicebusnamespace> -k <servicebuskey>
# sbaztool grant Send /path1 user1 -n <servicebusnamespace> -k <servicebuskey>
# sbaztool grant Listen /path1 user1 -n <servicebusnamespace> -k <servicebuskey>
# sbaztool grant Manage /path1 user1 -n <servicebusnamespace> -k
# <servicebuskey>
# sbaztool makeid user2 Tb6K5qEgstyRBwp86JEjUezKj/a+fnkLFnibfgvxvdg= -n <servicebusnamespace> -k <servicebuskey>
# sbaztool grant Send /path2 user2 -n <servicebusnamespace> -k <servicebuskey>
# sbaztool grant Listen /path2 user2 -n <servicebusnamespace> -k <servicebuskey>
# sbaztool grant Manage /path2 user2 -n <servicebusnamespace> -k
# <servicebuskey>
sbs1 = ServiceBusService(credentials.getServiceBusNamespace(),
'NoHEoD6snlvlhZm7yek9Etxca3l0CYjfc19ICIJZoUg=',
'user1')
sbs2 = ServiceBusService(credentials.getServiceBusNamespace(),
'Tb6K5qEgstyRBwp86JEjUezKj/a+fnkLFnibfgvxvdg=',
'user2')
queue1_name = 'path1/queue' + str(random.randint(1, 10000000))
queue2_name = 'path2/queue' + str(random.randint(1, 10000000))
try:
# Create queues, success
sbs1.create_queue(queue1_name)
sbs2.create_queue(queue2_name)
# Receive messages, success
msg = sbs1.receive_queue_message(queue1_name, True, 1)
self.assertIsNone(msg.body)
msg = sbs1.receive_queue_message(queue1_name, True, 1)
self.assertIsNone(msg.body)
msg = sbs2.receive_queue_message(queue2_name, True, 1)
self.assertIsNone(msg.body)
msg = sbs2.receive_queue_message(queue2_name, True, 1)
self.assertIsNone(msg.body)
# Receive messages, failure
with self.assertRaises(HTTPError):
msg = sbs1.receive_queue_message(queue2_name, True, 1)
with self.assertRaises(HTTPError):
msg = sbs2.receive_queue_message(queue1_name, True, 1)
finally:
try:
sbs1.delete_queue(queue1_name)
except:
pass
try:
sbs2.delete_queue(queue2_name)
except:
pass
def test_unicode_create_queue_unicode_name(self):
# Arrange
self.queue_name = self.queue_name + u'啊齄丂狛狜'
# Act
with self.assertRaises(WindowsAzureError):
created = self.sbs.create_queue(self.queue_name)
# Assert
def test_unicode_receive_queue_message_unicode_data(self):
# Assert
sent_msg = Message('receive message啊齄丂狛狜')
self._create_queue_and_send_msg(self.queue_name, sent_msg)
# Act
received_msg = self.sbs.receive_queue_message(self.queue_name, False)
# Assert
self.assertIsNotNone(received_msg)
self.assertEquals(sent_msg.body, received_msg.body)
def test_unicode_receive_queue_message_binary_data(self):
# Assert
base64_data = 'AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/wABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoKSorLC0uLzAxMjM0NTY3ODk6Ozw9Pj9AQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVpbXF1eX2BhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ent8fX5/gIGCg4SFhoeIiYqLjI2Oj5CRkpOUlZaXmJmam5ydnp+goaKjpKWmp6ipqqusra6vsLGys7S1tre4ubq7vL2+v8DBwsPExcbHyMnKy8zNzs/Q0dLT1NXW19jZ2tvc3d7f4OHi4+Tl5ufo6err7O3u7/Dx8vP09fb3+Pn6+/z9/v8AAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5Ojs8PT4/QEFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaW1xdXl9gYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXp7fH1+f4CBgoOEhYaHiImKi4yNjo+QkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/AwcLDxMXGx8jJysvMzc7P0NHS09TV1tfY2drb3N3e3+Dh4uPk5ebn6Onq6+zt7u/w8fLz9PX29/j5+vv8/f7/AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w=='
binary_data = base64.b64decode(base64_data)
sent_msg = Message(binary_data)
self._create_queue_and_send_msg(self.queue_name, sent_msg)
# Act
received_msg = self.sbs.receive_queue_message(self.queue_name, False)
# Assert
self.assertIsNotNone(received_msg)
self.assertEquals(sent_msg.body, received_msg.body)
def test_unicode_create_subscription_unicode_name(self):
# Arrange
self._create_topic(self.topic_name)
# Act
with self.assertRaises(WindowsAzureError):
created = self.sbs.create_subscription(
self.topic_name, u'MySubscription啊齄丂狛狜')
# Assert
def test_unicode_create_rule_unicode_name(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
# Act
with self.assertRaises(WindowsAzureError):
created = self.sbs.create_rule(
self.topic_name, 'MySubscription', 'MyRule啊齄丂狛狜')
# Assert
def test_unicode_receive_subscription_message_unicode_data(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
sent_msg = Message('subscription message啊齄丂狛狜')
self.sbs.send_topic_message(self.topic_name, sent_msg)
# Act
received_msg = self.sbs.receive_subscription_message(
self.topic_name, 'MySubscription', False)
# Assert
self.assertIsNotNone(received_msg)
self.assertEquals(sent_msg.body, received_msg.body)
def test_unicode_receive_subscription_message_binary_data(self):
# Arrange
base64_data = 'AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/wABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoKSorLC0uLzAxMjM0NTY3ODk6Ozw9Pj9AQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVpbXF1eX2BhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ent8fX5/gIGCg4SFhoeIiYqLjI2Oj5CRkpOUlZaXmJmam5ydnp+goaKjpKWmp6ipqqusra6vsLGys7S1tre4ubq7vL2+v8DBwsPExcbHyMnKy8zNzs/Q0dLT1NXW19jZ2tvc3d7f4OHi4+Tl5ufo6err7O3u7/Dx8vP09fb3+Pn6+/z9/v8AAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5Ojs8PT4/QEFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaW1xdXl9gYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXp7fH1+f4CBgoOEhYaHiImKi4yNjo+QkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/AwcLDxMXGx8jJysvMzc7P0NHS09TV1tfY2drb3N3e3+Dh4uPk5ebn6Onq6+zt7u/w8fLz9PX29/j5+vv8/f7/AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w=='
binary_data = base64.b64decode(base64_data)
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
sent_msg = Message(binary_data)
self.sbs.send_topic_message(self.topic_name, sent_msg)
# Act
received_msg = self.sbs.receive_subscription_message(
self.topic_name, 'MySubscription', False)
# Assert
self.assertIsNotNone(received_msg)
self.assertEquals(sent_msg.body, received_msg.body)
class ServiceBusTest(AzureTestCase):
def setUp(self):
self.sbs = ServiceBusService(credentials.getServiceBusNamespace(),
credentials.getServiceBusKey(), 'owner')
proxy_host = credentials.getProxyHost()
proxy_port = credentials.getProxyPort()
if proxy_host:
self.sbs.set_proxy(proxy_host, proxy_port)
__uid = getUniqueTestRunID()
queue_base_name = u'mytestqueue%s' % (__uid)
topic_base_name = u'mytesttopic%s' % (__uid)
self.queue_name = getUniqueNameBasedOnCurrentTime(queue_base_name)
self.topic_name = getUniqueNameBasedOnCurrentTime(topic_base_name)
self.additional_queue_names = []
self.additional_topic_names = []
def tearDown(self):
self.cleanup()
return super(ServiceBusTest, self).tearDown()
def cleanup(self):
try:
self.sbs.delete_queue(self.queue_name)
except:
pass
for name in self.additional_queue_names:
try:
self.sbs.delete_queue(name)
except:
pass
try:
self.sbs.delete_topic(self.topic_name)
except:
pass
for name in self.additional_topic_names:
try:
self.sbs.delete_topic(name)
except:
pass
#--Helpers-----------------------------------------------------------------
def _create_queue(self, queue_name):
self.sbs.create_queue(queue_name, None, True)
def _create_queue_and_send_msg(self, queue_name, msg):
self._create_queue(queue_name)
self.sbs.send_queue_message(queue_name, msg)
def _create_topic(self, topic_name):
self.sbs.create_topic(topic_name, None, True)
def _create_topic_and_subscription(self, topic_name, subscription_name):
self._create_topic(topic_name)
self._create_subscription(topic_name, subscription_name)
def _create_subscription(self, topic_name, subscription_name):
self.sbs.create_subscription(topic_name, subscription_name, None, True)
#--Test cases for service bus service -------------------------------------
def test_create_service_bus_missing_arguments(self):
# Arrange
if os.environ.has_key(AZURE_SERVICEBUS_NAMESPACE):
del os.environ[AZURE_SERVICEBUS_NAMESPACE]
if os.environ.has_key(AZURE_SERVICEBUS_ACCESS_KEY):
del os.environ[AZURE_SERVICEBUS_ACCESS_KEY]
if os.environ.has_key(AZURE_SERVICEBUS_ISSUER):
del os.environ[AZURE_SERVICEBUS_ISSUER]
# Act
with self.assertRaises(WindowsAzureError):
sbs = ServiceBusService()
# Assert
def test_create_service_bus_env_variables(self):
# Arrange
os.environ[
AZURE_SERVICEBUS_NAMESPACE] = credentials.getServiceBusNamespace()
os.environ[AZURE_SERVICEBUS_ACCESS_KEY] = credentials.getServiceBusKey(
)
os.environ[AZURE_SERVICEBUS_ISSUER] = 'owner'
# Act
sbs = ServiceBusService()
if os.environ.has_key(AZURE_SERVICEBUS_NAMESPACE):
del os.environ[AZURE_SERVICEBUS_NAMESPACE]
if os.environ.has_key(AZURE_SERVICEBUS_ACCESS_KEY):
del os.environ[AZURE_SERVICEBUS_ACCESS_KEY]
if os.environ.has_key(AZURE_SERVICEBUS_ISSUER):
del os.environ[AZURE_SERVICEBUS_ISSUER]
# Assert
self.assertIsNotNone(sbs)
self.assertEquals(sbs.service_namespace,
credentials.getServiceBusNamespace())
self.assertEquals(sbs.account_key, credentials.getServiceBusKey())
self.assertEquals(sbs.issuer, 'owner')
#--Test cases for queues --------------------------------------------------
def test_create_queue_no_options(self):
# Arrange
# Act
created = self.sbs.create_queue(self.queue_name)
# Assert
self.assertTrue(created)
def test_create_queue_no_options_fail_on_exist(self):
# Arrange
# Act
created = self.sbs.create_queue(self.queue_name, None, True)
# Assert
self.assertTrue(created)
def test_create_queue_with_options(self):
# Arrange
# Act
queue_options = Queue()
queue_options.default_message_time_to_live = 'PT1M'
queue_options.duplicate_detection_history_time_window = 'PT5M'
queue_options.enable_batched_operations = False
queue_options.dead_lettering_on_message_expiration = False
queue_options.lock_duration = 'PT1M'
queue_options.max_delivery_count = 15
queue_options.max_size_in_megabytes = 5120
queue_options.message_count = 0
queue_options.requires_duplicate_detection = False
queue_options.requires_session = False
queue_options.size_in_bytes = 0
created = self.sbs.create_queue(self.queue_name, queue_options)
# Assert
self.assertTrue(created)
queue = self.sbs.get_queue(self.queue_name)
self.assertEquals('PT1M', queue.default_message_time_to_live)
self.assertEquals('PT5M',
queue.duplicate_detection_history_time_window)
self.assertEquals(False, queue.enable_batched_operations)
self.assertEquals(False, queue.dead_lettering_on_message_expiration)
self.assertEquals('PT1M', queue.lock_duration)
self.assertEquals(15, queue.max_delivery_count)
self.assertEquals(5120, queue.max_size_in_megabytes)
self.assertEquals(0, queue.message_count)
self.assertEquals(False, queue.requires_duplicate_detection)
self.assertEquals(False, queue.requires_session)
self.assertEquals(0, queue.size_in_bytes)
def test_create_queue_with_already_existing_queue(self):
# Arrange
# Act
created1 = self.sbs.create_queue(self.queue_name)
created2 = self.sbs.create_queue(self.queue_name)
# Assert
self.assertTrue(created1)
self.assertFalse(created2)
def test_create_queue_with_already_existing_queue_fail_on_exist(self):
# Arrange
# Act
created = self.sbs.create_queue(self.queue_name)
with self.assertRaises(WindowsAzureError):
self.sbs.create_queue(self.queue_name, None, True)
# Assert
self.assertTrue(created)
def test_get_queue_with_existing_queue(self):
# Arrange
self._create_queue(self.queue_name)
# Act
queue = self.sbs.get_queue(self.queue_name)
# Assert
self.assertIsNotNone(queue)
self.assertEquals(queue.name, self.queue_name)
def test_get_queue_with_non_existing_queue(self):
# Arrange
# Act
with self.assertRaises(WindowsAzureError):
resp = self.sbs.get_queue(self.queue_name)
# Assert
def test_list_queues(self):
# Arrange
self._create_queue(self.queue_name)
# Act
queues = self.sbs.list_queues()
for queue in queues:
name = queue.name
# Assert
self.assertIsNotNone(queues)
self.assertNamedItemInContainer(queues, self.queue_name)
def test_list_queues_with_special_chars(self):
# Arrange
# Name must start and end with an alphanumeric and can only contain
# letters, numbers, periods, hyphens, forward slashes and underscores.
other_queue_name = self.queue_name + 'foo/.-_123'
self.additional_queue_names = [other_queue_name]
self._create_queue(other_queue_name)
# Act
queues = self.sbs.list_queues()
# Assert
self.assertIsNotNone(queues)
self.assertNamedItemInContainer(queues, other_queue_name)
def test_delete_queue_with_existing_queue(self):
# Arrange
self._create_queue(self.queue_name)
# Act
deleted = self.sbs.delete_queue(self.queue_name)
# Assert
self.assertTrue(deleted)
queues = self.sbs.list_queues()
self.assertNamedItemNotInContainer(queues, self.queue_name)
def test_delete_queue_with_existing_queue_fail_not_exist(self):
# Arrange
self._create_queue(self.queue_name)
# Act
deleted = self.sbs.delete_queue(self.queue_name, True)
# Assert
self.assertTrue(deleted)
queues = self.sbs.list_queues()
self.assertNamedItemNotInContainer(queues, self.queue_name)
def test_delete_queue_with_non_existing_queue(self):
# Arrange
# Act
deleted = self.sbs.delete_queue(self.queue_name)
# Assert
self.assertFalse(deleted)
def test_delete_queue_with_non_existing_queue_fail_not_exist(self):
# Arrange
# Act
with self.assertRaises(WindowsAzureError):
self.sbs.delete_queue(self.queue_name, True)
# Assert
def test_send_queue_message(self):
# Arrange
self._create_queue(self.queue_name)
sent_msg = Message('send message')
# Act
self.sbs.send_queue_message(self.queue_name, sent_msg)
# Assert
def test_receive_queue_message_read_delete_mode(self):
# Assert
sent_msg = Message('receive message')
self._create_queue_and_send_msg(self.queue_name, sent_msg)
# Act
received_msg = self.sbs.receive_queue_message(self.queue_name, False)
# Assert
self.assertIsNotNone(received_msg)
self.assertEquals(sent_msg.body, received_msg.body)
def test_receive_queue_message_read_delete_mode_throws_on_delete(self):
# Assert
sent_msg = Message('receive message')
self._create_queue_and_send_msg(self.queue_name, sent_msg)
# Act
received_msg = self.sbs.receive_queue_message(self.queue_name, False)
with self.assertRaises(WindowsAzureError):
received_msg.delete()
# Assert
def test_receive_queue_message_read_delete_mode_throws_on_unlock(self):
# Assert
sent_msg = Message('receive message')
self._create_queue_and_send_msg(self.queue_name, sent_msg)
# Act
received_msg = self.sbs.receive_queue_message(self.queue_name, False)
with self.assertRaises(WindowsAzureError):
received_msg.unlock()
# Assert
def test_receive_queue_message_peek_lock_mode(self):
# Arrange
sent_msg = Message('peek lock message')
self._create_queue_and_send_msg(self.queue_name, sent_msg)
# Act
received_msg = self.sbs.receive_queue_message(self.queue_name, True)
# Assert
self.assertIsNotNone(received_msg)
self.assertEquals(sent_msg.body, received_msg.body)
def test_receive_queue_message_delete(self):
# Arrange
sent_msg = Message('peek lock message delete')
self._create_queue_and_send_msg(self.queue_name, sent_msg)
# Act
received_msg = self.sbs.receive_queue_message(self.queue_name, True)
received_msg.delete()
# Assert
self.assertIsNotNone(received_msg)
self.assertEquals(sent_msg.body, received_msg.body)
def test_receive_queue_message_unlock(self):
# Arrange
sent_msg = Message('peek lock message unlock')
self._create_queue_and_send_msg(self.queue_name, sent_msg)
# Act
received_msg = self.sbs.receive_queue_message(self.queue_name, True)
received_msg.unlock()
# Assert
received_again_msg = self.sbs.receive_queue_message(
self.queue_name, True)
received_again_msg.delete()
self.assertIsNotNone(received_msg)
self.assertIsNotNone(received_again_msg)
self.assertEquals(sent_msg.body, received_msg.body)
self.assertEquals(received_again_msg.body, received_msg.body)
def test_send_queue_message_with_custom_message_type(self):
# Arrange
self._create_queue(self.queue_name)
# Act
sent_msg = Message(
'<text>peek lock message custom message type</text>',
type='text/xml')
self.sbs.send_queue_message(self.queue_name, sent_msg)
received_msg = self.sbs.receive_queue_message(self.queue_name, True, 5)
received_msg.delete()
# Assert
self.assertIsNotNone(received_msg)
self.assertEquals('text/xml', received_msg.type)
def test_send_queue_message_with_custom_message_properties(self):
# Arrange
self._create_queue(self.queue_name)
# Act
props = {
'hello': 'world',
'foo': 42,
'active': True,
'deceased': False,
'large': 8555111000,
'floating': 3.14,
'dob': datetime(2011, 12, 14)
}
sent_msg = Message('message with properties', custom_properties=props)
self.sbs.send_queue_message(self.queue_name, sent_msg)
received_msg = self.sbs.receive_queue_message(self.queue_name, True, 5)
received_msg.delete()
# Assert
self.assertIsNotNone(received_msg)
self.assertEquals(received_msg.custom_properties['hello'], 'world')
self.assertEquals(received_msg.custom_properties['foo'], 42)
self.assertEquals(received_msg.custom_properties['active'], True)
self.assertEquals(received_msg.custom_properties['deceased'], False)
self.assertEquals(received_msg.custom_properties['large'], 8555111000)
self.assertEquals(received_msg.custom_properties['floating'], 3.14)
self.assertEquals(received_msg.custom_properties['dob'],
datetime(2011, 12, 14))
def test_receive_queue_message_timeout_5(self):
# Arrange
self._create_queue(self.queue_name)
# Act
start = time.clock()
received_msg = self.sbs.receive_queue_message(self.queue_name, True, 5)
duration = time.clock() - start
# Assert
self.assertTrue(duration > 3 and duration < 7)
self.assertIsNotNone(received_msg)
self.assertIsNone(received_msg.body)
def test_receive_queue_message_timeout_50(self):
# Arrange
self._create_queue(self.queue_name)
# Act
start = time.clock()
received_msg = self.sbs.receive_queue_message(self.queue_name, True,
50)
duration = time.clock() - start
# Assert
self.assertTrue(duration > 48 and duration < 52)
self.assertIsNotNone(received_msg)
self.assertIsNone(received_msg.body)
#--Test cases for topics/subscriptions ------------------------------------
def test_create_topic_no_options(self):
# Arrange
# Act
created = self.sbs.create_topic(self.topic_name)
# Assert
self.assertTrue(created)
def test_create_topic_no_options_fail_on_exist(self):
# Arrange
# Act
created = self.sbs.create_topic(self.topic_name, None, True)
# Assert
self.assertTrue(created)
def test_create_topic_with_options(self):
# Arrange
# Act
topic_options = Topic()
topic_options.default_message_time_to_live = 'PT1M'
topic_options.duplicate_detection_history_time_window = 'PT5M'
topic_options.enable_batched_operations = False
topic_options.max_size_in_megabytes = 5120
topic_options.requires_duplicate_detection = False
topic_options.size_in_bytes = 0
#TODO: MaximumNumberOfSubscriptions is not supported?
created = self.sbs.create_topic(self.topic_name, topic_options)
# Assert
self.assertTrue(created)
topic = self.sbs.get_topic(self.topic_name)
self.assertEquals('PT1M', topic.default_message_time_to_live)
self.assertEquals('PT5M',
topic.duplicate_detection_history_time_window)
self.assertEquals(False, topic.enable_batched_operations)
self.assertEquals(5120, topic.max_size_in_megabytes)
self.assertEquals(False, topic.requires_duplicate_detection)
self.assertEquals(0, topic.size_in_bytes)
def test_create_topic_with_already_existing_topic(self):
# Arrange
# Act
created1 = self.sbs.create_topic(self.topic_name)
created2 = self.sbs.create_topic(self.topic_name)
# Assert
self.assertTrue(created1)
self.assertFalse(created2)
def test_create_topic_with_already_existing_topic_fail_on_exist(self):
# Arrange
# Act
created = self.sbs.create_topic(self.topic_name)
with self.assertRaises(WindowsAzureError):
self.sbs.create_topic(self.topic_name, None, True)
# Assert
self.assertTrue(created)
def test_topic_backwards_compatibility_warning(self):
# Arrange
topic_options = Topic()
topic_options.max_size_in_megabytes = 5120
# Act
val = topic_options.max_size_in_mega_bytes
# Assert
self.assertEqual(val, 5120)
# Act
topic_options.max_size_in_mega_bytes = 1024
# Assert
self.assertEqual(topic_options.max_size_in_megabytes, 1024)
def test_get_topic_with_existing_topic(self):
# Arrange
self._create_topic(self.topic_name)
# Act
topic = self.sbs.get_topic(self.topic_name)
# Assert
self.assertIsNotNone(topic)
self.assertEquals(topic.name, self.topic_name)
def test_get_topic_with_non_existing_topic(self):
# Arrange
# Act
with self.assertRaises(WindowsAzureError):
self.sbs.get_topic(self.topic_name)
# Assert
def test_list_topics(self):
# Arrange
self._create_topic(self.topic_name)
# Act
topics = self.sbs.list_topics()
for topic in topics:
name = topic.name
# Assert
self.assertIsNotNone(topics)
self.assertNamedItemInContainer(topics, self.topic_name)
def test_list_topics_with_special_chars(self):
# Arrange
# Name must start and end with an alphanumeric and can only contain
# letters, numbers, periods, hyphens, forward slashes and underscores.
other_topic_name = self.topic_name + 'foo/.-_123'
self.additional_topic_names = [other_topic_name]
self._create_topic(other_topic_name)
# Act
topics = self.sbs.list_topics()
# Assert
self.assertIsNotNone(topics)
self.assertNamedItemInContainer(topics, other_topic_name)
def test_delete_topic_with_existing_topic(self):
# Arrange
self._create_topic(self.topic_name)
# Act
deleted = self.sbs.delete_topic(self.topic_name)
# Assert
self.assertTrue(deleted)
topics = self.sbs.list_topics()
self.assertNamedItemNotInContainer(topics, self.topic_name)
def test_delete_topic_with_existing_topic_fail_not_exist(self):
# Arrange
self._create_topic(self.topic_name)
# Act
deleted = self.sbs.delete_topic(self.topic_name, True)
# Assert
self.assertTrue(deleted)
topics = self.sbs.list_topics()
self.assertNamedItemNotInContainer(topics, self.topic_name)
def test_delete_topic_with_non_existing_topic(self):
# Arrange
# Act
deleted = self.sbs.delete_topic(self.topic_name)
# Assert
self.assertFalse(deleted)
def test_delete_topic_with_non_existing_topic_fail_not_exist(self):
# Arrange
# Act
with self.assertRaises(WindowsAzureError):
self.sbs.delete_topic(self.topic_name, True)
# Assert
def test_create_subscription(self):
# Arrange
self._create_topic(self.topic_name)
# Act
created = self.sbs.create_subscription(self.topic_name,
'MySubscription')
# Assert
self.assertTrue(created)
def test_create_subscription_with_options(self):
# Arrange
self._create_topic(self.topic_name)
# Act
subscription_options = Subscription()
subscription_options.dead_lettering_on_filter_evaluation_exceptions = False
subscription_options.dead_lettering_on_message_expiration = False
subscription_options.default_message_time_to_live = 'PT15M'
subscription_options.enable_batched_operations = False
subscription_options.lock_duration = 'PT1M'
subscription_options.max_delivery_count = 15
#message_count is read-only
subscription_options.message_count = 0
subscription_options.requires_session = False
created = self.sbs.create_subscription(self.topic_name,
'MySubscription',
subscription_options)
# Assert
self.assertTrue(created)
subscription = self.sbs.get_subscription(self.topic_name,
'MySubscription')
self.assertEquals(
False, subscription.dead_lettering_on_filter_evaluation_exceptions)
self.assertEquals(False,
subscription.dead_lettering_on_message_expiration)
self.assertEquals('PT15M', subscription.default_message_time_to_live)
self.assertEquals(False, subscription.enable_batched_operations)
self.assertEquals('PT1M', subscription.lock_duration)
#self.assertEquals(15, subscription.max_delivery_count) #no idea why max_delivery_count is always 10
self.assertEquals(0, subscription.message_count)
self.assertEquals(False, subscription.requires_session)
def test_create_subscription_fail_on_exist(self):
# Arrange
self._create_topic(self.topic_name)
# Act
created = self.sbs.create_subscription(self.topic_name,
'MySubscription', None, True)
# Assert
self.assertTrue(created)
def test_create_subscription_with_already_existing_subscription(self):
# Arrange
self._create_topic(self.topic_name)
# Act
created1 = self.sbs.create_subscription(self.topic_name,
'MySubscription')
created2 = self.sbs.create_subscription(self.topic_name,
'MySubscription')
# Assert
self.assertTrue(created1)
self.assertFalse(created2)
def test_create_subscription_with_already_existing_subscription_fail_on_exist(
self):
# Arrange
self._create_topic(self.topic_name)
# Act
created = self.sbs.create_subscription(self.topic_name,
'MySubscription')
with self.assertRaises(WindowsAzureError):
self.sbs.create_subscription(self.topic_name, 'MySubscription',
None, True)
# Assert
self.assertTrue(created)
def test_list_subscriptions(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription2')
# Act
subscriptions = self.sbs.list_subscriptions(self.topic_name)
# Assert
self.assertIsNotNone(subscriptions)
self.assertEquals(len(subscriptions), 1)
self.assertEquals(subscriptions[0].name, 'MySubscription2')
def test_get_subscription_with_existing_subscription(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription3')
# Act
subscription = self.sbs.get_subscription(self.topic_name,
'MySubscription3')
# Assert
self.assertIsNotNone(subscription)
self.assertEquals(subscription.name, 'MySubscription3')
def test_get_subscription_with_non_existing_subscription(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription3')
# Act
with self.assertRaises(WindowsAzureError):
self.sbs.get_subscription(self.topic_name, 'MySubscription4')
# Assert
def test_delete_subscription_with_existing_subscription(self):
# Arrange
self._create_topic(self.topic_name)
self._create_subscription(self.topic_name, 'MySubscription4')
self._create_subscription(self.topic_name, 'MySubscription5')
# Act
deleted = self.sbs.delete_subscription(self.topic_name,
'MySubscription4')
# Assert
self.assertTrue(deleted)
subscriptions = self.sbs.list_subscriptions(self.topic_name)
self.assertIsNotNone(subscriptions)
self.assertEquals(len(subscriptions), 1)
self.assertEquals(subscriptions[0].name, 'MySubscription5')
def test_delete_subscription_with_existing_subscription_fail_not_exist(
self):
# Arrange
self._create_topic(self.topic_name)
self._create_subscription(self.topic_name, 'MySubscription4')
self._create_subscription(self.topic_name, 'MySubscription5')
# Act
deleted = self.sbs.delete_subscription(self.topic_name,
'MySubscription4', True)
# Assert
self.assertTrue(deleted)
subscriptions = self.sbs.list_subscriptions(self.topic_name)
self.assertIsNotNone(subscriptions)
self.assertEquals(len(subscriptions), 1)
self.assertEquals(subscriptions[0].name, 'MySubscription5')
def test_delete_subscription_with_non_existing_subscription(self):
# Arrange
self._create_topic(self.topic_name)
# Act
deleted = self.sbs.delete_subscription(self.topic_name,
'MySubscription')
# Assert
self.assertFalse(deleted)
def test_delete_subscription_with_non_existing_subscription_fail_not_exist(
self):
# Arrange
self._create_topic(self.topic_name)
# Act
with self.assertRaises(WindowsAzureError):
self.sbs.delete_subscription(self.topic_name, 'MySubscription',
True)
# Assert
def test_create_rule_no_options(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
# Act
created = self.sbs.create_rule(self.topic_name, 'MySubscription',
'MyRule1')
# Assert
self.assertTrue(created)
def test_create_rule_no_options_fail_on_exist(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
# Act
created = self.sbs.create_rule(self.topic_name, 'MySubscription',
'MyRule1', None, True)
# Assert
self.assertTrue(created)
def test_create_rule_with_already_existing_rule(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
# Act
created1 = self.sbs.create_rule(self.topic_name, 'MySubscription',
'MyRule1')
created2 = self.sbs.create_rule(self.topic_name, 'MySubscription',
'MyRule1')
# Assert
self.assertTrue(created1)
self.assertFalse(created2)
def test_create_rule_with_already_existing_rule_fail_on_exist(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
# Act
created = self.sbs.create_rule(self.topic_name, 'MySubscription',
'MyRule1')
with self.assertRaises(WindowsAzureError):
self.sbs.create_rule(self.topic_name, 'MySubscription', 'MyRule1',
None, True)
# Assert
self.assertTrue(created)
def test_create_rule_with_options_sql_filter(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
# Act
rule1 = Rule()
rule1.filter_type = 'SqlFilter'
rule1.filter_expression = 'foo > 40'
created = self.sbs.create_rule(self.topic_name, 'MySubscription',
'MyRule1', rule1)
# Assert
self.assertTrue(created)
def test_create_rule_with_options_true_filter(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
# Act
rule1 = Rule()
rule1.filter_type = 'TrueFilter'
rule1.filter_expression = '1=1'
created = self.sbs.create_rule(self.topic_name, 'MySubscription',
'MyRule1', rule1)
# Assert
self.assertTrue(created)
def test_create_rule_with_options_false_filter(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
# Act
rule1 = Rule()
rule1.filter_type = 'FalseFilter'
rule1.filter_expression = '1=0'
created = self.sbs.create_rule(self.topic_name, 'MySubscription',
'MyRule1', rule1)
# Assert
self.assertTrue(created)
def test_create_rule_with_options_correlation_filter(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
# Act
rule1 = Rule()
rule1.filter_type = 'CorrelationFilter'
rule1.filter_expression = 'myid'
created = self.sbs.create_rule(self.topic_name, 'MySubscription',
'MyRule1', rule1)
# Assert
self.assertTrue(created)
def test_create_rule_with_options_empty_rule_action(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
# Act
rule1 = Rule()
rule1.action_type = 'EmptyRuleAction'
rule1.action_expression = ''
created = self.sbs.create_rule(self.topic_name, 'MySubscription',
'MyRule1', rule1)
# Assert
self.assertTrue(created)
def test_create_rule_with_options_sql_rule_action(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
# Act
rule1 = Rule()
rule1.action_type = 'SqlRuleAction'
rule1.action_expression = "SET foo = 5"
created = self.sbs.create_rule(self.topic_name, 'MySubscription',
'MyRule1', rule1)
# Assert
self.assertTrue(created)
def test_list_rules(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
resp = self.sbs.create_rule(self.topic_name, 'MySubscription',
'MyRule2')
# Act
rules = self.sbs.list_rules(self.topic_name, 'MySubscription')
# Assert
self.assertEquals(len(rules), 2)
def test_get_rule_with_existing_rule(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
# Act
rule = self.sbs.get_rule(self.topic_name, 'MySubscription', '$Default')
# Assert
self.assertIsNotNone(rule)
self.assertEquals(rule.name, '$Default')
def test_get_rule_with_non_existing_rule(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
# Act
with self.assertRaises(WindowsAzureError):
self.sbs.get_rule(self.topic_name, 'MySubscription',
'NonExistingRule')
# Assert
def test_get_rule_with_existing_rule_with_options(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
sent_rule = Rule()
sent_rule.filter_type = 'SqlFilter'
sent_rule.filter_expression = 'foo > 40'
sent_rule.action_type = 'SqlRuleAction'
sent_rule.action_expression = 'SET foo = 5'
self.sbs.create_rule(self.topic_name, 'MySubscription', 'MyRule1',
sent_rule)
# Act
received_rule = self.sbs.get_rule(self.topic_name, 'MySubscription',
'MyRule1')
# Assert
self.assertIsNotNone(received_rule)
self.assertEquals(received_rule.name, 'MyRule1')
self.assertEquals(received_rule.filter_type, sent_rule.filter_type)
self.assertEquals(received_rule.filter_expression,
sent_rule.filter_expression)
self.assertEquals(received_rule.action_type, sent_rule.action_type)
self.assertEquals(received_rule.action_expression,
sent_rule.action_expression)
def test_delete_rule_with_existing_rule(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
resp = self.sbs.create_rule(self.topic_name, 'MySubscription',
'MyRule3')
resp = self.sbs.create_rule(self.topic_name, 'MySubscription',
'MyRule4')
# Act
deleted1 = self.sbs.delete_rule(self.topic_name, 'MySubscription',
'MyRule4')
deleted2 = self.sbs.delete_rule(self.topic_name, 'MySubscription',
'$Default')
# Assert
self.assertTrue(deleted1)
self.assertTrue(deleted2)
rules = self.sbs.list_rules(self.topic_name, 'MySubscription')
self.assertIsNotNone(rules)
self.assertEquals(len(rules), 1)
self.assertEquals(rules[0].name, 'MyRule3')
def test_delete_rule_with_existing_rule_fail_not_exist(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
resp = self.sbs.create_rule(self.topic_name, 'MySubscription',
'MyRule3')
resp = self.sbs.create_rule(self.topic_name, 'MySubscription',
'MyRule4')
# Act
deleted1 = self.sbs.delete_rule(self.topic_name, 'MySubscription',
'MyRule4', True)
deleted2 = self.sbs.delete_rule(self.topic_name, 'MySubscription',
'$Default', True)
# Assert
self.assertTrue(deleted1)
self.assertTrue(deleted2)
rules = self.sbs.list_rules(self.topic_name, 'MySubscription')
self.assertIsNotNone(rules)
self.assertEquals(len(rules), 1)
self.assertEquals(rules[0].name, 'MyRule3')
def test_delete_rule_with_non_existing_rule(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
# Act
deleted = self.sbs.delete_rule(self.topic_name, 'MySubscription',
'NonExistingRule')
# Assert
self.assertFalse(deleted)
def test_delete_rule_with_non_existing_rule_fail_not_exist(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
# Act
with self.assertRaises(WindowsAzureError):
self.sbs.delete_rule(self.topic_name, 'MySubscription',
'NonExistingRule', True)
# Assert
def test_send_topic_message(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
sent_msg = Message('subscription message')
# Act
self.sbs.send_topic_message(self.topic_name, sent_msg)
# Assert
def test_receive_subscription_message_read_delete_mode(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
sent_msg = Message('subscription message')
self.sbs.send_topic_message(self.topic_name, sent_msg)
# Act
received_msg = self.sbs.receive_subscription_message(
self.topic_name, 'MySubscription', False)
# Assert
self.assertIsNotNone(received_msg)
self.assertEquals(sent_msg.body, received_msg.body)
def test_receive_subscription_message_read_delete_mode_throws_on_delete(
self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
sent_msg = Message('subscription message')
self.sbs.send_topic_message(self.topic_name, sent_msg)
# Act
received_msg = self.sbs.receive_subscription_message(
self.topic_name, 'MySubscription', False)
with self.assertRaises(WindowsAzureError):
received_msg.delete()
# Assert
def test_receive_subscription_message_read_delete_mode_throws_on_unlock(
self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
sent_msg = Message('subscription message')
self.sbs.send_topic_message(self.topic_name, sent_msg)
# Act
received_msg = self.sbs.receive_subscription_message(
self.topic_name, 'MySubscription', False)
with self.assertRaises(WindowsAzureError):
received_msg.unlock()
# Assert
def test_receive_subscription_message_peek_lock_mode(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
sent_msg = Message('subscription message')
self.sbs.send_topic_message(self.topic_name, sent_msg)
# Act
received_msg = self.sbs.receive_subscription_message(
self.topic_name, 'MySubscription', True, 5)
# Assert
self.assertIsNotNone(received_msg)
self.assertEquals(sent_msg.body, received_msg.body)
def test_receive_subscription_message_delete(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
sent_msg = Message('subscription message')
self.sbs.send_topic_message(self.topic_name, sent_msg)
# Act
received_msg = self.sbs.receive_subscription_message(
self.topic_name, 'MySubscription', True, 5)
received_msg.delete()
# Assert
self.assertIsNotNone(received_msg)
self.assertEquals(sent_msg.body, received_msg.body)
def test_receive_subscription_message_unlock(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
sent_msg = Message('subscription message')
self.sbs.send_topic_message(self.topic_name, sent_msg)
# Act
received_msg = self.sbs.receive_subscription_message(
self.topic_name, 'MySubscription', True)
received_msg.unlock()
# Assert
received_again_msg = self.sbs.receive_subscription_message(
self.topic_name, 'MySubscription', True)
received_again_msg.delete()
self.assertIsNotNone(received_msg)
self.assertIsNotNone(received_again_msg)
self.assertEquals(sent_msg.body, received_msg.body)
self.assertEquals(received_again_msg.body, received_msg.body)
def test_with_filter(self):
# Single filter
called = []
def my_filter(request, next):
called.append(True)
return next(request)
sbs = self.sbs.with_filter(my_filter)
sbs.create_topic(self.topic_name + '0', None, True)
self.assertTrue(called)
del called[:]
sbs.delete_topic(self.topic_name + '0')
self.assertTrue(called)
del called[:]
# Chained filters
def filter_a(request, next):
called.append('a')
return next(request)
def filter_b(request, next):
called.append('b')
return next(request)
sbs = self.sbs.with_filter(filter_a).with_filter(filter_b)
sbs.create_topic(self.topic_name + '0', None, True)
self.assertEqual(called, ['b', 'a'])
sbs.delete_topic(self.topic_name + '0')
self.assertEqual(called, ['b', 'a', 'b', 'a'])
def test_two_identities(self):
# In order to run this test, 2 service bus service identities are created using
# the sbaztool available at:
# http://code.msdn.microsoft.com/windowsazure/Authorization-SBAzTool-6fd76d93
#
# Use the following commands to create 2 identities and grant access rights.
# Replace <servicebusnamespace> with the namespace specified in the test .json file
# Replace <servicebuskey> with the key specified in the test .json file
# This only needs to be executed once, after the service bus namespace is created.
#
# sbaztool makeid user1 NoHEoD6snlvlhZm7yek9Etxca3l0CYjfc19ICIJZoUg= -n <servicebusnamespace> -k <servicebuskey>
# sbaztool grant Send /path1 user1 -n <servicebusnamespace> -k <servicebuskey>
# sbaztool grant Listen /path1 user1 -n <servicebusnamespace> -k <servicebuskey>
# sbaztool grant Manage /path1 user1 -n <servicebusnamespace> -k <servicebuskey>
# sbaztool makeid user2 Tb6K5qEgstyRBwp86JEjUezKj/a+fnkLFnibfgvxvdg= -n <servicebusnamespace> -k <servicebuskey>
# sbaztool grant Send /path2 user2 -n <servicebusnamespace> -k <servicebuskey>
# sbaztool grant Listen /path2 user2 -n <servicebusnamespace> -k <servicebuskey>
# sbaztool grant Manage /path2 user2 -n <servicebusnamespace> -k <servicebuskey>
sbs1 = ServiceBusService(
credentials.getServiceBusNamespace(),
'NoHEoD6snlvlhZm7yek9Etxca3l0CYjfc19ICIJZoUg=', 'user1')
sbs2 = ServiceBusService(
credentials.getServiceBusNamespace(),
'Tb6K5qEgstyRBwp86JEjUezKj/a+fnkLFnibfgvxvdg=', 'user2')
queue1_name = 'path1/queue' + str(random.randint(1, 10000000))
queue2_name = 'path2/queue' + str(random.randint(1, 10000000))
try:
# Create queues, success
sbs1.create_queue(queue1_name)
sbs2.create_queue(queue2_name)
# Receive messages, success
msg = sbs1.receive_queue_message(queue1_name, True, 1)
self.assertIsNone(msg.body)
msg = sbs1.receive_queue_message(queue1_name, True, 1)
self.assertIsNone(msg.body)
msg = sbs2.receive_queue_message(queue2_name, True, 1)
self.assertIsNone(msg.body)
msg = sbs2.receive_queue_message(queue2_name, True, 1)
self.assertIsNone(msg.body)
# Receive messages, failure
with self.assertRaises(HTTPError):
msg = sbs1.receive_queue_message(queue2_name, True, 1)
with self.assertRaises(HTTPError):
msg = sbs2.receive_queue_message(queue1_name, True, 1)
finally:
try:
sbs1.delete_queue(queue1_name)
except:
pass
try:
sbs2.delete_queue(queue2_name)
except:
pass
def test_unicode_create_queue_unicode_name(self):
# Arrange
self.queue_name = self.queue_name + u'啊齄丂狛狜'
# Act
with self.assertRaises(WindowsAzureError):
created = self.sbs.create_queue(self.queue_name)
# Assert
def test_unicode_receive_queue_message_unicode_data(self):
# Assert
sent_msg = Message('receive message啊齄丂狛狜')
self._create_queue_and_send_msg(self.queue_name, sent_msg)
# Act
received_msg = self.sbs.receive_queue_message(self.queue_name, False)
# Assert
self.assertIsNotNone(received_msg)
self.assertEquals(sent_msg.body, received_msg.body)
def test_unicode_receive_queue_message_binary_data(self):
# Assert
base64_data = 'AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/wABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoKSorLC0uLzAxMjM0NTY3ODk6Ozw9Pj9AQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVpbXF1eX2BhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ent8fX5/gIGCg4SFhoeIiYqLjI2Oj5CRkpOUlZaXmJmam5ydnp+goaKjpKWmp6ipqqusra6vsLGys7S1tre4ubq7vL2+v8DBwsPExcbHyMnKy8zNzs/Q0dLT1NXW19jZ2tvc3d7f4OHi4+Tl5ufo6err7O3u7/Dx8vP09fb3+Pn6+/z9/v8AAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5Ojs8PT4/QEFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaW1xdXl9gYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXp7fH1+f4CBgoOEhYaHiImKi4yNjo+QkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/AwcLDxMXGx8jJysvMzc7P0NHS09TV1tfY2drb3N3e3+Dh4uPk5ebn6Onq6+zt7u/w8fLz9PX29/j5+vv8/f7/AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w=='
binary_data = base64.b64decode(base64_data)
sent_msg = Message(binary_data)
self._create_queue_and_send_msg(self.queue_name, sent_msg)
# Act
received_msg = self.sbs.receive_queue_message(self.queue_name, False)
# Assert
self.assertIsNotNone(received_msg)
self.assertEquals(sent_msg.body, received_msg.body)
def test_unicode_create_subscription_unicode_name(self):
# Arrange
self._create_topic(self.topic_name)
# Act
with self.assertRaises(WindowsAzureError):
created = self.sbs.create_subscription(self.topic_name,
u'MySubscription啊齄丂狛狜')
# Assert
def test_unicode_create_rule_unicode_name(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
# Act
with self.assertRaises(WindowsAzureError):
created = self.sbs.create_rule(self.topic_name, 'MySubscription',
'MyRule啊齄丂狛狜')
# Assert
def test_unicode_receive_subscription_message_unicode_data(self):
# Arrange
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
sent_msg = Message('subscription message啊齄丂狛狜')
self.sbs.send_topic_message(self.topic_name, sent_msg)
# Act
received_msg = self.sbs.receive_subscription_message(
self.topic_name, 'MySubscription', False)
# Assert
self.assertIsNotNone(received_msg)
self.assertEquals(sent_msg.body, received_msg.body)
def test_unicode_receive_subscription_message_binary_data(self):
# Arrange
base64_data = 'AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/wABAgMEBQYHCAkKCwwNDg8QERITFBUWFxgZGhscHR4fICEiIyQlJicoKSorLC0uLzAxMjM0NTY3ODk6Ozw9Pj9AQUJDREVGR0hJSktMTU5PUFFSU1RVVldYWVpbXF1eX2BhYmNkZWZnaGlqa2xtbm9wcXJzdHV2d3h5ent8fX5/gIGCg4SFhoeIiYqLjI2Oj5CRkpOUlZaXmJmam5ydnp+goaKjpKWmp6ipqqusra6vsLGys7S1tre4ubq7vL2+v8DBwsPExcbHyMnKy8zNzs/Q0dLT1NXW19jZ2tvc3d7f4OHi4+Tl5ufo6err7O3u7/Dx8vP09fb3+Pn6+/z9/v8AAQIDBAUGBwgJCgsMDQ4PEBESExQVFhcYGRobHB0eHyAhIiMkJSYnKCkqKywtLi8wMTIzNDU2Nzg5Ojs8PT4/QEFCQ0RFRkdISUpLTE1OT1BRUlNUVVZXWFlaW1xdXl9gYWJjZGVmZ2hpamtsbW5vcHFyc3R1dnd4eXp7fH1+f4CBgoOEhYaHiImKi4yNjo+QkZKTlJWWl5iZmpucnZ6foKGio6SlpqeoqaqrrK2ur7CxsrO0tba3uLm6u7y9vr/AwcLDxMXGx8jJysvMzc7P0NHS09TV1tfY2drb3N3e3+Dh4uPk5ebn6Onq6+zt7u/w8fLz9PX29/j5+vv8/f7/AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIjJCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZHSElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWprbG1ub3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6PkJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKztLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7/P3+/w=='
binary_data = base64.b64decode(base64_data)
self._create_topic_and_subscription(self.topic_name, 'MySubscription')
sent_msg = Message(binary_data)
self.sbs.send_topic_message(self.topic_name, sent_msg)
# Act
received_msg = self.sbs.receive_subscription_message(
self.topic_name, 'MySubscription', False)
# Assert
self.assertIsNotNone(received_msg)
self.assertEquals(sent_msg.body, received_msg.body)
accessName = 'RootManageSharedAccessKey' # Your name, ex: 'owner' or 'RootManageSharedAccessKey'
accessKey = 'G6Iaa12aaB1aaHcZ4ghTzJKxLp1nFxf2hs1ZqYCSB5Y=' # Your key: ex: G6Iaa12aaB1aaHcZ4ghTzJKxLp1nFxf2hs1ZqYCSB5Y=
bus_service = ServiceBusService(service_namespace=namespaceName,
shared_access_key_name=accessName,
shared_access_key_value=accessKey)
topicName = 'test'
subscriptionName = 'readers'
topic_options = Topic()
topic_options.max_size_in_megabytes = '5120'
topic_options.default_message_time_to_live = 'PT1M'
bus_service.create_topic(topicName, topic_options)
bus_service.create_subscription(topicName, subscriptionName)
for i in range(5):
msg = Message('Msg {0}'.format(i).encode('utf-8'),
custom_properties={'messagenumber': i})
bus_service.send_topic_message(topicName, msg)
for i in range(5):
msg = bus_service.receive_subscription_message(topicName,
subscriptionName,
peek_lock=False)
print(msg.body)
print 'job done'
import json
import os
from azure.servicebus import ServiceBusService, Message
with open(
os.path.abspath(
os.path.join(os.path.dirname(__file__), '../config.json')),
'r') as read_file:
config = json.load(read_file)
topic_name = config['topic_name']
service_namespace = config['service_namespace']
key_name = config['key_name']
key_value = config['key_value']
sbs = ServiceBusService(service_namespace=service_namespace,
shared_access_key_name=key_name,
shared_access_key_value=key_value)
sbs.create_topic(topic_name)
msg = Message("Azure test message")
sbs.send_topic_message(topic_name, msg)
print("Message sent")
import sys
import ConfigParser
from azure.servicebus import ServiceBusService, Message
config = ConfigParser.SafeConfigParser()
config.read('/root/config.ini')
namespace = config.get('ServiceBus', 'Namespace')
key_name = config.get('ServiceBus', 'KeyName')
key_value = config.get('ServiceBus', 'KeyValue')
sbs = ServiceBusService(
namespace,
shared_access_key_name = key_name,
shared_access_key_value = key_value)
msg = Message('{ "SensorId": "' + sys.argv[2] + '", "Moisture": ' + sys.argv[3] + ' }',
custom_properties = { 'DeviceId': sys.argv[1], 'MessageType': 'MoistureTelemetry' })
sbs.send_topic_message('telemetry', msg)
#! bin/python3.6
from azure.servicebus import ServiceBusService, Message, Topic
from azure.mgmt.servicebus import ServiceBusManagementClient
import os, config
bus_service = ServiceBusService(
service_namespace=config.sb_namespace_name,
shared_access_key_name=config.shared_access_key_name,
shared_access_key_value=config.shared_access_key_value)
msgSend = Message(b'Test Message3')
bus_service.send_topic_message(config.sb_topic_name, msgSend)
# msg = bus_service.receive_subscription_message(config.sb_topic_name, config.sb_subscription_name, peek_lock=True)
# print(msg.body)
# msg.unlock
class AzureConnector():
def __init__(self, config):
tree = ET.parse('SharedConfig.xml')
self.myMachineName = tree.find('.//Instance').get("id")
self.sms = ServiceManagementService(
subscription_id=config.get("azure", "subscription_id"),
cert_file=config.get("azure", "cert_file")
);
self.bus_service = ServiceBusService(
service_namespace=config.get("azure", "bus_namespace"),
shared_access_key_name=config.get("azure", "bus_shared_access_key_name"),
shared_access_key_value=config.get("azure", "bus_shared_access_key_value"))
self.command_queue = config.get("azure", "commandQueuePath")
for tries in range(1,10):
try:
self.bus_service.create_queue(self.command_queue)
break
except:
print "Esperando"
self.status_topic = config.get("azure", "statusTopicPath")
self.bus_service.create_queue(self.status_topic)
self.storage = BlobService(account_name=config.get("azure", "account_name"),
account_key=config.get("azure", "account_key"))
self.algo_storage_name = config.get("azure", "algorithm_storage_name")
self.storage.create_container(self.algo_storage_name, fail_on_exist=False)
self.proj_storage_name = config.get("azure", "project_storage_name")
self.storage.create_container(self.proj_storage_name, fail_on_exist=False)
def check_new_tasks(self):
for tries in range(1,2):
try:
message = self.bus_service.receive_queue_message(self.command_queue, peek_lock=False, timeout=60)
break
except:
message = None
if message is None or message.body is None:
return None
job_description = json.loads(message.body.replace('/AzureBlobStorage/', ''))
command = CommandMetadata(
command_id = job_description["command_id"],
algorithm_directory = job_description["algorithm_prfx"],
project_prfx = job_description["project_prfx"],
project_input_files = job_description["project_input_files"],
algorithm_executable_name = job_description["algorithm_executable_name"],
algorithm_parameters = job_description["algorithm_parameters"],
sent_timestamp = datetime.datetime.strptime(job_description["sent_timestamp"], "%d/%m/%Y %H:%M:%S"),
machine_size=job_description["machine_size"])
# Retornar dados sobre o comando consumido da fila
return command
# Não há nada na fila
return None
def list_algo_files(self, prfx):
list = self.storage.list_blobs(container_name=self.algo_storage_name, prefix=prfx)
result = []
for blob in list:
result.append(blob.name)
return result
def download_algo_zip(self, algorithm_bin_file, tmp_file):
print "download_algo_zip(algorithm_bin_file="+algorithm_bin_file+", tmp_file="+tmp_file+")"
for tries in range(1,5):
try:
self.storage.get_blob_to_path(self.algo_storage_name, algorithm_bin_file, tmp_file,
open_mode='wb', snapshot=None, x_ms_lease_id=None,
progress_callback=None)
break
except Exception as e:
if tries == 5:
print("Muitos erros de conexão. Operação abortada.")
else:
print("Erro de conexão com serviço. Retentando..." + e.__str__())
def download_file_to_project(self, project_name, blob_name, dir):
print "download_file_to_project(project_name="+project_name+", blob_name="+blob_name+", dir="+dir+")"
for tries in range(1,5):
try:
self.storage.get_blob_to_path(self.proj_storage_name,
os.path.join(project_name,blob_name),
os.path.join(dir,os.path.join(project_name,blob_name)),
open_mode='wb', snapshot=None, x_ms_lease_id=None,
progress_callback=None)
break
except Exception as e:
if tries == 5:
print("Muitos erros de conexão. Operação abortada.")
else:
print("Erro de conexão com serviço. Retentando..." + e.__str__())
def download_file_to_project(self, project_name, blob_name, dir):
print "download_file_to_project(project_name="+project_name+", blob_name="+blob_name+", dir="+dir+")"
for tries in range(1,5):
try:
self.storage.get_blob_to_path(self.proj_storage_name,
os.path.join(project_name,blob_name),
os.path.join(dir,os.path.join(project_name,blob_name)),
open_mode='wb', snapshot=None, x_ms_lease_id=None,
progress_callback=None)
break
except Exception as e:
if tries == 5:
print("Muitos erros de conexão. Operação abortada.")
else:
print("Erro de conexão com serviço. Retentando..." + e.__str__())
def upload_proj_file(self, project_name, blob_name, dir):
print "upload_proj_file(project_name="+project_name+", blob_name="+blob_name+", dir="+dir+")"
if blob_name[0] == '/':
blob_name = blob_name[1:]
for tries in range(1,5):
try:
self.storage.put_block_blob_from_path(self.proj_storage_name,
os.path.join(project_name,blob_name),
os.path.join(dir,os.path.join(project_name,blob_name)))
break
except Exception as e:
if tries == 5:
print("Muitos erros de conexão. Operação abortada.")
else:
print("Erro de conexão com serviço. Retentando..." + e.__str__())
def download_file_to_algo(self, blob_name, dir):
print "download_file_to_algo(blob_name="+blob_name+", dir="+dir+")"
for tries in range(1,5):
try:
self.storage.get_blob_to_path(container_name=self.algo_storage_name,
blob_name=os.path.join(blob_name),
file_path=os.path.join(dir,blob_name),
open_mode='wb', snapshot=None, x_ms_lease_id=None,
progress_callback=None)
break
except Exception as e:
if tries == 5:
print("Muitos erros de conexão. Operação abortada.")
else:
print("Erro de conexão com serviço. Retentando..." + e.__str__())
def send_status(self, main_status):
for tries in range(1,5):
try:
self.bus_service.send_topic_message(topic_name=self.status_topic,
message=Message(main_status.encode('utf-8')))
break
except Exception as e:
if tries == 5:
print("Muitos erros de conexão. Operação abortada.")
else:
print("Erro de conexão com serviço. Retentando..." + e.__str__())
def shutdown_myself(self):
# A máquina virtual irá cometer suicídio.
print("Removendo máquina virtual da nuvem...")
for tries in range(1,5):
try:
self.sms.delete_deployment(
service_name=self.myMachineName,
deployment_name=self.myMachineName, delete_vhd=True)
exit(0)
break
except Exception as e:
if tries == 5:
print("Muitos erros de conexão. Operação abortada.")
else:
print("Erro de conexão com serviço. Retentando..." + e.__str__())
help='Set the service state')
parser.add_argument('-T',
'--summary',
type=str,
required=True,
help='Set the summary')
parser.add_argument('-D',
'--datetime',
type=str,
required=True,
help='Set the datetime')
args = parser.parse_args()
sbs = ServiceBusService(os.getenv('SERVICE_NAMESPACE'),
shared_access_key_name=os.getenv('KEY_NAME'),
shared_access_key_value=os.getenv('KEY_VALUE'))
msg = Message(body="SQLGENERIC CRITICAL - 1",
custom_properties={
'notificationtype': args.notificationtype,
'hostname': args.hostname,
'service': args.service,
'address': args.address,
'state': args.state,
'summary': args.summary,
'datetime': args.datetime
})
sbs.send_topic_message(os.getenv('TOPIC'), msg)
from azure.servicebus import ServiceBusService
from azure.servicebus import Message
sbs = ServiceBusService(
service_namespace='SERVICEBUS_NAMESPACE', # namespace name as created on Azure portal
shared_access_key_name='SHARED_ACCESS_POLICY_NAME', # Shared Access Policy name as created on Azure portal
shared_access_key_value='SHARED_ACCESS_POLICY_KEY') # Shared Access Policy Key
# implementirati logiku ponavljanja s unosom poruke s tipkovnice
while True:
poruka = input("Vaša poruka: ")
msg = Message(poruka)
sbs.send_topic_message('SERVICE_BUS_TOPIC', msg) # topic name as created on Azure portal
print('wget failed')
outfile = None
os.remove(infile)
return outfile
def handle_output(outputname):
block_blob_service = BlockBlobService(account_name=config.storage_acc_name,
account_key=config.storage_acc_key)
block_blob_service.create_blob_from_path(config.storage_container,
outputname, outputname)
if __name__ == "__main__":
bus_service = ServiceBusService(service_namespace=config.sb_name,
shared_access_key_name=config.sb_key_name,
shared_access_key_value=config.sb_key_val)
while True:
msg = bus_service.receive_queue_message(config.q_name,
peek_lock=False,
timeout=60)
if msg.body:
print('got new messgae: ' + msg.body)
process_params = json.loads(msg.body)
filename = get_image(process_params['url'])
processed = process(filename)
handle_output(processed)
bus_service.send_topic_message(config.topic_name,
Message(json.dumps(process_params)))
else:
print('no new msg in queue')
from datetime import datetime, date, time
from azure.servicebus import ServiceBusService, Message, Topic, Rule, DEFAULT_RULE_NAME
import json
with open('config.json') as json_data_file:
config_dict = json.load(json_data_file)
'''
Create a topic
-------------------------------------------------------------------------------------------
The following code creates a ServiceBusService object.
Replace mynamespace, sharedaccesskeyname, and sharedaccesskey with your actual
namespace, Shared Access Signature (SAS) key name, and key value.
'''
bus_service = ServiceBusService(
service_namespace=config_dict['ServiceBusService']['service_namespace'],
shared_access_key_name=config_dict['ServiceBusService']
['shared_access_key_name'],
shared_access_key_value=config_dict['ServiceBusService']
['shared_access_key_value'])
from uuid import getnode as get_mac
mac = raw_input("Mac: ")
payload = {
"macid": mac,
"timestamp": datetime.now().strftime("%b %d %Y %H:%M:%S")
}
msg = Message(payload)
print payload
bus_service.send_topic_message('FieldGatway2AzureCloud', msg)
