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='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)