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)
