def publish(msg, room, token):
publisher = Publisher(room=room, token=token)
publisher.start()
publisher.publish(msg)
_, data = publisher.recv()
if not data == b'publish successful':
raise Exception(data)
publisher.stop()
def process_withdrawal_status(self, message):
self.info("Publish .. creating publish instance, queue," \
"exchange: (%s, %s) " % ('WITHDRAWAL_STATUS', 'WITHDRAWAL_STATUS'))
message['exchange'] = 'WITHDRAWAL_STATUS'
publisher = Publisher('WITHDRAWAL_STATUS', 'WITHDRAWAL_STATUS')
self.logger.info("Publish calling publish status : %r" % message)
publisher.publish(message, 'WITHDRAWAL_STATUS')
self.info(
"POST: Withdraw status Queued successfully with message: %r " %
message)
def process_message_status(self, message):
self.info("Publish .. creating publish instance, queue," \
"exchange: (%s, %s) " % ('DLR_QUEUE', 'DLR_QUEUE'))
message['exchange'] = 'DLR_QUEUE'
message['reference'] = message.get('ref_no')
publisher = Publisher('DLR_QUEUE', 'DLR_QUEUE')
self.logger.info("Publish calling publish status : %r" % message)
publisher.publish(message, 'DLR_QUEUE')
self.info("POST: DLR Queued successfully with message: %r " % message)
def get(self):
message = self.get_message_dict()
self.logger.info("Publish .. creating publish instance, queue," \
"exchange: (%s, %s) " % (self.QUEUE_NAME, self.EXCHANGE_NAME))
publisher = Publisher(self.QUEUE_NAME, self.EXCHANGE_NAME)
self.logger.info("Publish calling publish : %r" % message)
q_message = self.get_queue_message(message)
publisher.publish(q_message, self.ROUTING_KEY)
self.info("GET: Task Queued successfully with message: %r " % message)
return self.response(message.get('TransID'), 201,
'Transaction queued succcess'), 200
def get(self):
message = self.get_message_dict()
self.logger.info("Publish .. creating publish instance, queue," \
"exchange: (%s, %s) " % (self.SMS_QUEUE_NAME, self.SMS_EXCHANGE_NAME))
message['exchange'] = self.SMS_EXCHANGE_NAME
publisher = Publisher(self.SMS_QUEUE_NAME, self.SMS_EXCHANGE_NAME)
self.logger.info("Publish calling publish : %r" % message)
publisher.publish(message, self.SMS_ROUTING_KEY)
self.info("GET: Task Queued successfully with message: %r " % message)
return self.response()
class SerialData(object):
""" This class handles the communication with Arduino Boards.
"""
def __init__(self, port='/dev/ttyACM1'):
signal.signal(signal.SIGINT, self.signal_handler)
self.__publisher = Publisher()
self.__last_received = '{"temperature":"-100","humidity":"-100"}'
self.__kill_received = False
try:
self.ser = serial.Serial(
port=port,
baudrate=9600,
bytesize=serial.EIGHTBITS,
parity=serial.PARITY_NONE,
stopbits=serial.STOPBITS_ONE,
timeout=0.1,
xonxoff=0,
rtscts=0,
interCharTimeout=None
)
except serial.serialutil.SerialException:
# no serial connection
self.ser = None
else:
self.__thread = Thread(target=self.__receiving, args=(self.ser,)).start()
def __receiving(self, ser):
readline = ''
while not self.__kill_received:
if self.__kill_received:
logging.debug('got kill')
readline = ser.readline()
if readline != '':
self.__last_received = readline
self.__publisher.publish(self.__last_received)
def next(self):
if not self.ser:
return 100 # return anything so we can test when Arduino isn't connected
for j in range(40):
raw_line = self.__last_received
try:
# logging.debug(raw_line.strip())
return raw_line.strip()
except ValueError, e:
# print 'bogus data',raw_line
logging.debug("Value Error: {0}".format(raw_line.strip()))
print str(e)
time.sleep(.005)
return 0.
def post(self):
message = self.get_message_dict()
self.info("Received inbox post request ==> %r" % (message, ))
if not message or not message.get('short_code'):
return {
'response_code': 400,
'response_desc': 'Missing MSISDN on POST'
}, 400
message['exchange'] = self.SMS_EXCHANGE_NAME
publisher = Publisher(self.SMS_QUEUE_NAME, self.SMS_EXCHANGE_NAME)
self.logger.info("Publish calling publish : %r" % message)
publisher.publish(message, self.SMS_ROUTING_KEY)
self.info("POST: Task Queued successfully with message: %r " % message)
return self.response()
def post(self):
message = self.get_message_dict()
if not message or not message.get('TransID'):
return {
'response_code': 400,
'response_desc': 'Missing transaction ID'
}, 400
message['exchange'] = self.EXCHANGE_NAME
publisher = Publisher(self.QUEUE_NAME, self.EXCHANGE_NAME)
self.logger.info("Publish calling publish : %r => Q = %s, EX=%s" %
(message, self.QUEUE_NAME, self.EXCHANGE_NAME))
q_message = self.get_queue_message(message)
publisher.publish(q_message, self.ROUTING_KEY)
self.info("POST: Task Queued successfully with message: %r " % message)
return self.response(message.get('TransID'), 201, 'Succcess')
class RPData(object):
"""This class handles hardware communication with sensors and actuators directly attached to
the RPi
"""
def __init__(self):
signal.signal(signal.SIGINT, self.signal_handler)
self.__lastswitchstate = 1;
self.__temperature = -100;
self.__humidity = 0;
self.__thread = Thread(target=self.__receiving).start()
self.__kill_received = False
self.__publisher = Publisher()
def __receiving(self):
"""This function is called by the thread to update the device"""
while not self.__kill_received:
if self.__kill_received:
logging.debug("Thread got killed")
humidity, temperature = Adafruit_DHT.read_retry(Adafruit_DHT.DHT22, 4)
logging.debug("Got temperature reading: "+str(temperature)+" and also got Humidity reading: "+str(humidity))
if self.__temperature != temperature or self.__humidity != humidity:
if self.__humidity != 0 and self.__temperature != -100:
self.__publisher.publish({"temperature":temperature,"humidity":humidity, "switch":self.__lastswitchstate})
self.__humidity = humidity
self.__temperature = temperature
sleep(2)
def next(self):
return str('{"temperature":"%5.2f","humidity":"%5.2f", "switch":"%d"}' % (self.__temperature, self.__humidity, self.__lastswitchstate))
def updateSwitch(self, state):
subprocess.call(["sudo", "/usr/local/bin/send433", "11111", "11", str(state)])
self.__lastswitchstate = state
def signal_handler(self, signal, frame):
self.__kill_received = True
os._exit(1)
def publish_rabbit(self, message):
print "got message to publish %r" % message
pyb = Publisher(queue_name, exchange_name, logger)
inject = pyb.publish(message, routing_key)
print("rabbit mq inject result {0!r}".format(inject))
from Publisher import Publisher
from Subscriber import Subscriber
publisher = Publisher()
subscriber = Subscriber()
subscriber.subscriberName = "Hello World"
publisher.add(subscriber)
publisher.publish("Hello from Publisher")
publisher.filter_publish("Hello World", "Hello From Filter Publisher")
#!/usr/bin/env python
from Publisher import Publisher
CEP_SERVER_ADDRESS = '192.168.122.1' # IP address of the server. You can find it at the end of the CEP console
SSL_PORT = 7711 # Thrift SSL port of the server
TCP_PORT = 7611 # Thrift TCP port of the server
USERNAME = '******' # Username
PASSWORD = '******' # Passowrd
publisher = Publisher(CEP_SERVER_ADDRESS, SSL_PORT, TCP_PORT)
# Connect to server with username and password
publisher.connect(USERNAME, PASSWORD)
# Publish an event to the Temperature stream
publisher.publish('com.javahelps.stream.Temperature:1.0.0', 'Kitchen', 56)
# Disconnect
publisher.disconnect()
