def main(): global EXIT ##join with the tables hour_subscription=Subscriber() hour_subscription.subscribe('/topic/enrich/hour', 'join_hour', Listener(hour_subscription,hourly_action)) day_subscription=Subscriber() day_subscription.subscribe('/topic/report/day', 'join_day', Listener(day_subscription,daily_action)) while not EXIT: pass
def do_subscribe(opts): LOGGER.info('Starting subscriber...') try: dsn = 'dbname={} user={} password={} host={} port={}'.format( opts.db_name, opts.db_user, opts.db_password, opts.db_host, opts.db_port) database = Database(dsn) database.connect() subscriber = Subscriber(opts.connect) subscriber.add_handler(get_events_handler(database)) known_blocks = database.fetch_last_known_blocks(KNOWN_COUNT) known_ids = [block['block_id'] for block in known_blocks] subscriber.start(known_ids=known_ids) except KeyboardInterrupt: sys.exit(0) except Exception as err: # pylint: disable=broad-except LOGGER.exception(err) sys.exit(1) finally: try: database.disconnect() subscriber.stop() except UnboundLocalError: pass LOGGER.info('Subscriber shut down successfully')
def add(self, msisdn, credit): sub = Subscriber() sms = SMS(); try: mysub = sub.get(msisdn) except SubscriberException as e: raise CreditException(e) current_balance = sub.get_balance(msisdn) new_balance = Decimal(str(credit)) + Decimal(str(current_balance)) # update subscriber balance try: cur = db_conn.cursor() cur.execute('UPDATE subscribers SET balance=%(new_balance)s WHERE msisdn=%(msisdn)s', {'new_balance': Decimal(str(new_balance)), 'msisdn': msisdn}) sms.send(config['smsc'], msisdn, sms_credit_added % (credit, new_balance)) except psycopg2.DatabaseError as e: raise CreditException('PG_HLR error updating subscriber balance: %s' % e) # insert transaction into the credit history try: cur = db_conn.cursor() cur.execute('INSERT INTO credit_history(msisdn,previous_balance,current_balance,amount) VALUES(%s,%s,%s,%s)', (msisdn, current_balance, new_balance, credit)) except psycopg2.DatabaseError as e: db_conn.rollback() raise CreditException('PG_HLR error inserting invoice in the history: %s' % e) finally: db_conn.commit()
def app_input(self): from subscriber import Subscriber print("Went in the thread!") project_id = "pub-sub132608" subscriber = "sub_asdfjfdklsjdjdyebv_V-1" sub = Subscriber(project_id, subscriber, "") sub.start_server()
def main(): global EXIT subscription = Subscriber() subscription.subscribe('/queue/analytics/hour', 'report_', Listener(subscription, action)) while not EXIT: pass
def broadcast_to_all_subscribers(self, text, btype, location): sms_log.debug('Broadcast message to [%s], Location:%s' % (btype, location)) if location == "all": location = False sub = Subscriber() try: if btype == 'authorized': subscribers_list = sub.get_all_authorized(location) elif btype == 'unauthorized': subscribers_list = sub.get_all_unauthorized(location) elif btype == 'notpaid': subscribers_list = sub.get_all_notpaid(location) elif btype == 'extension': subscribers_list = sub.get_all_5digits() else: subscribers_list = [] except NoDataException as ex: return False for mysub in subscribers_list: self.send(config['smsc'], mysub[1], text) time.sleep(1) sms_log.debug('Broadcast message sent to [%s] %s' % (btype, mysub[1]))
def get_subscriber(ws): if ws in subscribers: return subscribers.get(ws) else: sub = Subscriber(ws, app=app) subscribers[ws] = sub return sub
def __init__(self, dbinfo=ct.DB_INFO, redis_host=None): self.dbinfo = dbinfo self.logger = getLogger(__name__) self.index_objs = dict() self.stock_objs = dict() self.combination_objs = dict() self.cal_client = CCalendar(dbinfo, redis_host) self.index_info_client = IndexInfo() self.comb_info_client = CombinationInfo(dbinfo, redis_host) self.stock_info_client = CStockInfo(dbinfo, redis_host) self.rindex_stock_data_client = RIndexStock(dbinfo, redis_host) self.industry_info_client = IndustryInfo(dbinfo, redis_host) self.rindustry_info_client = RIndexIndustryInfo(dbinfo, redis_host) self.limit_client = CLimit(dbinfo, redis_host) self.animation_client = CAnimation(dbinfo, redis_host) self.subscriber = Subscriber() self.quote_handler = StockQuoteHandler() self.ticker_handler = TickerHandler() self.connect_client = StockConnect(market_from=ct.SH_MARKET_SYMBOL, market_to=ct.HK_MARKET_SYMBOL, dbinfo=dbinfo, redis_host=redis_host) self.margin_client = Margin(dbinfo=dbinfo, redis_host=redis_host) self.emotion_client = Emotion(dbinfo=dbinfo, redis_host=redis_host) self.sh_exchange_client = StockExchange(ct.SH_MARKET_SYMBOL) self.sz_exchange_client = StockExchange(ct.SZ_MARKET_SYMBOL)
def deactivate_subscriptions(self, msg): try: sms = SMS() sub = Subscriber() cur = db_conn.cursor() cur.execute( 'SELECT msisdn FROM subscribers WHERE subscription_status = 0 AND authorized = 1' ) count = cur.rowcount if count > 0: self.logger.info('Found %d subscribers to be deactivated' % count) subscribers_list = cur.fetchall() db_conn.commit() for mysub in subscribers_list: self.logger.debug( 'Send SMS that account is deactivated to %s' % mysub[0]) sms.send(config['smsc'], mysub[0], msg) # disable subscriber try: sub.authorized(mysub[0], 0) except SubscriberException as e: raise SubscriptionException( 'PG_HLR error in deactivating subscription: %s' % e) else: db_conn.commit() self.logger.info('No subscribers need to be deactivate') except psycopg2.DatabaseError as e: raise SubscriptionException( 'PG_HLR error in checking subscriptions to deactivate: %s' % e)
def add_subscriber(self, name_, topics): j = 0 name_found = False while j < len(self.subscribers): if name_ == self.subscribers.get(j).get_name(): name_found = True break else: j += 1 if not name_found: s = Subscriber(self.sub_id, name_) self.subscribers[s.get_id()] = s self.sub_id += 1 i = 0 while i < len(topics): if topics[i] not in self.topic_manager.topics: self.topic_manager.add_sub( s, self.topic_manager.create_topic(topics[i])) else: self.topic_manager.add_sub( s, self.topic_manager.find_topic(topics[i])) i += 1 return s else: raise Exception( "There is already a subscriber named \'{0}\' registered to topics \'{1}\'!" .format(name_, topics))
def validate_data(self, pin): res_log.debug('Check PIN length') if len(pin) > 4 or len(pin) < 4: raise ResellerException('PIN invalid length') res_log.debug('Check if Reseller exists') # check if reseller exists in the database and the PIN is valid try: cur = db_conn.cursor() cur.execute( 'SELECT msisdn,pin FROM resellers WHERE msisdn=%(msisdn)s', {'msisdn': str(self.reseller_msisdn)}) if cur.rowcount > 0: res_log.debug('Valid Reseller found') res_log.debug('Auth PIN') data = cur.fetchone() if data[1] != pin: raise ResellerException('Invalid PIN!') res_log.debug('Check if subscriber is valid') # check if subscriber exists try: sub = Subscriber() sub.get(self.subscriber_msisdn) except SubscriberException as e: raise ResellerException('Invalid subscriber') else: raise ResellerException('Invalid Reseller') except psycopg2.DatabaseError as e: raise ResellerException( 'Database error getting reseller msisdn: %s' % e)
def generate(self): cl = Sponsor(self.cfg, self.SponserName, self.befinciaryPlanName) allSponsersSubscribersEDIString = '' for i in range(self.generateCount): sponsorEDIString = cl.edi_string() sub = Subscriber(cl, self.ploicyId, self.effectiveDate, self.minAge, self.maxAge) subscriberEDIString = sub.edi_string() dependentStringPresent = False if (self.addSpouse == "Yes"): # Spouse as a dependent dep = Dependent(sub, spouse=True) dependentEDIString = dep.edi_string() dependentStringPresent = True if (self.childrenCount > 0): for i in range(0, self.childrenCount): if sub.age > 23: dep = Dependent(sub) if (dependentStringPresent): dependentEDIString += dep.edi_string() else: dependentEDIString = dep.edi_string() if (self.childrenCount > 0 or self.addSpouse == "Yes"): subscriberEDIString = subscriberEDIString + dependentEDIString sponsorEDIString = sponsorEDIString.replace( '{SUBSCRIBER_DETAILS}', subscriberEDIString) sponsorEDIString = sponsorEDIString.replace( '{SECount}', str(len(sponsorEDIString.split('\n')) - 1)) allSponsersSubscribersEDIString += sponsorEDIString GEEDIstring = self.edi_string.replace('{GECount}', str(self.generateCount)) completeEDIString = GEEDIstring.replace( '{SPONSOR_DETAILS}', allSponsersSubscribersEDIString) self.saveFile(completeEDIString) return None
def main(): global EXIT subscription = Subscriber() subscription.subscribe('/queue/source', 'clean', Listener(subscription, action)) while not EXIT: pass subscription.disconnect()
def handleBilling(self): sb = Subscriber(int(self.txtPhoneNumber.get('1.0', 'end-1c'))) sms = sb.smsBill() originCall = sb.originCallBill() destCall = sb.destCallBill() text = '______Bill______\nSMS: %drub\nOutgoing Call: %drub\nIncoming Call: %drub\nTotal: %drub\n' \ % (sms, originCall, destCall, sms+originCall+destCall) self.showContent('text', text)
def handleGetRecords(self): sb = Subscriber(int(self.txtPhoneNumber.get('1.0', 'end-1c'))) table = [ ['timestamp', 'msisdn_origin', 'msisdn_dest', 'call_duration', 'sms_number'] ] for rc in sb.originRecords + sb.destRecords: table.append(rc.toStringArray()) self.showContent('table', table)
def get_subscriber(): """Returns Subscriber instance connected to kafka consumer.""" return Subscriber( topic=os.environ["TOPIC"], client_id=os.environ["CLIENT_ID"], group_id=os.environ["GROUP_ID"], auto_offset_reset="earliest", **get_kafka_connection_params(), )
def setup_subscriber_requester(context): requester = Requester(context, ip, port) print("Requester ready") requester.send_string('SUB_PORT') sub_port = requester.recv_string() print(sub_port) subscriber = Subscriber(context, ip, sub_port) print("subscriber ready") return requester, subscriber
def main(): broker = Broker() subscriber = Subscriber() subscriber.connect_broker(broker) topics = ["1", "2", "3", "4", '5', '6', '7', '8', '9'] subscriber.subscribe_to_topics(topics)
def onMessage(self, payload, isBinary): # echo back message verbatim message = json.loads(payload.decode('utf-8')) metadata = message.get('metadata') event = metadata.get('event') queue_name = metadata.get('queue_name') if event == "SUBSCRIBE": manager = SubscriptionManagerFactory.get_manager(queue_name) dependencies = metadata.get('dependencies', []) # also ensure all subscribers which this subscriber depends upon # are active subscriber = Subscriber(self, metadata) manager.add_subscription(subscriber) setattr(self, 'subscriber', subscriber) for subscriber_id in dependencies: parent = manager.get_subscriber(subscriber_id) if parent is None: print("WARNING: ", "parent subscriber is not found") continue print("Parent ", parent) parent.add_dependent(subscriber) subscriber.add_parent(parent) manager.status() if event == "PUBLISH": payload = message.get('message') msg_hash = MessageStore.add(payload) handler = MessageBufferHandlerFactory.get_handler( queue_name, self.factory.reactor) response = handler.handle_message(msg_hash) self.sendMessage(response.encode('utf-8')) if event == "REQUEST_MESSAGE": msg_hash = self.subscriber.get_message() message = MessageStore.get(msg_hash) payload = { 'metadata': { 'message_hash': msg_hash, }, 'message_body': message } payload = json.dumps(payload) self.sendMessage(payload.encode('utf-8')) if event == "MESSAGE_PROCESSED_ACK": message_hash = metadata.get('message_hash') print("ACK received for message_hash", message_hash) self.subscriber.notify_dependents(message_hash)
def create_subscribers(num): subscribers = [] for i in range(num): subscriber = Subscriber() subscriber.name = fake.name() subscriber.phone = fake.phone_number() subscriber.email = fake.email() subscriber.address = fake.address() subscribers.append(subscriber) Subscriber.objects.insert(subscribers)
def run(self): syslog.syslog("fail2ban-zmq-tools Subscriber starting") signal.signal(signal.SIGTERM, self.__sigTERMhandler) signal.signal(signal.SIGINT, self.__sigTERMhandler) self.subscriber = Subscriber(subscriberconfig=subscriberconfig) self.subscriber.start() syslog.syslog("fail2ban-zmq-tools Subscriber running.\ Main process waiting for termination signal.\ Threads working.") signal.pause() syslog.syslog("fail2ban-zmq-tools Subscriber exiting.")
def __init__(self, dbinfo): self.combination_objs = dict() self.stock_objs = dict() self.evt = AsyncResult() self.dbinfo = dbinfo self.cal_client = CCalendar(dbinfo) self.comb_info_client = CombinationInfo(dbinfo) self.stock_info_client = CStockInfo(dbinfo) self.delisted_info_client = CDelisted(dbinfo) self.animation_client = CAnimation(dbinfo) self.subscriber = Subscriber()
def subscriber(): URL = request.form['url'] email = request.form['email'] threshold = request.form['price'] product = Subscriber(URL,email,threshold) err = product.subscribe() if err: message = err else: message = "Thanks for subscribing for updates on product on email-ID "+ email return render_template('thanks.html',message=message,url=URL)
def select_all_subscribers(self): query = 'SELECT * FROM `subscriber`;' cursor = self.__connection.cursor() subscribers = list() cursor.execute(query) for id, email, subscribed_date in cursor.fetchall(): subscriber = Subscriber(email, id, subscribed_date) subscribers.append(subscriber) return subscribers
def main(): global EXIT subscription=Subscriber() subscription.subscribe('/queue/source', 'window', Listener(subscription,action)) threads = [] for i in range(4): t = threading.Thread(target=action) threads.append(t) t.start() while not EXIT: pass subscription.disconnect()
def __init__(self, mqueue, identifiers, start_time, end_time, frequency, timezone): PollingThread.__init__(self) self.__queue = mqueue self.__start_time = get_today_time(start_time) self.__end_time = get_today_time(end_time) self.__timezone = timezone self.__frequency = frequency self.__identifiers = identifiers self.__subscriber = Subscriber() self.__next_call_time = localnow(self.__timezone) self.__last_response_time = localnow(self.__timezone)
def test(): from subscriber import Subscriber account = json.load(open("/var/lib/doublefault/account.json")) db = SettingDB(account["db-username"], account["db-password"], table_name="test") db.drop_table() db.create_table() db.put_user_data(Subscriber("user1", address="10.0001,10.0001")) db.put_user_data(Subscriber("user2", address="10.0002,10.0002")) db.put_user_data(Subscriber("user3", address="10.0003,10.0003")) db.put_user_data(Subscriber("user4", address="10.0004,10.0004")) db.put_user_data(Subscriber("user5", address="37 Wellington St., Arlington MA")) subsc = db.find_user("user1") print ("ID: {u.surrogateid} address: {u.address}, coord: {u.coordinates.latitude},{u.coordinates.longitude}".format(u=subsc)) db.put_user_data(Subscriber("user1", address="20.0001,20.0001")) for user in ["user1", "user2", "user3", "user4", "user5", "user6"]: subsc = db.find_user(user) if subsc: print ("ID: {u.surrogateid} address: {u.address}, coord: {u.coordinates.latitude},{u.coordinates.longitude}".format(u=subsc)) pass else: print ("no %s" % user) pass pass pass
def subscription_info(self): sub = Subscriber() unpaid = self.get_unpaid_subscriptions() print '---\n\n' for number in unpaid: print 'PostGres: ' + number[0] + ':' info = sub.print_vty_hlr_info(number) if "No subscriber found for extension" in info: print 'OsmoHLR: ' + info print "Checking for 5 digit extension" info = sub.print_vty_hlr_info(number[0][-5:]) print 'OsmoHLR: ' + info print '---\n\n'
def send_subscription_fee_notice(self, msg): # get all subscribers try: sub = Subscriber() subscribers_list = sub.get_all() except SubscriberException as e: raise SubscriptionException('%s' % e) sms = SMS() for mysub in subscribers_list: self.logger.debug("Send sms to %s %s" % (mysub[1], msg)) sms.send(config['smsc'], mysub[1], msg)
def main(): subscriber = Subscriber(project_id, subscription_name) subscription = subscriber.subscribe() while True: time.sleep(2) subscription.open(callback) logger.info("Open Subscriber") time.sleep(10) subscription.close() logger.info("Close Subscriber")