class AzureConnection():
def __init__(self):
self.bus_service = ServiceBusService(
service_namespace='msgtestsb',
shared_access_key_name='RootManageSharedAccessKey',
shared_access_key_value=
'Ar9fUCZQdTL7cVWgerdNOB7sbQp0cWEeQyTRYUjKwpk=')
queue_options = Queue()
queue_options.max_size_in_megabytes = '5120'
queue_options.default_message_time_to_live = 'PT96H'
self.bus_service.create_queue('process_incoming', queue_options)
self.bus_service.create_queue('whatsapp_sender', queue_options)
self.bus_service.create_queue('myapp_sender', queue_options)
def receive(self):
msg = self.bus_service.receive_queue_message('process_incoming',
peek_lock=False)
if msg != None and msg.body:
logger.info(msg.body)
return json.loads(msg.body)
else:
return None
def send(self, jsondict):
t = json.dumps(jsondict)
msg = Message(t)
logger.info(t)
Q = jsondict['medium'] + '_sender'
self.bus_service.send_queue_message(Q, msg)
class AzureConnection():
def __init__(self):
self.bus_service = ServiceBusService(
service_namespace='msgtestsb',
shared_access_key_name='RootManageSharedAccessKey',
shared_access_key_value='Ar9fUCZQdTL7cVWgerdNOB7sbQp0cWEeQyTRYUjKwpk=')
queue_options = Queue()
queue_options.max_size_in_megabytes = '5120'
queue_options.default_message_time_to_live = 'PT96H'
self.bus_service.create_queue('process_incoming', queue_options)
self.bus_service.create_queue('whatsapp_sender', queue_options)
self.bus_service.create_queue('myapp_sender', queue_options)
def receive(self):
msg = self.bus_service.receive_queue_message('process_incoming', peek_lock=False)
if msg != None and msg.body:
logger.info( msg.body)
return json.loads(msg.body)
else:
return None
def send(self, jsondict):
t = json.dumps(jsondict)
msg = Message(t)
logger.info( t)
Q = jsondict['medium'] + '_sender'
self.bus_service.send_queue_message(Q, msg)
def send_to_queue(data, queue):
svcbus = ServiceBusService(
service_namespace='botista',
shared_access_key_name='RootManageSharedAccessKey',
shared_access_key_value='0/O8pigV09yoxSrSpEjKK+uoMWS1JYYJQEbnbzVxnpA=')
event = Message(json.dumps(data))
svcbus.send_queue_message(queue, event)
class AzureServiceBusQueue(Queue):
"""
Implements a Queue backed by a Windows Azure Service Bus Queue.
"""
# Timeout in seconds. receive_message is blocking and returns as soon as one of two
# conditions occurs: a message is received or the timeout period has elapsed.
polling_timeout = 60
def __init__(self, namespace, key, issuer, name):
self.service = ServiceBusService(service_namespace=namespace, account_key=key, issuer=issuer)
self.name = name
def receive_message(self):
msg = self.service.receive_queue_message(self.name, peek_lock=False, timeout=self.polling_timeout)
return None if msg.body is None else AzureServiceBusQueueMessage(self, msg)
def send_message(self, body):
self.service.send_queue_message(self.name, Message(body))
def servicebus_notification(
namespace,
queue_name,
shared_access_key_name,
shared_access_key,
message):
"""
Send notification message to an existing service bus queue
"""
servicebus = ServiceBusService(
service_namespace=namespace,
shared_access_key_name=shared_access_key_name,
shared_access_key_value=shared_access_key)
notification_message = Message(message)
# let the exception bubble up to be handled by the caller
servicebus.send_queue_message(queue_name, notification_message)
def sender():
bus_service = ServiceBusService(
service_namespace='comp6905',
shared_access_key_name='RootManageSharedAccessKey',
shared_access_key_value='rK2FMzVKvCjpad7xVSj1AB3hDimhxZq3WtEE4y28yaM=')
x = 0
while (True):
msg1 = bus_service.receive_queue_message('numbers', peek_lock=False)
# print (msg1.body.decode("utf-8"))
msg2 = msg1.body.decode("utf-8")
msg3 = str(int(msg2) + 501)
msg4 = Message(msg3.encode('utf-8'))
bus_service.send_queue_message('numbers', msg4)
premessage = '{"TransactionID":"' + msg2 + '","UserId":"A1","SellerID":"S1","Product Name":"Financial Trap","Sale Price":"1000000","Transaction Date":"2016-11-01T13:19:42.963Z"}'
# print(premessage)
preMbytes = premessage.encode('utf-8')
msg = Message(preMbytes)
x = x + 1
#print(x)
bus_service.send_queue_message('queue1', msg)
class AzureServiceBusQueue(Queue):
"""
Implements a Queue backed by a Windows Azure Service Bus Queue.
"""
# Timeout in seconds. receive_message is blocking and returns as soon as one of two
# conditions occurs: a message is received or the timeout period has elapsed.
polling_timeout = 60
def __init__(self, namespace, key, issuer, shared_access_key_name,
shared_access_key_value, name):
self.service = ServiceBusService(
service_namespace=namespace,
account_key=key,
issuer=issuer,
shared_access_key_name=shared_access_key_name,
shared_access_key_value=shared_access_key_value)
self.name = name
self.max_retries = 3
self.wait = lambda count: 1.0 * (2**count)
def _try_request(self, fn, retry_count=0, fail=None):
'''Helper to retry request for sending and receiving messages.'''
try:
return fn()
except (WindowsAzureError) as e:
if retry_count < self.max_retries:
logger.error(
"Retrying request after error occurred. Attempt %s of %s.",
retry_count + 1, self.max_retries)
wait_interval = self.wait(retry_count)
if wait_interval > 0.0:
sleep(wait_interval)
return self._try_request(fn,
retry_count=retry_count + 1,
fail=fail)
else:
if fail is not None:
fail()
raise e
def receive_message(self):
op = lambda: self.service.receive_queue_message(
self.name, peek_lock=False, timeout=self.polling_timeout)
msg = self._try_request(op)
return None if msg.body is None else AzureServiceBusQueueMessage(
self, msg)
def send_message(self, body):
op = lambda: self.service.send_queue_message(self.name, Message(body))
fail = lambda: logger.error(
"Failed to send message. Message body is:\n%s", body)
self._try_request(op, fail=fail)
def notify_height(self, height):
"""
Notifies of the current height
height -- height to notify of
"""
d = {}
d['device_id'] = self.device_name
d['command_text'] = ""
d['to_height'] = "{:.9f}".format(height)
d['move_initiate_time'] = time.strftime("%Y-%m-%dT%H:%M:%S")
msgbody = json.dumps(d)
msg = Message(str.encode(msgbody))
sbs = ServiceBusService(self.namespace,
shared_access_key_name=self.key_name,
shared_access_key_value=self.key_value)
print('sending...')
sbs.send_queue_message(self.queue_name, msg)
print('sent ' + msgbody)
class ServiceBusQueue(object):
def __init__(self, namespace, access_key_name, access_key_value, q_name, q_max_size="5120", msg_ttl="PT1M"):
self.bus_svc = ServiceBusService(
service_namespace=namespace,
shared_access_key_name=access_key_name,
shared_access_key_value=access_key_value,
)
self.queue_options = Queue()
self.queue_options.max_size_in_megabytes = q_max_size
self.queue_options.default_message_time_to_live = msg_ttl
self.queue_name = q_name
self.bus_svc.create_queue(self.queue_name, self.queue_options)
def send(self, msg):
message = bytes(msg)
message = Message(message)
self.bus_svc.send_queue_message(self.queue_name, message)
def receive(self):
msg = self.bus_svc.receive_queue_message(self.queue_name, peek_lock=False)
data = ast.literal_eval(msg.body)
return data
def read_file(self, file) -> str:
print('file: ' + str(file))
parsed = parser.from_file(file)
print(parsed['metadata'])
content = parsed['content']
split = content.replace('\n', '').split('.')
#print(content)
queue_data = load_queue_credentials()
print(queue_data['namespace'])
print(queue_data['key_name'])
print(queue_data['key_value'])
bus_service = ServiceBusService(
service_namespace=queue_data['namespace'],
shared_access_key_name=queue_data['key_name'],
shared_access_key_value=queue_data['key_value'])
#for part in split:
#send part to queue
print("sending...")
msg = Message('test')
bus_service.send_queue_message('texttoworker', msg)
print("done?")
class AzureServiceBusQueue(Queue):
"""
Implements a Queue backed by a Windows Azure Service Bus Queue.
"""
# Timeout in seconds. receive_message is blocking and returns as soon as one of two
# conditions occurs: a message is received or the timeout period has elapsed.
polling_timeout = 60
def __init__(self, namespace, key, issuer, shared_access_key_name, shared_access_key_value, name):
self.service = ServiceBusService(service_namespace=namespace, account_key=key,
issuer=issuer, shared_access_key_name=shared_access_key_name,
shared_access_key_value=shared_access_key_value)
self.name = name
self.max_retries = 3
self.wait = lambda count: 1.0*(2**count)
def _try_request(self, fn, retry_count=0, fail=None):
'''Helper to retry request for sending and receiving messages.'''
try:
return fn()
except (WindowsAzureError) as e:
if retry_count < self.max_retries:
logger.error("Retrying request after error occurred. Attempt %s of %s.",
retry_count+1, self.max_retries)
wait_interval = self.wait(retry_count)
if wait_interval > 0.0:
sleep(wait_interval)
return self._try_request(fn, retry_count=retry_count+1, fail=fail)
else:
if fail is not None:
fail()
raise e
def receive_message(self):
op = lambda: self.service.receive_queue_message(self.name,
peek_lock=False,
timeout=self.polling_timeout)
msg = self._try_request(op)
return None if msg.body is None else AzureServiceBusQueueMessage(self, msg)
def send_message(self, body):
op = lambda: self.service.send_queue_message(self.name, Message(body))
fail = lambda: logger.error("Failed to send message. Message body is:\n%s", body)
self._try_request(op, fail=fail)
from azure.servicebus import ServiceBusService
from azure.servicebus import Message
# All these print statements get sent to the Azure Functions live log
print "--- GET ---"
print http.get
print
print "--- POST ---"
print http.post
print
key_name = 'RootManageSharedAccessKey' # SharedAccessKeyName from Azure portal
key_value = '4My+blZDLkuXYCnqWNlx35V5wA+9XiBZvxwccRNG7bg=' # SharedAccessKey from Azure portal
sbs = ServiceBusService('mynamespace0', shared_access_key_name=key_name, shared_access_key_value=key_value)
msg = Message(http.post)
sbs.send_queue_message('t', msg)
print "##########Message sent##############"
print "--- HEADERS ---"
print http.headers
print
print "--- OTHER ENVIRONMENTAL VARIABLES ---"
for x in http.env:
print x
print
# All data to be returned to the client gets put into this dict
returnData = {
# HTTP Status Code:
bus_service = ServiceBusService(
service_namespace='lumi001',
shared_access_key_name='RootManageSharedAccessKey',
shared_access_key_value='AFOA06OWcNUsDQyi8jHuqIhumuV5QN+jObsfv5QhNBM=',
host_base='.servicebus.chinacloudapi.cn')
# bus_service.create_queue('taskqueue')
for i in range(5):
msg_str = 'Follow#oQ_DVvyaYU_iFEpJCI5WW9lLkvG4@%s' % (time.ctime(
time.time()))
if i % 2 == 0:
msg_str = 'UnFollow#oQ_DVvyaYU_iFEpJCI5WW9lLkvG4@%s' % (time.ctime(
time.time()))
msg = Message(str.encode(msg_str))
print('test', msg_str)
bus_service.send_queue_message('wechat.subscription.exp', msg)
time.sleep(1)
time.sleep(1)
# message = bus_service.receive_queue_message('wechat.subscription.exp')
# while 1:
# message = bus_service.receive_queue_message('wechat.subscription.exp')
# if message.body == None:
# break
# print(message.body == None)
# print('receive--> message','#'*10,message.body)
# # print(message,dump(message),'#'*10,message.body)
# message.delete()
from azure.servicebus import ServiceBusService, Message, Queue
namespace = "nsgtrnamespace"
endpoint = "sb://" + namespace + ".servicebus.windows.net/"
keyName = "all"
key = "KbuVe06trwIaVPeYYg/F+WfmojIi+pdWe4SrD5BBczY="
queueName = "nsgtrqueue"
bus_service = ServiceBusService(service_namespace=namespace,
shared_access_key_name=keyName,
shared_access_key_value=key)
sentMsg = Message(b'hi')
bus_service.send_queue_message(queueName, sentMsg)
receivedMsg = bus_service.receive_queue_message(queueName, peek_lock=False)
print(receivedMsg.body)
#print(bus_service.receive_queue_message(queueName, peek_lock=False))
from azure.servicebus import ServiceBusService, Message, Queue
import config
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)
msg = Message(
'{ "url" : "http://vignette4.wikia.nocookie.net/althistory/images/8/8d/Eiffel-tower.jpg", "sender" : "abc"}'
)
bus_service.send_queue_message('imgprocjobs', msg)
print('sent message ' + msg.body)
"algorithm_executable_name": "/bin/ksh",
"algorithm_parameters": ["/AzureBlobStorage/sandbox/admin/tester/admi_test_CBJ6LTHDWM/.cmds/admi_test_CBJ6LTHDWM/script.ksh"],
"sent_timestamp": "12/01/2015 10:00:00",
"machine_size": "*"
}"""
#
# job_description = json.loads(json_message)
#
# command_id = job_description["command_id"],
# algorithm_bin_file = job_description["algorithm_bin_file"],
# 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")
print "Enviando mensagem..."
bus_service.send_queue_message('commands', Message(json_message))
print "Mensagem enviada. Checando agora a fila de status."
try:
bus_service.create_subscription('status', 'tester_sub')
while True:
print ">"
status_message = bus_service.receive_subscription_message('status', 'tester_sub', peek_lock=False)
print status_message.body
except KeyboardInterrupt:
print "tchau."
def doSomething():
# Write to log file and update Slack
hostname = socket.gethostname()
logMessage = "SIMULATOR (" + hostname + "): Creating statistics starting @ " + str(time.ctime())
log = Log()
log.info(logMessage)
notify.info(logMessage)
# Gather environment variables
AZURE_SB_SERVICE_NAMESPACE = os.getenv('AZURE_SB_SERVICE_NAMESPACE')
AZURE_SB_SHARED_ACCESS_KEY_NAME = os.getenv('AZURE_SB_SHARED_ACCESS_KEY_NAME')
AZURE_SB_SHARED_ACCESS_KEY = os.getenv('AZURE_SB_SHARED_ACCESS_KEY')
# Start loop and write random messages to Azure Service Bus Queue
x=0
while True:
x=x+1
time.sleep(2)
# Write message to SB Queue
sb_service = ServiceBusService(service_namespace=AZURE_SB_SERVICE_NAMESPACE,shared_access_key_name=AZURE_SB_SHARED_ACCESS_KEY_NAME,shared_access_key_value=AZURE_SB_SHARED_ACCESS_KEY)
msg_text = "Update number: " + str(x)
msg = Message(msg_text.encode("utf-8"))
# Randomly create data for SB Queue
r = random.randint(1, 10)
if r == 1:
msg.custom_properties={'deviceid':'mydevice' + str(r),'temp':'40.8','pressure':'61.93','humidity':'20','windspeed':str(r) + '.5'}
sb_service.send_queue_message('statistics', msg)
elif r == 2:
msg.custom_properties={'deviceid':'mydevice' + str(r),'temp':'50.8','pressure':'62.83','humidity':'30','windspeed':str(r) + '.5'}
sb_service.send_queue_message('statistics', msg)
elif r == 3:
msg.custom_properties={'deviceid':'mydevice' + str(r),'temp':'60.8','pressure':'63.73','humidity':'40','windspeed':str(r) + '.5'}
sb_service.send_queue_message('statistics', msg)
elif r == 4:
msg.custom_properties={'deviceid':'mydevice' + str(r),'temp':'70.8','pressure':'64.63','humidity':'50','windspeed':str(r) + '.5'}
sb_service.send_queue_message('statistics', msg)
elif r == 5:
msg.custom_properties={'deviceid':'mydevice' + str(r),'temp':'80.8','pressure':'51.93','humidity':'60','windspeed':str(r) + '.5'}
sb_service.send_queue_message('statistics', msg)
elif r == 6:
msg.custom_properties={'deviceid':'mydevice' + str(r),'temp':'90.8','pressure':'55.93','humidity':'70','windspeed':str(r) + '.5'}
sb_service.send_queue_message('statistics', msg)
elif r == 7:
msg.custom_properties={'deviceid':'mydevice' + str(r),'temp':'45.2','pressure':'34.99','humidity':'45','windspeed':str(r) + '.5'}
sb_service.send_queue_message('statistics', msg)
elif r == 8:
msg.custom_properties={'deviceid':'mydevice' + str(r),'temp':'55.2','pressure':'38.99','humidity':'55','windspeed':str(r) + '.5'}
sb_service.send_queue_message('statistics', msg)
elif r == 9:
msg.custom_properties={'deviceid':'mydevice' + str(r),'temp':'65.2','pressure':'36.99','humidity':'65','windspeed':str(r) + '.5'}
sb_service.send_queue_message('statistics', msg)
else:
msg.custom_properties={'deviceid':'mydevice' + str(r),'temp':'75.2','pressure':'71.77','humidity':'38','windspeed':str(r) + '.5'}
sb_service.send_queue_message('statistics', msg)
log.info("Message #" + str(x) + " posted.")
service_namespace='lumi001',
shared_access_key_name='RootManageSharedAccessKey',
shared_access_key_value='AFOA06OWcNUsDQyi8jHuqIhumuV5QN+jObsfv5QhNBM=',
host_base='.servicebus.chinacloudapi.cn')
queue_name = 'temp_queue'
# queue_name = 'wechat.subscription.exp'
# bus_service.create_queue('temp_queue')
for i in range(15):
msg_str = 'Follow#oQ_DVvyaYU_iFEpJCI5WW9lLkvG4@%s' % (time.ctime(
time.time()))
if i % 2 == 0:
msg_str = 'UnFollow#oQ_DVvyaYU_iFEpJCI5WW9lLkvG4@%s' % (time.ctime(
time.time()))
msg = Message(str.encode(msg_str))
print('push to queue: ', msg_str)
bus_service.send_queue_message(queue_name, msg)
time.sleep(1)
# time.sleep(1)
# # message = bus_service.receive_queue_message(queue_name)
# message = bus_service.receive_queue_message(queue_name)
# while 1:
# message = bus_service.receive_queue_message(queue_name)
# if message.body == None:
# break
# print(message.body == None)
# print('receive--> message','#'*10,message.body)
# # print(message,dump(message),'#'*10,message.body)
# message.delete()
class EchoLayer(YowInterfaceLayer):
def __init__(self):
super(EchoLayer, self).__init__()
YowInterfaceLayer.__init__(self)
self.connected = False
self.serve = Serve()
self.bus_service = ServiceBusService(
service_namespace='msgtestsb',
shared_access_key_name='RootManageSharedAccessKey',
shared_access_key_value='Ar9fUCZQdTL7cVWgerdNOB7sbQp0cWEeQyTRYUjKwpk=')
@ProtocolEntityCallback("message")
def onMessage(self, recdMsg):
jsondict = {'medium': 'whatsapp'}
jsondict['phonenum'] = recdMsg.getFrom(False)
jsondict['msgtype'] = recdMsg.getType()
if jsondict['msgtype'] == 'text':
jsondict['msgbody'] = recdMsg.getBody()
if jsondict['msgtype'] == 'media':
jsondict['mediatype'] = recdMsg.getMediaType()
if jsondict['mediatype'] in ["image", "audio", "video"]:
jsondict['mediaurl'] = recdMsg.getMediaUrl()
if jsondict['mediatype'] in ["image", "video"]:
jsondict['caption'] = recdMsg.getCaption()
else:
jsondict['caption'] = None
elif jsondict['mediatype'] == 'vcard':
jsondict['name'] = recdMsg.getName()
jsondict['carddata'] = recdMsg.getCardData()
elif jsondict['mediatype'] == "location":
jsondict['lat'] = recdMsg.getLatitude()
jsondict['long'] = recdMsg.getLongitude()
jsondict['name'] = recdMsg.getLocationName()
jsondict['url'] = recdMsg.getLocationURL()
jsondict['encoding'] = "raw"
if jsondict['msgtype'] == 'text':
logging.info( recdMsg.getBody())
pushjson = json.dumps(jsondict)
if AZURE_SERVICING:
msg = Message(pushjson)
self.bus_service.send_queue_message('process_incoming', msg)
else:
retjson = self.serve.getResponseWrapper(pushjson, recdMsg)
if retjson:
SendQueue.put(retjson)
self.toLower(recdMsg.ack())
self.toLower(recdMsg.ack(True))
self.sendMessages()
def sendMessages(self):
try:
sendmsg = SendQueue.get_nowait()
except:
return
jsondict = json.loads(sendmsg)
phonenum = jsondict['phonenum']
if jsondict['restype'] == 'list':
ret = jsondict['response']
else:
ret = [(jsondict['restype'], jsondict['response'])]
for (restype,response) in ret:
logging.info( '%s: Send to %s %s ' % (datetime.now(), phonenum, restype))
if restype in [ 'image' , 'audio', 'video' ]:
if 'localfile' in response.keys():
path = response['localfile']
else:
mediaurl = response['mediaurl']
path = '/tmp/' + basename(mediaurl)
if isfile(path):
unlink(path)
urlretrieve(mediaurl, path)
if isfile(path):
if restype == 'image':
self.image_send(phonenum, path, response['caption'])
if restype == 'video':
# self.video_send(phonenum, path, response['caption'])
# video not supported yet
self.message_send(phonenum, "Video Message not supported yet")
if restype == 'audio':
# self.audio_send(phonenum, path)
# video not supported yet
self.message_send(phonenum, "Audio Message not supported yet")
elif restype == 'text':
self.message_send(phonenum, response)
elif restype == 'vcard':
self.vcard_send(phonenum, response['name'],response['carddata'])
elif restype == 'location':
self.location_send(phonenum, response['lat'],response['long'],
response['name'], response['url'], response['encoding'])
# handling completed queue in azure service not yet implemented
#CompletedSendQueue.append(key[1])
@ProtocolEntityCallback("receipt")
def onReceipt(self, entity):
self.toLower(entity.ack())
self.sendMessages()
def logResponse(self, msg):
if msg.getType() == 'text':
logging.info(("Echoing %s to %s" % (msg.getBody(), msg.getFrom(False))))
elif msg.getType() == 'media':
if msg.getMediaType() in [ "image", "audio", "video"]:
logging.info(("Echoing %s %s to %s" % (msg.getMediaType(), msg.url, msg.getFrom(False))))
elif msg.getMediaType() == "location":
logging.info(("Echoing location (%s, %s) to %s" % (msg.getLatitude(), msg.getLongitude(), msg.getFrom(False))))
elif msg.getMediaType() == "vcard":
logging.info(("Echoing vcard (%s, %s) to %s" % (msg.getName(), msg.getCardData(), msg.getFrom(False))))
@ProtocolEntityCallback("success")
def onSuccess(self, entity):
self.connected = True
logger.info("Logged in! Auth")
self.sendMessages()
@ProtocolEntityCallback("failure")
def onFailure(self, entity):
self.connected = False
logger.info("Login Failed, reason: %s" % entity.getReason())
def message_send(self, number, content):
outgoingMessage = TextMessageProtocolEntity(content.encode("utf-8") if version_info >= (3,0) else content, to = self.normalizeJid(number))
self.toLower(outgoingMessage)
def vcard_send(self, number, name, carddata):
outgoingMessage = VCardMediaMessageProtocolEntity(
name, carddata, to = self.normalizeJid(number))
self.toLower(outgoingMessage)
def location_send(self, number, lat, lon, name, url, encoding):
outgoingMessage = LocationMediaMessageProtocolEntity(
lat, lon, name, url, encoding, to = self.normalizeJid(number))
self.toLower(outgoingMessage)
def image_send(self, number, path, caption = None):
jid = self.normalizeJid(number)
entity = RequestUploadIqProtocolEntity(RequestUploadIqProtocolEntity.MEDIA_TYPE_IMAGE, filePath=path)
successFn = lambda successEntity, originalEntity: self.onRequestUploadResult(jid, path, successEntity, originalEntity, caption)
errorFn = lambda errorEntity, originalEntity: self.onRequestUploadError(jid, path, errorEntity, originalEntity)
self._sendIq(entity, successFn, errorFn)
def video_send(self, number, path, caption = None):
jid = self.normalizeJid(number)
entity = RequestUploadIqProtocolEntity(RequestUploadIqProtocolEntity.MEDIA_TYPE_VIDEO, filePath=path)
successFn = lambda successEntity, originalEntity: self.onRequestUploadResult(jid, path, successEntity, originalEntity, caption)
errorFn = lambda errorEntity, originalEntity: self.onRequestUploadError(jid, path, errorEntity, originalEntity)
self._sendIq(entity, successFn, errorFn)
def audio_send(self, number, path):
jid = self.normalizeJid(number)
entity = RequestUploadIqProtocolEntity(RequestUploadIqProtocolEntity.MEDIA_TYPE_AUDIO, filePath=path)
successFn = lambda successEntity, originalEntity: self.onRequestUploadResult(jid, path, successEntity, originalEntity)
errorFn = lambda errorEntity, originalEntity: self.onRequestUploadError(jid, path, errorEntity, originalEntity)
self._sendIq(entity, successFn, errorFn)
def normalizeJid(self, number):
if '@' in number:
return number
elif "-" in number:
return "*****@*****.**" % number
return "*****@*****.**" % number
########### callbacks ############
def onRequestUploadResult(self, jid, filePath, resultRequestUploadIqProtocolEntity, requestUploadIqProtocolEntity, caption = None):
if requestUploadIqProtocolEntity.mediaType == RequestUploadIqProtocolEntity.MEDIA_TYPE_AUDIO:
doSendFn = self.doSendAudio
elif requestUploadIqProtocolEntity.mediaType == RequestUploadIqProtocolEntity.MEDIA_TYPE_IMAGE:
doSendFn = self.doSendImage
else:
doSendFn = self.doSendVideo
if resultRequestUploadIqProtocolEntity.isDuplicate():
doSendFn(filePath, resultRequestUploadIqProtocolEntity.getUrl(), jid,
resultRequestUploadIqProtocolEntity.getIp(), caption)
else:
successFn = lambda filePath, jid, url: doSendFn(filePath, url, jid, resultRequestUploadIqProtocolEntity.getIp(), caption)
mediaUploader = MediaUploader(jid, self.getOwnJid(), filePath,
resultRequestUploadIqProtocolEntity.getUrl(),
resultRequestUploadIqProtocolEntity.getResumeOffset(),
successFn, self.onUploadError, self.onUploadProgress, async=False)
mediaUploader.start()
def onRequestUploadError(self, jid, path, errorRequestUploadIqProtocolEntity, requestUploadIqProtocolEntity):
logger.error("Request upload for file %s for %s failed" % (path, jid))
def onUploadError(self, filePath, jid, url):
logger.error("Upload file %s to %s for %s failed!" % (filePath, url, jid))
def onUploadProgress(self, filePath, jid, url, progress):
return
#sys.stdout.write("%s => %s, %d%% \r" % (os.path.basename(filePath), jid, progress))
#sys.stdout.flush()
def doSendVideo(self, filePath, url, to, ip = None, caption = None):
entity = VideoDownloadableMediaMessageProtocolEntity.fromFilePath(filePath, url, ip, to, caption = caption)
self.toLower(entity)
def doSendImage(self, filePath, url, to, ip = "127.0.0.1", caption = None):
logger.info('filepath:%s url:%s to:%s ip:%s caption:%s ' % (filePath, url, to, ip, caption))
entity = ImageDownloadableMediaMessageProtocolEntity.fromFilePath(filePath, url, ip, to, caption = caption)
self.toLower(entity)
def doSendAudio(self, filePath, url, to, ip = None, caption = None):
entity = AudioDownloadableMediaMessageProtocolEntity.fromFilePath(filePath, url, ip, to)
self.toLower(entity)
def getMediaMessageBody(self, message):
if message.getMediaType() in ("image", "audio", "video"):
return self.getDownloadableMediaMessageBody(message)
else:
return "[Media Type: %s]" % message.getMediaType()
def getDownloadableMediaMessageBody(self, message):
return "[Media Type:{media_type}, Size:{media_size}, URL:{media_url}]".format(
media_type = message.getMediaType(),
media_size = message.getMediaSize(),
media_url = message.getMediaUrl()
)
import sys
from azure.servicebus import ServiceBusService, Message
sbs = ServiceBusService(
"magicButtonMB",
shared_access_key_name="RootManageSharedAccessKey",
shared_access_key_value="SNZewWOTdOkaVShECrp+OCKmSFqW5JCEjEM52slp5TM=")
msg = Message((sys.argv[2] + " " + sys.argv[3]).encode())
sbs.send_queue_message(sys.argv[1], msg)
from azure.servicebus import ServiceBusService, Message, Queue
bus_service = ServiceBusService(
service_namespace='maxqueue-ns',
shared_access_key_name='MAXRULE1',
shared_access_key_value='UBJelXoKJFsfTRnTA3c9jGWW6JXnp5Tc78cOZzdb0fI=')
msg = Message(b'Test Message')
bus_service.send_queue_message('MAXQUEUE', msg)
msg = bus_service.receive_queue_message('MAXQUEUE', peek_lock=False)
print(msg.body)
from azure.servicebus import ServiceBusService, Message, Queue
bus_service = ServiceBusService(
service_namespace='appcandy-ns',
shared_access_key_name='MachineSend',
shared_access_key_value='Q4uctgrpqj+SZOejERPkkH0Mw0r4W4mOSb7yHSmLLI4=')
msg = Message(b'New Test Message')
bus_service.send_queue_message('appcandy', msg)
from azure.servicebus import ServiceBusService, Message, Queue
namespace = "nsgtrnamespace"
endpoint = "sb://" + namespace + ".servicebus.windows.net/"
keyName = "all"
key = "KbuVe06trwIaVPeYYg/F+WfmojIi+pdWe4SrD5BBczY="
queueName = "nsgtrqueue"
bus_service = ServiceBusService(
service_namespace=namespace,
shared_access_key_name=keyName,
shared_access_key_value=key
)
sentMsg = Message(b'hi')
bus_service.send_queue_message(queueName, sentMsg)
receivedMsg = bus_service.receive_queue_message(queueName, peek_lock=False)
print(receivedMsg.body)
#print(bus_service.receive_queue_message(queueName, peek_lock=False))
self.devicename = "Not Set"
self.ipaddr = "Not Set"
print(os.getcwd())
service_namespace = 'nixpitest'
with open('private/keys.txt', 'r') as myfile:
keyval = myfile.read().replace('\n', '')
key_name = 'RootManageSharedAccessKey' # SharedAccessKeyName from Azure portal
key_value = keyval # SharedAccessKey from Azure portal
sbs = ServiceBusService(service_namespace,
shared_access_key_name=key_name,
shared_access_key_value=key_value)
sbs.create_queue('ippublishqueue')
myip = (([
ip for ip in socket.gethostbyname_ex(socket.gethostname())[2]
if not ip.startswith("127.")
] or [[(s.connect(("8.8.8.8", 53)), s.getsockname()[0], s.close())
for s in [socket.socket(socket.AF_INET, socket.SOCK_DGRAM)]][0][1]]) +
["no IP found"])[0]
initMessage = InitMessage()
initMessage.devicename = "fred"
initMessage.ipaddr = myip
s = json.dumps(initMessage.__dict__) # s set to: {"x":1, "y":2}
print(s)
msg = Message(s)
sbs.send_queue_message('ippublishqueue', msg)
print(myip, 'published to service bus queue')
from azure.servicebus import ServiceBusService, Message, Queue
#sudo pip install azure bzw. nur den azure-servicebus damit es schneller gehtS
service_namespace = 'svpservicebus'
key_name = 'PiKey' # SharedAccessKeyName from Azure portal
key_value = 'uFAnfl9Js5ELJ/1n3xoB39uVvshmhEXdUzLEStdfW0c=' # SharedAccessKey from Azure portal
connectionString = 'Endpoint=sb://svpservicebus.servicebus.windows.net/;SharedAccessKeyName=Reader;SharedAccessKey=smSDkgYnikYSZ9ia07p5i7/uzSdcH9zOdeIJoKfhPng=;EntityPath=iot-maker-lab01-queue'
bus_service = ServiceBusService(service_namespace,
shared_access_key_name=key_name,
shared_access_key_value=key_value)
#bus_service.create_queue('iot-maker-lab01-queue')
#sb://svpservicebus.servicebus.windows.net/
decide = raw_input("Anlegen [1], Abbrechen [2]: ")
while decide != "2":
if decide == "1":
msg_body = raw_input("Bitte geben Sie ihren Namen ein: ")
msg = Message(b'Hallo, '+msg_body)
bus_service.send_queue_message('iot-maker-lab01-queue', msg)
decide = raw_input("Anlegen [1], Auslesen [2], Abbrechen [3]: ")
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)
block_blob_service.set_container_acl(container_name,
public_access=PublicAccess.Container)
local_path = os.path.expanduser(r"C:\demo")
full_path_to_file = os.path.join(local_path, video_name)
block_blob_service.create_blob_from_path(container_name, video_name,
full_path_to_file)
# In[ ]:
#message to service bus
from azure.servicebus import ServiceBusService, Message, Queue
bus_service = ServiceBusService(
service_namespace='SVDServiceBus',
shared_access_key_name='RootManageSharedAccessKey',
shared_access_key_value='g********************p9+12EQu+*************=')
bus_service.create_queue('resultqueue')
msg = Message(video_name)
bus_service.send_queue_message('resultqueue', msg)
# In[ ]:
import os
import subprocess
os.remove(video_name)
#Close all running task
subprocess.call('taskkill.bat')
#Logout
import os
os.system("shutdown -l")
class EchoLayer(YowInterfaceLayer):
def __init__(self):
super(EchoLayer, self).__init__()
YowInterfaceLayer.__init__(self)
self.connected = False
self.serve = Serve()
self.bus_service = ServiceBusService(
service_namespace='msgtestsb',
shared_access_key_name='RootManageSharedAccessKey',
shared_access_key_value=
'Ar9fUCZQdTL7cVWgerdNOB7sbQp0cWEeQyTRYUjKwpk=')
@ProtocolEntityCallback("message")
def onMessage(self, recdMsg):
jsondict = {'medium': 'whatsapp'}
jsondict['phonenum'] = recdMsg.getFrom(False)
jsondict['msgtype'] = recdMsg.getType()
if jsondict['msgtype'] == 'text':
jsondict['msgbody'] = recdMsg.getBody()
if jsondict['msgtype'] == 'media':
jsondict['mediatype'] = recdMsg.getMediaType()
if jsondict['mediatype'] in ["image", "audio", "video"]:
jsondict['mediaurl'] = recdMsg.getMediaUrl()
if jsondict['mediatype'] in ["image", "video"]:
jsondict['caption'] = recdMsg.getCaption()
else:
jsondict['caption'] = None
elif jsondict['mediatype'] == 'vcard':
jsondict['name'] = recdMsg.getName()
jsondict['carddata'] = recdMsg.getCardData()
elif jsondict['mediatype'] == "location":
jsondict['lat'] = recdMsg.getLatitude()
jsondict['long'] = recdMsg.getLongitude()
jsondict['name'] = recdMsg.getLocationName()
jsondict['url'] = recdMsg.getLocationURL()
jsondict['encoding'] = "raw"
if jsondict['msgtype'] == 'text':
logging.info(recdMsg.getBody())
pushjson = json.dumps(jsondict)
if AZURE_SERVICING:
msg = Message(pushjson)
self.bus_service.send_queue_message('process_incoming', msg)
else:
retjson = self.serve.getResponseWrapper(pushjson, recdMsg)
if retjson:
SendQueue.put(retjson)
self.toLower(recdMsg.ack())
self.toLower(recdMsg.ack(True))
self.sendMessages()
def sendMessages(self):
try:
sendmsg = SendQueue.get_nowait()
except:
return
jsondict = json.loads(sendmsg)
phonenum = jsondict['phonenum']
if jsondict['restype'] == 'list':
ret = jsondict['response']
else:
ret = [(jsondict['restype'], jsondict['response'])]
for (restype, response) in ret:
logging.info('%s: Send to %s %s ' %
(datetime.now(), phonenum, restype))
if restype in ['image', 'audio', 'video']:
if 'localfile' in response.keys():
path = response['localfile']
else:
mediaurl = response['mediaurl']
path = '/tmp/' + basename(mediaurl)
if isfile(path):
unlink(path)
urlretrieve(mediaurl, path)
if isfile(path):
if restype == 'image':
self.image_send(phonenum, path, response['caption'])
if restype == 'video':
# self.video_send(phonenum, path, response['caption'])
# video not supported yet
self.message_send(phonenum,
"Video Message not supported yet")
if restype == 'audio':
# self.audio_send(phonenum, path)
# video not supported yet
self.message_send(phonenum,
"Audio Message not supported yet")
elif restype == 'text':
self.message_send(phonenum, response)
elif restype == 'vcard':
self.vcard_send(phonenum, response['name'],
response['carddata'])
elif restype == 'location':
self.location_send(phonenum, response['lat'], response['long'],
response['name'], response['url'],
response['encoding'])
# handling completed queue in azure service not yet implemented
#CompletedSendQueue.append(key[1])
@ProtocolEntityCallback("receipt")
def onReceipt(self, entity):
self.toLower(entity.ack())
self.sendMessages()
def logResponse(self, msg):
if msg.getType() == 'text':
logging.info(
("Echoing %s to %s" % (msg.getBody(), msg.getFrom(False))))
elif msg.getType() == 'media':
if msg.getMediaType() in ["image", "audio", "video"]:
logging.info(
("Echoing %s %s to %s" %
(msg.getMediaType(), msg.url, msg.getFrom(False))))
elif msg.getMediaType() == "location":
logging.info(("Echoing location (%s, %s) to %s" %
(msg.getLatitude(), msg.getLongitude(),
msg.getFrom(False))))
elif msg.getMediaType() == "vcard":
logging.info(
("Echoing vcard (%s, %s) to %s" %
(msg.getName(), msg.getCardData(), msg.getFrom(False))))
@ProtocolEntityCallback("success")
def onSuccess(self, entity):
self.connected = True
logger.info("Logged in! Auth")
self.sendMessages()
@ProtocolEntityCallback("failure")
def onFailure(self, entity):
self.connected = False
logger.info("Login Failed, reason: %s" % entity.getReason())
def message_send(self, number, content):
outgoingMessage = TextMessageProtocolEntity(
content.encode("utf-8") if version_info >= (3, 0) else content,
to=self.normalizeJid(number))
self.toLower(outgoingMessage)
def vcard_send(self, number, name, carddata):
outgoingMessage = VCardMediaMessageProtocolEntity(
name, carddata, to=self.normalizeJid(number))
self.toLower(outgoingMessage)
def location_send(self, number, lat, lon, name, url, encoding):
outgoingMessage = LocationMediaMessageProtocolEntity(
lat, lon, name, url, encoding, to=self.normalizeJid(number))
self.toLower(outgoingMessage)
def image_send(self, number, path, caption=None):
jid = self.normalizeJid(number)
entity = RequestUploadIqProtocolEntity(
RequestUploadIqProtocolEntity.MEDIA_TYPE_IMAGE, filePath=path)
successFn = lambda successEntity, originalEntity: self.onRequestUploadResult(
jid, path, successEntity, originalEntity, caption)
errorFn = lambda errorEntity, originalEntity: self.onRequestUploadError(
jid, path, errorEntity, originalEntity)
self._sendIq(entity, successFn, errorFn)
def video_send(self, number, path, caption=None):
jid = self.normalizeJid(number)
entity = RequestUploadIqProtocolEntity(
RequestUploadIqProtocolEntity.MEDIA_TYPE_VIDEO, filePath=path)
successFn = lambda successEntity, originalEntity: self.onRequestUploadResult(
jid, path, successEntity, originalEntity, caption)
errorFn = lambda errorEntity, originalEntity: self.onRequestUploadError(
jid, path, errorEntity, originalEntity)
self._sendIq(entity, successFn, errorFn)
def audio_send(self, number, path):
jid = self.normalizeJid(number)
entity = RequestUploadIqProtocolEntity(
RequestUploadIqProtocolEntity.MEDIA_TYPE_AUDIO, filePath=path)
successFn = lambda successEntity, originalEntity: self.onRequestUploadResult(
jid, path, successEntity, originalEntity)
errorFn = lambda errorEntity, originalEntity: self.onRequestUploadError(
jid, path, errorEntity, originalEntity)
self._sendIq(entity, successFn, errorFn)
def normalizeJid(self, number):
if '@' in number:
return number
elif "-" in number:
return "*****@*****.**" % number
return "*****@*****.**" % number
########### callbacks ############
def onRequestUploadResult(self,
jid,
filePath,
resultRequestUploadIqProtocolEntity,
requestUploadIqProtocolEntity,
caption=None):
if requestUploadIqProtocolEntity.mediaType == RequestUploadIqProtocolEntity.MEDIA_TYPE_AUDIO:
doSendFn = self.doSendAudio
elif requestUploadIqProtocolEntity.mediaType == RequestUploadIqProtocolEntity.MEDIA_TYPE_IMAGE:
doSendFn = self.doSendImage
else:
doSendFn = self.doSendVideo
if resultRequestUploadIqProtocolEntity.isDuplicate():
doSendFn(filePath, resultRequestUploadIqProtocolEntity.getUrl(),
jid, resultRequestUploadIqProtocolEntity.getIp(), caption)
else:
successFn = lambda filePath, jid, url: doSendFn(
filePath, url, jid, resultRequestUploadIqProtocolEntity.getIp(
), caption)
mediaUploader = MediaUploader(
jid,
self.getOwnJid(),
filePath,
resultRequestUploadIqProtocolEntity.getUrl(),
resultRequestUploadIqProtocolEntity.getResumeOffset(),
successFn,
self.onUploadError,
self.onUploadProgress,
async=False)
mediaUploader.start()
def onRequestUploadError(self, jid, path,
errorRequestUploadIqProtocolEntity,
requestUploadIqProtocolEntity):
logger.error("Request upload for file %s for %s failed" % (path, jid))
def onUploadError(self, filePath, jid, url):
logger.error("Upload file %s to %s for %s failed!" %
(filePath, url, jid))
def onUploadProgress(self, filePath, jid, url, progress):
return
#sys.stdout.write("%s => %s, %d%% \r" % (os.path.basename(filePath), jid, progress))
#sys.stdout.flush()
def doSendVideo(self, filePath, url, to, ip=None, caption=None):
entity = VideoDownloadableMediaMessageProtocolEntity.fromFilePath(
filePath, url, ip, to, caption=caption)
self.toLower(entity)
def doSendImage(self, filePath, url, to, ip="127.0.0.1", caption=None):
logger.info('filepath:%s url:%s to:%s ip:%s caption:%s ' %
(filePath, url, to, ip, caption))
entity = ImageDownloadableMediaMessageProtocolEntity.fromFilePath(
filePath, url, ip, to, caption=caption)
self.toLower(entity)
def doSendAudio(self, filePath, url, to, ip=None, caption=None):
entity = AudioDownloadableMediaMessageProtocolEntity.fromFilePath(
filePath, url, ip, to)
self.toLower(entity)
def getMediaMessageBody(self, message):
if message.getMediaType() in ("image", "audio", "video"):
return self.getDownloadableMediaMessageBody(message)
else:
return "[Media Type: %s]" % message.getMediaType()
def getDownloadableMediaMessageBody(self, message):
return "[Media Type:{media_type}, Size:{media_size}, URL:{media_url}]".format(
media_type=message.getMediaType(),
media_size=message.getMediaSize(),
media_url=message.getMediaUrl())
try:
# Split and Parse emails
# Get Contents
# Save to db
doc = {}
doc['from'] = fx.getContact(email.sender)
doc['to'] = fx.getContacts(email.to_recipients)
if email.cc_recipients:
doc['cc'] = fx.getContacts(email.cc_recipients)
doc['subject'] = email.subject.strip()
msgs = fx.process(email.text_body)
msgs = [[doc['subject']]] + msgs
doc['emails'] = msgs
doc['intent'] = fx.getIntent(msgs)
#doc['intentions'] = fx.getIntentPerLine(msgs)
doc['caseid'] = str(uuid.uuid4())
doc['state'] = 'new'
doc['handoff'] = False
doc['botHasReplied'] = False
#print docid
#Send Message to Incoming Queue
event = Message(json.dumps(doc))
nttBus.send_queue_message('htn.incoming.emails', event)
docid = sdmails.insert_one(doc).inserted_id
except Exception,e:
print email.subject
print str(e)
pass
from azure.servicebus import ServiceBusService, Message, Queue
from random import randint
# Initialize
bus_service = ServiceBusService(
service_namespace='YOUR_NAMESPACE',
shared_access_key_name='RootManageSharedAccessKey',
shared_access_key_value='YOUR_KEY')
# Create a queue
bus_service.create_queue('myqueue')
# queue_options = Queue()
# queue_options.max_size_in_megabytes = '5120'
# queue_options.default_message_time_to_live = 'PT1M'
# bus_service.create_queue('myqueue', queue_options)
# Add message to queue
msg = Message(b'Test Message ' + str(randint(1000,9999)))
bus_service.send_queue_message('myqueue', msg)
# Read messages
msg = bus_service.receive_queue_message('myqueue', peek_lock=False)
print(msg.body)
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)
from azure.servicebus import ServiceBusService, Message, Queue
import os
import glob
from azure.storage.blob import BlockBlobService, PublicAccess
print("Connecting to Queue...")
bus_service = ServiceBusService(
service_namespace=os.environ['SERVICEBUS_NAMESPACE'],
shared_access_key_name=os.environ['SERVICEBUS_ACCESSKEY_NAME'],
shared_access_key_value=os.environ['SERVICEBUS_ACCESSKEY'])
block_blob_service = BlockBlobService(account_name=os.environ['STORAGE_ACCOUNT'], account_key=os.environ['STORAGE_KEY'])
container_name ='images'
block_blob_service.create_container(container_name)
generator = block_blob_service.list_blobs(container_name)
for blob in generator:
print("Pushing: " + blob.name)
msg = Message(blob.name)
bus_service.send_queue_message('cocoonaks', 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)
#Fix String data Type
text_body = data['text_body'].encode('ascii',errors = 'ignore').decode()
subject = data['subject'].encode('ascii',errors = 'ignore').decode()
frm = data['from']['name']
#Get Email Data structure and intent
emails = fx.process(text_body,frm,subject)
intent = fx.getIntent(emails)
#Prepare the doc
doc = {}
doc['emails'] = emails
doc['intent'] = intent
if (intent.get('intent')):
doc['request'] = req[intent['intent']]
#update the collection
result = collection.update_one({'caseid':data['caseid']}, {"$set":doc}, upsert=False)
#send Message to reply queue
url = "https://sd-ui.azurewebsites.net/task/"+data['caseid']
msg= {}
msg['item_id'] = data['item_id']
msg['type'] = 'link_generated'
msg['url'] = url
event = Message(json.dumps(msg))
nttBus.send_queue_message('htn.reply.email', event)
from azure.servicebus import ServiceBusService, Message, Queue
bus_service = ServiceBusService(
service_namespace='appcandy-ns',
shared_access_key_name='MachineSend',
shared_access_key_value='Q4uctgrpqj+SZOejERPkkH0Mw0r4W4mOSb7yHSmLLI4=')
msg = Message(b'New Test Message')
bus_service.send_queue_message('appcandy', msg)
from azure.servicebus import ServiceBusService, Message, Queue
bus_service = ServiceBusService(
service_namespace='cloudassignment34ed0',
shared_access_key_name='RootManageSharedAccessKey',
shared_access_key_value='P6TUMCQVFg8ZIG8Z5KiPAIFaAHzvTcX9g7n8fNYAbZ0=')
bus_service.create_queue('taskqueue')
msg = Message('Test for today Message')
bus_service.send_queue_message('taskqueue', msg)
# bus_service_r = ServiceBusService(
# service_namespace='cloudassignment34ed0',
# shared_access_key_name='RootManageSharedAccessKey',
# shared_access_key_value='P6TUMCQVFg8ZIG8Z5KiPAIFaAHzvTcX9g7n8fNYAbZ0=')
# msg = bus_service.receive_queue_message('taskqueue', peek_lock=False)
# print(msg.body)
