def test_send_receive_message(self): q = self.conn.create_queue('message_test') msg_created = Message() msg_created.set_body('hello world') msg_sent = q.write(msg_created) self.assertEquals(msg_created, msg_sent) read_msg = q.read() self.assertIsNotNone(read_msg) print 'written', msg_created.get_body() print 'read', read_msg.get_body() self.assertEquals(msg_created.get_body(), read_msg.get_body())
def queue_msgs_write(qid): """ Write a new message to a queue curl -s -X POST -H 'Accept: application/json' http://localhost:8080/queues/<mytestqueue>/msgs -d '{"content": "this is the message I want to put on the queue"}' """ body = request.get_json(force=True) content = body['content'] conn = get_conn() if conn.lookup(qid) == None: return "queue " + qid + " is not existed." else: q = conn.get_queue(qid) m = Message() m.set_body(content) q.write(m) item = {} item['name'] = q.name item['message'] = m.get_body() resp = json.dumps(item) return Response(response = resp, mimetype = "application/json")
class MyMessage(object): def __init__(self): STATUS_OPS = ('REJECTED', 'ACCEPTED') self.where = {'notification_enabled': False, 'channels': list()} self.data = { "title": "", #Titulo del mensaje push "alert": "", #Descripcion del mensaje Push (iOS) "status": "", # Estado de la tarea "task": "", # Titulo de la tarea "user": "", #Quien ejecuto la accion "team_id": 0, # Id por el cual se actualiza el stack de notiticaciones "team": "" # Llave para agrupar las notificaciones } self.message = MessageBoto() def build_message(self): """ build a Message obj, from where and data """ body = {'where': self.where, 'data': self.data} self.message.set_body( str(body).replace('\'', '"').replace('True', 'true')) def fill_content(self, placeholder, data): #has to be fixed data_array = [{k: v} for k, v in data.items()] if placeholder == 'data': self.data = data_array elif placeholder == 'where': self.where = data_array def __str__(self): return self.message.get_body()
def analyzeDockerName(request): dname = request.POST['dname'] # print dname conn = boto.sqs.connect_to_region( "us-west-2", aws_access_key_id=config.sqs_access_key, aws_secret_access_key=config.sqs_access_secret) queue = conn.get_queue("Image") mes = Message() mes.set_body(dname) queue.write(mes) find = False while (not find): queue = conn.get_queue("Package") messages = queue.get_messages() for mes in messages: pkglist = mes.get_body() find = True break if (len(messages) != 0): queue.delete_message_batch(messages) # res = os.popen('./script.sh ' + dname) # for i in range(4): # res.readline() pkglist = pkglist.split() return render_to_response('packages.html', {"pkglist": pkglist})
def queue_msgwrite(queue): """ Writes a message to the queue curl -X POST -H 'Content-Type: application/json' http://localhost:5000/queue/<mytestqueue>/msqs -d '{"content":"message"}' """ conn = get_conn() body = request.get_json(force=True) q = conn.get_queue("C13765235-%s" % queue) resp = {} if q != None: m = Message() m.set_body(body["content"]) q.write(m) resp["id"] = q.id resp["message"] = m.get_body() else: resp["status"] = "Not Found" return Response( response=json.dumps(resp), mimetype="application/json" )
def send_to_sqs(self, msg): global log conn = boto.sqs.connect_to_region(settings.AWS_CONF['region'], aws_access_key_id=settings.AWS_CONF['awskey'], aws_secret_access_key=settings.AWS_CONF['awssecret'], is_secure=False) try: parsed_json = simplejson.loads(msg) except Exception as e: logger.critical("Invalid message:%s Reason:%s" % (msg, e)) # wrap with timestamp if 'timestamp' not in parsed_json: msg = '{"event":%s , "timestamp":"%d"}' % (msg, int(time())) logger.info('Message %s' % msg) # Send to SQS if conn is None: logger.critical("Could not connect to AWS: region=%s" % settings.AWS_CONF['region']) else: q = conn.get_queue(settings.AWS_CONF['sqsqueue']) if q is None: logger.critical("Error connecting to SQS queue: %s" % settings.AWS_CONF['sqsqueue']) return m = Message() m.set_body(msg) q.write(m) if m.id is None: logger.critical("Could not send this msg to queue: %s" % m.get_body()) else: logger.info('Wrote %s' % m.id)
def test_create_job_from_message(self): message = Message(body=dumps({ 'callable': random_job, 'args': (), 'kwargs': {}, })) job = Job.from_message(message) self.assertEqual(message.get_body(), job.message.get_body())
def test_create_job_from_message(self): message = Message(body=dumps({ 'callable': random_job, 'args': (), 'kwargs': {}, })) job = Job.from_message(message) self.assertEqual(message.get_body(), job.message.get_body())
def getMsg(qid): conn = boto.sqs.connect_to_region(region) q = conn.get_queue(qid) try: m = Message() m = q.read(60) str1 = m.get_body() return jsonify({'message': str1}), 200 except: return jsonify( {'ERROR': "Could not read message or queue does not exist"}), 404
def readq(username): conn = boto.sqs.connect_to_region( "eu-west-1", aws_access_key_id="AKIAJBPNKK2PQQPPU7PA", aws_secret_access_key="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") q = conn.get_queue(username) try: m = Message() m = q.read(60) str1 = m.get_body() return 'Message read = ' + str1 except: return 'Could not read message'
class QMessage(object): __message = None def __init__(self, *args, **kwargs): self.__message = kwargs.get("message", None) def get_object(self): return self.__message def set_body(self, message_body): if self.__message is None: self.__message = Message() self.__message.set_body(message_body) def get_body(self): return self.__message.get_body()
def readQueueMessage(name): conn = boto.sqs.connect_to_region( "eu-west-1", aws_access_key_id=settings.AWS_ACCESS_KEY_ID, aws_secret_access_key=settings.AWS_SECRET_ACCESS_KEY) q = conn.get_queue(name) try: m = Message() m = q.read(60) str1 = m.get_body() result = "Message read = " + str1 return result except: return "Could not read message"
def WriteMessage(name): name = "C13729611_"+name conn = get_conn() rs = conn.get_queue(name) body = request.get_json(force=True) message = body["content"] m = Message() m.set_body(message) resp = "Failed to write message" if rs is not None: rs.write(m) resp = "Message '" + m.get_body() + "' is written to queue: " + name resp = {"Response": resp} resp = json.dumps(resp) return Response(response=resp,mimetype="application/json")
def queues_read(): from keys import access_key_id, secret_access_key parser = argparse.ArgumentParser() parser.add_argument("qname") args = parser.parse_args() conn = boto.sqs.connect_to_region("eu-west-1", aws_access_key_id=access_key_id, aws_secret_access_key=secret_access_key) q = conn.get_queue(args.qname) try: m = Message() m = q.read(60) str1 = m.get_body() print "Message read = ", str1 except: print "Could not read message"
def consumeq(username): conn = boto.sqs.connect_to_region( "eu-west-1", aws_access_key_id="AKIAJBPNKK2PQQPPU7PA", aws_secret_access_key="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") q = conn.get_queue(username) try: m = Message() m = q.read(60) str1 = m.get_body() print "Message read = " + str1 except: return 'Could not read message' try: q.delete_message(m) return 'message deleted from the queue' except: return 'Could not delete message'
def send_to_sqs(msg): parsed_json = '' conn = boto.sqs.connect_to_region( settings.AWS_CONF['region'], aws_access_key_id=settings.AWS_CONF['awskey'], aws_secret_access_key=settings.AWS_CONF['awssecret'], is_secure=False) try: parsed_json = simplejson.loads(msg) except Exception as e: logger.critical('Invalid message:%s Reason:%s' % (msg, e)) return False # wrap with timestamp if 'timestamp' not in parsed_json: msg = '{"event":%s , "timestamp":"%d"}' % ( msg, int(datetime.utcnow().strftime('%s'))) logger.debug('Message %s' % msg) # Send to SQS if conn is None: logger.critical("Could not connect to AWS: region=%s" % settings.AWS_CONF['region']) return False else: q = conn.get_queue(settings.AWS_CONF['sqsqueue']) if q is None: logger.critical("Error connecting to SQS queue: %s" % settings.AWS_CONF['sqsqueue']) return m = Message() m.set_body(msg) q.write(m) if m.id is None: logger.critical('Could not send this msg to queue: %s' % m.get_body()) return False else: logger.info('Incident successfully written to SQS, msg_id:%s' % m.id) return True
def consumeQueueMessage (name): conn = boto.sqs.connect_to_region("eu-west-1", aws_access_key_id=settings.AWS_ACCESS_KEY_ID,aws_secret_access_key=settings.AWS_SECRET_ACCESS_KEY) q = conn.get_queue(name) result = "" try: m = Message() m = q.read(60) str1 = m.get_body() result = "Message read = " + str1 + " \n" except: result = result + "Could not read message\n" try: q.delete_message(m) result = result + "message deleted from the queue\n" except: result = result + "Could not delete message\n" return result
def queue_msgwrite(queue): """ Writes a message to the queue curl -X POST -H 'Content-Type: application/json' http://localhost:5000/queues/<mytestqueue>/msgs -d '{"content":"message"}' """ conn = get_conn() body = request.get_json(force=True) q = conn.get_queue("D14123580-%s" % queue) resp = {} if q != None: m = Message() m.set_body(body["content"]) q.write(m) resp["id"] = q.id resp["message"] = m.get_body() else: resp["status"] = "Not Found" return Response(response=json.dumps(resp), mimetype="application/json")
def send_to_sqs(msg): parsed_json = '' conn = boto.sqs.connect_to_region(settings.AWS_CONF['region'], aws_access_key_id=settings.AWS_CONF['awskey'], aws_secret_access_key=settings.AWS_CONF['awssecret'], is_secure=False) try: parsed_json = simplejson.loads(msg) except Exception as e: logger.critical('Invalid message:%s Reason:%s' % (msg, e)) return False # wrap with timestamp if 'timestamp' not in parsed_json: msg = '{"event":%s , "timestamp":"%d"}' % (msg, int(datetime.utcnow().strftime('%s'))) logger.debug('Message %s' % msg) # Send to SQS if conn is None: logger.critical("Could not connect to AWS: region=%s" % settings.AWS_CONF['region']) return False else: q = conn.get_queue(settings.AWS_CONF['sqsqueue']) if q is None: logger.critical("Error connecting to SQS queue: %s" % settings.AWS_CONF['sqsqueue']) return m = Message() m.set_body(msg) q.write(m) if m.id is None: logger.critical('Could not send this msg to queue: %s' % m.get_body()) return False else: logger.info('Incident successfully written to SQS, msg_id:%s' % m.id) return True
newQueue = conn.create_queue("queue4Messages") #creating messages #we get the queue where we want to write in #q = conn.get_all_queues() q = conn.get_queue('queue4Messages') #then we create the message object m = Message() #we want to create 100messages, strmessage = "That message " for i in range(1, 100): newM = strmessage + str(i) m.set_body('message') q.write(m) rs = q.get_messages() m = rs[5] messagereceived = m.get_body() print messagereceibed #deleting all the messages for i in range(1, 100): m = rs[i] q.delete_message(m)
# create a queue q = conn.create_queue('myqueue') print q # listing all the queues for this account list = conn.get_all_queues() print list # getting a queue by name my_queue = conn.get_queue('myqueue') print my_queue # writing a message in queue m = Message() m.set_body('This is my first message.') q.write(m) # reading messages from queue rs = q.get_messages() print len(rs) m = rs[0] print m.get_body() # Delete message q.delete_message(m) # Delete the queue conn.delete_queue(q)
__author__="charoy" __date__ ="$17 juil. 2013 21:37:19$" import boto.sqs from boto.sqs.message import Message conn = boto.sqs.connect_to_region("us-west-2") q = conn.create_queue('myqueue') m = Message() m.set_body('This is my first message.') status = q.write(m) rs = q.get_messages() print len(rs) m = rs[0] print m.get_body(); if __name__ == "__main__": print "Hello World";
conn = boto.sqs.connect_to_region( "us-east-1", aws_access_key_id='AKIAINWVSI3MIXIB5N3Q', aws_secret_access_key='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') my_queue = conn.get_queue(args.echo) m = Message() print "Reading Queue " + args.echo + " Messages read are deleted" while True: try: try: rs = my_queue.get_messages(num_messages=10, visibility_timeout=12000, wait_time_seconds=5) if (len(rs) == 0): print args.echo + " len = 0 now empty" sys.exit(0) for msgcounter in range(len(rs)): m = rs[msgcounter - 1] print m.get_body() #my_queue.delete_message(m) except: if my_queue.count() < 1: print args.echo + " is now empty" sys.exit(0) time.sleep(3) except KeyboardInterrupt: sys.exit(0)
rs = conn.get_all_queues() for q in rs: print q.id # write a message to the queue m = Message() m.set_body('Hello to you!') q.write(m) #write 100 messages to the queue i=0 for i in range(0, 99): m.set_body('All the messages'+i) q.write(m) #read a message from queue rs = q.get_messages() m = rs[27] m.get_body() #delete a message q.delete_message(m)
import boto.sqs import boto.sqs.queue from boto.sqs.message import Message from boto.sqs.connection import SQSConnection from boto.exception import SQSError conn = boto.sqs.connect_to_region('us-east-1',aws_access_key_id='BKIAIR7EH3TNSTDUCWKB',aws_secret_access_key='s2FZT5mrLYy8gX7kS1q0p4ObQYXTwGnaiUm+rxHA') q=conn.create_queue('C12339291') m=Message() m.set_body('First message.') q.write(m) rs=q.get_messages() len(rs) m=rs[0] messageVar=m.get_body() print(messageVar) q.delete_message(m)
from boto.exception import SQSError import sys keys = httplib.HTTPConnection("ec2-52-30-7-5.eu-west-1.compute.amazonaws.com:81") keys.request("GET", "/key") r1 = keys.getresponse().read().split(":") # Get the keys from a specific url and then use them to connect to AWS Service access_key_id = r1[0] secret_access_key = r1[1] # Set up a connection to the AWS service. conn = boto.sqs.connect_to_region( "eu-west-1", aws_access_key_id=access_key_id, aws_secret_access_key=secret_access_key ) # Get a list of the queues that exists and then print the list out # Do not use / or " in the name q = conn.get_queue("C13765235-%s" % sys.argv[1]) m = Message() m.set_body(sys.argv[2]) q.write(m) print("Message %s written to the queue" % m.get_body())
# simple script to create messages in an SQS queue import boto.sqs from boto.sqs.message import Message import string import random import time conn_sqs = boto.sqs.connect_to_region("us-west-2") my_queue = conn_sqs.get_queue('demoQueue1') def string_generator(size=6, chars=string.ascii_uppercase + string.digits): return ''.join(random.choice(chars) for _ in range(size)) m = Message() m.set_body(string_generator()) my_queue.write(m) print "Added the following string to the queue: " + m.get_body()
key_id_queue = raw_input("GPG Key ID: ") q = conn.create_queue(key_id_queue) m = Message() message = raw_input("Message: ") encrypt_message = str(gpg.encrypt(message, key_id_queue)) print "Encrypted Message Send to SQS: " + encrypt_message m.set_body(encrypt_message) q.write(m) if n.strip() == 'recieve': print gpg.list_keys(True) key_id_queue = raw_input("GPG Private ID: ") password = getpass.getpass() q = conn.get_queue(key_id_queue) rs = q.get_messages() m = rs[0] pulled_encrypt_message = m.get_body() print "Pulled Encrypted Message: " + pulled_encrypt_message decrypted_message = str(gpg.decrypt(str(pulled_encrypt_message), passphrase=password)) if decrypted_message == '': print "Posting back to SQS, incorrect key or password" q.write(m) else: print "Decrypted Message: " + decrypted_message if n.strip() == 'search': search = raw_input("Search for: ") response = urllib.urlopen("http://pgp.mit.edu:11371/pks/lookup?options=mr&op=get&search=" + search) pub_key = response.read() from pgpdump import AsciiData test = AsciiData(pub_key) test.strip_magic(pub_key) packets = list(test.packets())
parser.add_argument("qname") args = parser.parse_args() conn = boto.sqs.connect_to_region("us-west-2a") q = conn.get_queue(args.qname) try: m = Message() m = q.read(60) str1 = m.get_body() print "Message read = ", str1 except: print "Could not read message"
YOUR_SECRET_KEY = "lwVBol6OuS32W4DA+kasw5Qv8W5HfrKFCMC9g01W" REGION = "us-west-2" # Create the queue. This returns an SQS.Queue instance # queue = sqs.create_queue(QueueName='test', Attributes={'DelaySeconds': '5'}) # awsauth = AWS4Auth(YOUR_ACCESS_KEY, YOUR_SECRET_KEY, REGION, 'es') conn = boto.sqs.connect_to_region( REGION, aws_access_key_id=YOUR_ACCESS_KEY, aws_secret_access_key=YOUR_SECRET_KEY) # print conn.get_all_queues() # q = conn.get_queue('newsyQueue') #non-fifo q = conn.get_queue('newsQueue.fifo') #fifo print (q) m = Message() m.set_body('Reader started at this point') # m.set_group_id('lalala') # q.set_attributes( # Attributes={ # "ContentBasedDeduplication": True # }) resp = q.write(m) print ("added message, got {}").format(resp) while(True): for m in q.get_messages(): print (m, m.get_body()) q.delete_message(m) time.sleep(1)
import boto.sqs import argparse from boto.sqs.message import Message from subprocess import call parser = argparse.ArgumentParser() parser.add_argument("echo") args = parser.parse_args() conn = boto.sqs.connect_to_region( "us-east-1", aws_access_key_id='AKIAINWVSI3MIXIB5N3Q', aws_secret_access_key='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') my_queue = conn.get_queue(args.echo) m = Message() while True: m = my_queue.read(60) counter = my_queue.count() # print "Messages after read", counter , "This Messages = ", m.get_body() #This will run a command and check the return value return_code = call(['./do_work', str(m.get_body())]) if return_code > 0: print "message not deleted return code is = ", return_code else: my_queue.delete_message(m) print "message deleted from the queue "
from boto.sqs.message import Message from boto.sqs.connection import SQSConnection from boto.exception import SQSError import sys keys = httplib.HTTPConnection( "ec2-52-30-7-5.eu-west-1.compute.amazonaws.com:81") keys.request("GET", "/key") r1 = keys.getresponse().read().split(":") # Get the keys from a specific url and then use them to connect to AWS Service access_key_id = r1[0] secret_access_key = r1[1] # Set up a connection to the AWS service. conn = boto.sqs.connect_to_region("eu-west-1", aws_access_key_id=access_key_id, aws_secret_access_key=secret_access_key) # Get a list of the queues that exists and then print the list out # Do not use / or " in the name q = conn.get_queue("D14123580-%s" % sys.argv[1]) m = Message() m.set_body(sys.argv[2]) q.write(m) print("Message %s has been written to the queue" % m.get_body())
return resp.read() # url=raw_input("Url: ") url = "http://ec2-52-30-7-5.eu-west-1.compute.amazonaws.com" # port=raw_input("Port number: ") port = str(81) # Get the keys from a specific url and then use them to connect to AWS Service list = get_key_and_id(url, port).split(':') access_key_id = list[0] secret_access_key = list[1] # Set up a connection to the AWS service. conn = boto.sqs.connect_to_region("eu-west-1", aws_access_key_id=access_key_id, aws_secret_access_key=secret_access_key) if len(sys.argv) != 3: print "How to use: python <python file name> <queue name> <message>" exit(1) if conn.lookup(sys.argv[1]) == None: print sys.argv[1] + " queue is not existed." else: q = conn.get_queue(sys.argv[1]) m = Message() m.set_body(sys.argv[2]) q.write(m) print "Message " + m.get_body() + " is written to the queue " + q.name
import argparse from boto.sqs.attributes import Attributes from boto.sqs.message import Message from boto.sqs.connection import SQSConnection from boto.exception import SQSError import sys sys.path.append('/data') from keys import access_key_id, secret_access_key parser = argparse.ArgumentParser() parser.add_argument("qname") args = parser.parse_args() conn = boto.sqs.connect_to_region("eu-west-1", aws_access_key_id=access_key_id, aws_secret_access_key=secret_access_key) q = conn.get_queue(args.qname) try: m = Message() m = q.read(60) str1 = m.get_body() print "Message read = ", str1 except: print "Could not read message" print boto.Version try: q.delete_message(m) print "message deleted from the queue" except: print "Could not delete message"
#we get the queue where we want to write in #q = conn.get_all_queues() q = conn.get_queue('queue4Messages') #then we create the message object m = Message() #we want to create 100messages, strmessage = "That message " for i in range(1,100): newM = strmessage + str(i) m.set_body('message') q.write(m) rs = q.get_messages() m = rs[5] messagereceived = m.get_body() print messagereceibed #deleting all the messages for i in range(1,100): m = rs[i] q.delete_message(m)