def main():
TOPIC_1 = '/topic/julian_1'
TOPIC_2 = '/topic/remote_queue'
SERVER = 'pcbunn.cacr.caltech.edu'
PORT = 61613
try:
# Testing remote queue
q = RemoteQueue(host=SERVER, port=PORT, destination=TOPIC_2)
stomp_1 = Client(host=SERVER, port=PORT)
stomp_1.connect()
stomp_1.subscribe(destination=TOPIC_1)
for i in range(4):
stomp_1.put(i, destination=TOPIC_1)
q.put(i+40)
for j in range(4):
message_1 = stomp_1.get(block=True)
message_2 = q.get()
print 'message_1 is ', message_1.body
print 'message_2 is ', message_2
#print 'ack'
#stomp.ack(message)
time.sleep(1.0)
except Exception, err:
print 'Error', err
return
def PostToSCE(lines):
logging.info ('Number of impressions: %s' % lines)
stomp = Client(host='activemq.dashboard.myinternaldomain.com')
stomp.connect()
body="{'host' : '%s', 'lines' : %d}" %(socket.gethostname(),lines)
stomp.put(body,"/queue/events",conf={'eventtype' : 'banner_line_count'})
stomp.disconnect()
def PostToSCE(livecampaigns):
logging.info ('Number of live Campaigns: %s' % livecampaigns)
stomp = Client(host='activemq.dashboard.internaldomain.com')
stomp.connect()
body="{'host' : '%s', 'campaigns' : %s}" %(socket.gethostname(),livecampaigns)
stomp.put(body,"/queue/events",conf={'eventtype' : 'banner_live_camp'})
stomp.disconnect()
def PostToSCE(responsetime):
logging.info ('The Response Timei was: %s' % responsetime)
stomp = Client(host='activemq.dashboard.internaldomain.com')
stomp.connect()
body="{'host' : '%s', 'responsetime' : %s}" %(socket.gethostname(),responsetime)
stomp.put(body,"/queue/events",conf={'eventtype' : 'banner_responsetime'})
stomp.disconnect()
class StompClient(QueueClient):
def __init__(self, host='127.0.0.1', username=None, password=None, exchange=None):
#TODO asserts
super(StompClient, self).__init__()
from stompy.simple import Client
self.client = Client(host)
self.client.connect(username, password)
self.agent_channel = 'jms.queue.msg.'
def put(self, message, destination='', persistent=False, conf={}):
super(StompClient, self).put(message, destination, persistent, conf)
self.client.put(message, destination=destination, persistent=persistent, conf=conf)
class RemoteQueue(object):
def __init__(self, host, port, destination):
self.host = host
self.port = port
self.destination = destination
self.stomp = Client(host, port)
self.stomp.connect()
self.stomp.subscribe(destination)
def put(self, message):
message = json.dumps(message)
self.stomp.put(message, self.destination)
def get(self):
mq_message = self.stomp.get(block=True)
message = mq_message.body
message = json.loads(message)
return message
def disconnect(self):
self.stomp.unsubscribe(self.destination)
self.stomp.disconnect()
def simple():
# 通过simple方式连接JMS服务器
# 指定hostname和port（tips:ActiveMQ支持多种协议连接stomp协议的默认端口为61613，这里不要写为61616）
stomp = Client("192.168.1.166", 61613)
# stomp = Client()#如果是ActiveMQ和ActiveMQ客户端（本程序）在同一台机器可使用默认值：hostname="localhost",port=61613
# 连接服务器
stomp.connect()
# 发送消息到指定的queue
stomp.put("The quick brown fox...", destination="/queue/hello")
# 从指定的queue订阅消息。ack参数指定为"client",不然可能出现一个问题（具体忘了，以后补充）,ack默认值为"auto"
stomp.subscribe("/queue/hello", ack="client")
# 等待接收ActiveMQ推送的消息
message = stomp.get()
# 打印消息的主体
print message.body
message.body
"quick brown fox..."
stomp.ack(message)
# 退订
stomp.unsubscribe("/queue/hello")
# 关闭连接
stomp.disconnect()
def simple():
# 通过simple方式连接JMS服务器
# 指定hostname和port（tips:ActiveMQ支持多种协议连接stomp协议的默认端口为61613，这里不要写为61616）
stomp = Client('192.168.1.166', 61613)
#stomp = Client()#如果是ActiveMQ和ActiveMQ客户端（本程序）在同一台机器可使用默认值：hostname="localhost",port=61613
# 连接服务器
stomp.connect()
# 发送消息到指定的queue
stomp.put("The quick brown fox...", destination="/queue/hello")
# 从指定的queue订阅消息。ack参数指定为"client",不然可能出现一个问题（具体忘了，以后补充）,ack默认值为"auto"
stomp.subscribe("/queue/hello", ack="client")
# 等待接收ActiveMQ推送的消息
message = stomp.get()
# 打印消息的主体
print message.body
message.body
'quick brown fox...'
stomp.ack(message)
# 退订
stomp.unsubscribe("/queue/hello")
# 关闭连接
stomp.disconnect()
manager.login(ami_username, ami_password)
if data['statusId'] == 'available':
response = queue_add(manager, data)
elif data['statusId'] == 'offline':
response = queue_remove(manager, data)
elif data['statusId'] == 'away':
response = queue_pause(manager, data)
print response.headers['Message']
manager.logoff()
elif data['type'] == channel_message.TYPE_PING:
#logging.info('ping at %s from %s', (data['id'], data['agent']))
#TODO hardcoded value
stomp.put('{"type":"pong"}', destination="jms.queue.msg." + str(data['agent']), persistent=False, conf={})
elif data['type'] == channel_message.TYPE_CHECK_CURRENT_STATUS:
manager = asterisk.manager.Manager()
manager.connect(ami_host)
manager.login(ami_username, ami_password)
response = queue_status(manager, data)
print response.headers
manager.logoff()
from stompy.simple import Client
import sys
import time
time.sleep(2)
queue_name = "/queue/test4"
if (len(sys.argv) < 2):
print("Usage: send.py total")
exit()
total = int(sys.argv[1])
count = 0
stomp = Client()
stomp.connect()
while (count < total):
stomp.put("{\"message\": \"addUser\", \"userid\": \"" + str(count) + "\"}", destination=queue_name, persistent=False)
count = count + 1;
stomp.disconnect()
#!/usr/bin/python
from stompy.simple import Client
import json
Dict_Message = dict()
Dict_Message["Test1"] = "CONDOR"
stomp = Client("localhost", 61613)
stomp.connect("producer", "pass")
stomp.put(json.dumps(Dict_Message),
destination="/queue/test",
conf={'Test': 'Test123'})
stomp.disconnect()
stomp = Client("localhost", 61613)
stomp.connect("consumer", "pass")
stomp.subscribe("/queue/test", conf={'selector': "Test = 'Test123'"})
#stomp.subscribe("/queue/test")
message = stomp.get()
print message.headers
New_Dict = json.loads(message.body)
print New_Dict
stomp.ack(message)
stomp.unsubscribe("/queue/test")
stomp.disconnect()
readings[index] = newtemp # put the new temp in the array
total = total - oldtemp + newtemp # adjust the total
average = total / N # calculate the average
# update the min and max
if average < min:
min = average
if average > max:
max = average
#print round(average, 2), round(min,2), round(max,2)
index += 1 # increment the index
if index >= N: # reset index if needed
index = 0
# build json
msg = {
'avg': round(average, 2),
'target': round(target, 2),
'min': round(min, 2),
'max': round(max, 2),
'timestamp': stamp
}
print(json.dumps(msg))
# put message on queue
stomp.put(msg, destination="/queue/test-queue", persistent=True)
time.sleep(1) # sleep for 1 sec
r[':filter'] = {
'identity': [],
'fact': [],
'agent': [],
'cf_class': [],
}
r[":requestid"] = rid
r[":callerid"] = 'cert=%s' % CERTNAME
r[":senderid"] = 'pythontest'
r[":msgtarget"] = target
r[':body'] = yaml.dump('ping')
h = rr.sign(sha1(r[':body']).digest(), 'sha1')
r[':hash'] = h.encode('base64').replace("\n", "").strip()
data = yaml.dump(r)
s.put(data, target)
time.sleep(2)
results = []
while True:
x = None
try:
x = s.get_nowait()
print x
except:
break
if not x:
break
y = yaml.load(x.body)
print y
if y[':requestid'] == rid:
results.append(y)
class SimpleRPCAction(object):
def __init__(self, agent, action, config=None, stomp_client=None, autoconnect=True, **kwargs):
self.agent = agent
self.action = action
self.config = config or Config()
self.params = kwargs
self.stomp_target = '%s.%s.command' % (self.config.topicprefix, agent)
self.stomp_target_reply = '%s.%s.reply' % (self.config.topicprefix, agent)
self.stomp_client = stomp_client
self.signer = PROVIDERS.get(self.config.securityprovider)
if self.signer:
caller = basename(self.config.pluginconf['ssl_client_public']).split('.')[0]
self.signer = self.signer(
self.config.pluginconf['ssl_client_private'],
caller,
)
if autoconnect and not stomp_client:
self.connect_stomp()
def connect_stomp(self):
self.stomp_client = Client(
self.config.pluginconf['stomp.host'],
int(self.config.pluginconf['stomp.port']),
)
self.stomp_client.connect(
self.config.pluginconf['stomp.user'],
self.config.pluginconf['stomp.password'],
)
def send(self, filter_=None, process_results=True, **kwargs):
body = dict()
body[':action'] = self.action
body[':agent'] = self.agent
body[':data'] = dict([(':%s' % k, v) for k, v in kwargs.items()])
body[':data'][':process_results'] = process_results
m = Message(body, self.stomp_target, filter_=filter_)
if self.signer:
self.signer.sign(m)
data = safe_dump(m.request, explicit_start=True, explicit_end=False)
body = "\n".join([' %s' % line for line in m.body.split("\n")])
data = data + ":body: |\n" + body
self.data = data
if process_results:
self.stomp_client.subscribe(self.stomp_target_reply)
self.stomp_client.put(data, self.stomp_target)
sleep(2)
self.stomp_client.unsubscribe(self.stomp_target_reply)
return self.collect_results(m.rid)
self.stomp_client.put(data, self.stomp_target)
def collect_results(self, request_id):
'''Collect the results from a previous :func:`Message.send` call.
:rtype: list of STOMP messages which match this object's `:requestid`'''
results = []
while True:
message = None
try:
message = self.stomp_client.get_nowait()
except Exception, e:
break
decoded_message = load(message.body.replace('!ruby/sym ', ':'))
if decoded_message[':requestid'] == request_id:
results.append(decoded_message)
return results
class SimpleRPCAction(object):
def __init__(self, agent, action, config=None, stomp_client=None,
autoconnect=True, **kwargs):
self.agent = agent
self.action = action
self.config = config or Config()
self.params = kwargs
if self.config.connector == 'stomp':
suffix = 'command'
else:
suffix = 'agent'
self.stomp_target = "{0}.{1}".format(self.target, suffix)
self.stomp_target_reply = '%s.reply' % self.target
self.stomp_client = stomp_client
self.signer = PROVIDERS.get(self.config.securityprovider)
if self.signer:
self.signer = self.signer(config)
if autoconnect and not stomp_client:
self.connect_stomp()
@property
def target(self):
'''MColletive target, based on topic and collective'''
collective = self.params.get('collective', self.config.main_collective)
return "{topicprefix}{collective}.{agent}".format(
topicprefix=self.config.topicprefix,
collective=collective,
agent=self.agent)
def connect_stomp(self):
'''Connect to stomp server'''
if self.config.connector == 'stomp':
key = 'stomp'
elif self.config.connector == 'activemq':
# FIXME(rafaduran): take advantage of multiple stomp servers
key = 'activemq.pool.1'
self.stomp_client = Client(
self.config.pluginconf['{key}.host'.format(key=key)],
int(self.config.pluginconf['{key}.port'.format(key=key)]),
)
self.stomp_client.connect(
self.config.pluginconf['{key}.user'.format(key=key)],
self.config.pluginconf['{key}.password'.format(key=key)],
)
def send(self, filter_=None, process_results=True, **kwargs):
if (self.agent == 'discovery') and (self.action == 'ping'):
body = 'ping'
else:
body = dict()
body[':action'] = self.action
body[':agent'] = self.agent
body[':data'] = dict([(':%s' % k, v) for k, v in kwargs.items()])
body[':data'][':process_results'] = process_results
collective = self.params.get('collective', self.config.main_collective)
if self.signer:
# body[':caller'] = self.signer.caller_id
m = Message(body, self.stomp_target, filter_=filter_,
agent=self.agent, identity=self.config.identity,
collective=collective)
self.signer.sign(m)
else:
m = Message(body, self.stomp_target, filter_=filter_,
agent=self.agent, identity=self.config.identity,
collective=collective)
self.request = m.request
data = safe_dump(m.request, explicit_start=True, explicit_end=False)
body = "\n".join([' %s' % line for line in m.body.split("\n")])
data = data + ":body: " + body
self.data = data
if process_results:
self.stomp_client.subscribe(self.stomp_target_reply)
if self.config.connector == 'activemq':
conf = {'reply-to': self.stomp_target_reply}
else:
conf = None
self.stomp_client.put(data, self.stomp_target, conf=conf)
sleep(2)
self.stomp_client.unsubscribe(self.stomp_target_reply)
return self.collect_results(m.rid)
self.stomp_client.put(data, self.stomp_target)
def collect_results(self, request_id):
'''Collect the results from a previous :func:`Message.send` call.
:rtype: list of STOMP messages which match this object's `:requestid`
'''
results = []
while True:
message = None
try:
message = self.stomp_client.get_nowait()
except Exception, e:
break
decoded_message = load(message.body.replace('!ruby/sym ', ':'))
if decoded_message[':requestid'] == request_id:
results.append(decoded_message)
return results
class WhenUsingSimpleClient(DingusTestCase(Client,
exclude=['TransactionError', 'Empty'])):
def setup(self):
super(WhenUsingSimpleClient, self).setup()
self.client = Client()
def should_connect(self):
self.client.connect()
assert self.client.stomp.calls('connect')
def should_disconnect(self):
self.client.disconnect()
assert self.client.stomp.calls('disconnect')
def should_subscribe(self):
self.client.subscribe('/queue/nose_test')
print self.client.stomp.calls
assert self.client.stomp.calls('subscribe',
{'ack': 'auto', 'destination': '/queue/nose_test'})
def should_unsubscribe(self):
self.client.unsubscribe('/queue/nose_test')
assert self.client.stomp.calls('unsubscribe',
{'destination': '/queue/nose_test'})
def should_begin_transaction(self):
self.client.begin('bah')
assert self.client.stomp.calls('begin',
{"transaction": self.client._current_transaction})
def should_fail_to_begin_already_in_transaction(self):
self.client._current_transaction = "meh"
nose_tools.assert_raises(TransactionError, self.client.begin, 'bah')
def should_commit_transaction(self):
self.client._current_transaction = 'meh'
self.client.commit('bah')
assert self.client.stomp.calls('commit', {'transaction': 'meh'})
def should_fail_to_commit_transaction(self):
nose_tools.assert_raises(TransactionError, self.client.commit, 'bah')
def should_abort_transaction(self):
self.client._current_transaction = 'meh'
self.client.abort()
assert self.client.stomp.calls('abort', {'transaction': 'meh'})
def should_fail_to_abort_transaction(self):
nose_tools.assert_raises(TransactionError, self.client.abort)
def should_ack_message(self):
self.client.ack("fake_frame")
assert self.client.stomp.calls('ack', "fake_frame")
def should_make_conf(self):
conf = self.client._make_conf(None,
destination='/queue/nose_test', ack='auto')
assert isinstance(conf, type({}))
def should_make_conf_with_transaction(self):
self.client._current_transaction = 'meh'
conf = self.client._make_conf({},
destination='/queue/nose_test', ack='auto')
assert isinstance(conf, type({}))
def should_put_item_into_queue(self):
self.client.put('bah', '/queue/nose_test')
conf = self.client._make_conf(None, body='bah',
destination='/queue/nose_test',
persistent='true')
assert self.client.stomp.calls('send', conf)
def should_get_message(self):
self.client.get()
assert self.client.stomp.calls('receive_frame', nonblocking=False, callback=None)
def should_get_message_without_blocking(self):
self.client.get_nowait()
assert self.client.stomp.calls('receive_frame', nonblocking=True, callback=None)
def should_not_get_message(self):
self.client.stomp.receive_frame.return_value = None
nose_tools.assert_raises(self.client.Empty,
self.client.get, block=False)
manager.connect(ami_host)
manager.login(ami_username, ami_password)
if data['statusId'] == 'available':
response = queue_add(manager, data['agent'])
elif data['statusId'] == 'offline':
response = queue_remove(manager, data['agent'])
elif data['statusId'] == 'away':
response = queue_pause(manager, data['agent'])
print response.headers['Message']
manager.logoff()
elif data['type'] == channel_message.TYPE_PING:
#logging.info('ping at %s from %s', (data['id'], data['agent']))
stomp.put('{"type":"pong"}', destination="jms.queue.msg." + str(data['agent']), persistent=False, conf={})
elif data['type'] == channel_message.TYPE_CHECK_CURRENT_STATUS:
manager = asterisk.manager.Manager()
manager.connect(ami_host)
manager.login(ami_username, ami_password)
response = queue_status(manager, data['agent'])
print response.headers
manager.logoff()
