def send_temperature(temp): today = datetime.datetime.now() now = str(today) sbs = ServiceBusService(service_namespace=sb_namespace, shared_access_key_name=key_name, shared_access_key_value=key_value) print ('sending to Event Hub...@' + now) event_message = '{ "DeviceId": "' + device_id + '", "DeviceName": "' + device_name + '", "Temperature": "' + str(temp) + '", "TimeStamp": "' + now + '" }' print (event_message) sbs.send_event(hub_name, event_message) print ('sent!')
def main(): parser = argparse.ArgumentParser(description='Run automated diagnostics') parser.add_argument('-y', action='store_true', help='Skip prompts') parser.add_argument('--anonymous', action='store_true', help='No telemetry') parser.add_argument('--case', help='Link output with a case, for use with Azure Support') parser.add_argument('--human', action='store_true', help='Write human-readable text to stdout') parser.add_argument('--feedback', action='store_true', help='Provide suggestions and/or feedback') args=parser.parse_args() if(args.feedback): suggestion = raw_input("Suggestion (Press return to submit): ") sbkey = '5QcCwDvDXEcrvJrQs/upAi+amTRMXSlGNtIztknUnAA=' sbs = ServiceBusService('linuxdiagnostics-ns', shared_access_key_name='PublicProducer', shared_access_key_value=sbkey) event = {'event': 'feedback', 'feedback': suggestion} sbs.send_event('linuxdiagnostics',json.dumps(event)) exit() if(args.anonymous): if(args.case == True): print "Cannot report case diagnostics in anonymous mode." else: Diagnostics(False,args.case).print_report(args.human) else: if(args.y): Diagnostics(True,args.case).print_report(args.human) else: prompt="In order to streamline support and drive continuous improvement, this script may transmit system data to Microsoft.\n Do you consent to this? (y/n):" consent=raw_input(prompt) if(consent=='y' or consent=='Y'): Diagnostics(True,args.case).print_report(args.human) else: print("To run without telemetry, use the --anonymous flag")
def main(): sbs = ServiceBusService( service_namespace='holEvents', shared_access_key_name='RootManageSharedAccessKey', shared_access_key_value='ugV/8wxg/Z0ZoTWBZWRUP5j2cgaEDiJC26ZLuoshotY=') turn = 0 while turn >= 0: t = rd(19.6, 67.6) ap = rd(1002.6, 101.1) rh = rd(54, 13.6) v = rd(83.5, 99.1) pe = rd(445.6, 61.1) now = datetime.now().strftime("%M") if turn == 0: time = now else: if now != time: data = { "T": str(t), "V": str(v), "AP": str(ap), "RH": str(rh), "PE": str(pe) } body = str.encode(json.dumps(data)) print(body) sbs.send_event('datatostream', body) time = now turn += 1
class Diagnostics: def __init__(self,telemetry,case): self.sbkey = '5QcCwDvDXEcrvJrQs/upAi+amTRMXSlGNtIztknUnAA=' self.sbs = ServiceBusService('linuxdiagnostics-ns', shared_access_key_name='PublicProducer', shared_access_key_value=self.sbkey) self.telemetry = telemetry self.case = case self.report = dict() self.data = dict() try: self.data['fstab'] = fstab() self.data['vmstat'] = vmstat() self.data['diskstats'] = diskstats() self.data['meminfo'] = meminfo() self.data['loadavg'] = loadavg() self.data['proc.sys.fs'] = procsysfs() self.data['inodes_by_mount'] = inodes_by_mp() self.data['waagent'] = waagent() self.check_fstab_uuid() self.check_resourcedisk_inodes() self.success_telemetry() except: self.error_telemetry(str(sys.last_value)) exit() def print_report(self,human): if(human): for item in map(lambda x: human_readable(self.report[x]),self.report): print item else: print json.dumps(self.report) # == Telemetry == def success_telemetry(self): if(self.telemetry): event = {'event': 'success', 'report': self.report, 'data': self.data} if(self.case): event['case'] = self.case self.sbs.send_event('linuxdiagnostics',json.dumps(event)) def error_telemetry(self,e): if(self.telemetry): event = {'event': 'error', 'error': e, 'report': self.report, 'data':self.data} if(self.case): event['case'] = self.case sbs.send_event('linuxdiagnostics',json.dumps(event)) # == Diagnostics == def check_fstab_uuid(self): uuids = map (lambda r:bool(re.match('UUID',r['fs_spec'],re.I)), self.data['fstab']) uuids = filter(lambda x: not x, uuids) if(len(uuids) > 0): self.report['linux.uuid']= report("fstab doesn't use UUIDs", 'red', 'best_practices', "/etc/fstab isn't using UUIDs to reference its volumes.", '') def check_resourcedisk_inodes(self): mountpoint = self.data['waagent']['ResourceDisk.MountPoint'] x=filter(lambda x: x['mountpoint']==mountpoint ,self.data['inodes_by_mount'])[0] if(x['inodes_used'] > 20): self.report['azure.resource_disk_usage'] = report('Resource Disk Usage', 'yellow', 'data_loss',"This instance appears to be using the resource disk. Data stored on this mountpoint may be lost.", '')
class EventHubSender(BaseSender): def __init__(self, *args, **kwargs): super().__init__(*args, **kwargs) self._sender = ServiceBusService(self._config.service_namespace, shared_access_key_name=self._config.key_name, shared_access_key_value=self._config.key_value) def send(self, label, data): assert isinstance(label, str), 'label must be a string' self._sender.send_event(label, data)
def send_msg_bus(namespace, hub, user, password): from azure.servicebus import ServiceBusService, Message, Queue from datetime import datetime import subprocess bus_service = ServiceBusService(service_namespace=namespace, shared_access_key_name=user, shared_access_key_value=password) message = subprocess.getoutput('az resource list -o json') # message = 'mon script,"{}"' bus_service.send_event(hub, message)
def send_temperature(temp): today = datetime.datetime.now() now = str(today) sbs = ServiceBusService(service_namespace=sb_namespace, shared_access_key_name=key_name, shared_access_key_value=key_value) print('sending to Event Hub...@' + now) event_message = '{ "DeviceId": "' + device_id + '", "DeviceName": "' + device_name + '", "Temperature": "' + str( temp) + '", "TimeStamp": "' + now + '" }' print(event_message) sbs.send_event(hub_name, event_message) print('sent!')
def on_data(self, data): # Twitter returns data in JSON format - we need to decode it first decoded = json.loads(data) # # Also, we convert UTF-8 to ASCII ignoring all bad characters sent by users # print '@%s: %s' % (decoded['user']['screen_name'], decoded['text'].encode('ascii', 'ignore')) # print '' # return True sbs = ServiceBusService(service_namespace=config.servns, shared_access_key_name=config.key_name, shared_access_key_value=config.key_value) searched_tweets = "{ 'source': '" + unicode(decoded['user']['screen_name']) + "' , 'text': '" + unicode(decoded['text'].encode('ascii', 'ignore')) + "' }" print(unicode(searched_tweets)) sbs.send_event('iot', unicode(searched_tweets)) return True
def main(): appkey = "24000e5c1b5338a94f68ce841d975f8a" # juhe-api # Azure service sbs = ServiceBusService( service_namespace='brucewaynetolltooth', shared_access_key_name='RootManageSharedAccessKey', shared_access_key_value='m6mWS29LUMIh2ZH9gh4KjmoNPiXBxeMCaq6eMxojBDc=') while True: print("Query starts...") page_quantity_query = 10 # 请求页数 for page in range(1, page_quantity_query): api_result = request4(appkey, "GET", page) # 香港股市列表 s = json.dumps(api_result) sbs.send_event('entrysignals', s) time.sleep(60) # 1000次每日限额,每1分钟请求10次,100分钟用完
class listener(StreamListener): whitespace_regex = re.compile('\s+') connection_string_regex = re.compile( '^Endpoint=sb://(.+).servicebus.windows.net/;SharedAccessKeyName=(.+);SharedAccessKey=(.+);EntityPath=(.+)$' ) def __init__(self, event_hub_connection_string, keywords): m = self.connection_string_regex.match(event_hub_connection_string) self.sbs = ServiceBusService(m.group(1), shared_access_key_name=m.group(2), shared_access_key_value=m.group(3)) self.keywords = keywords self.event_hub_name = m.group(4) def on_data(self, data): try: tweet = json.loads(data) p = re.compile('\s+') text = tweet['text'] for topic in self.get_topics(text, keywords): output = json.dumps({ 'text': text, 'timestamp_ms': tweet['timestamp_ms'], 'topic': topic, 'id': tweet['id'], 'retweet_count': tweet['retweet_count'], 'time_zone': tweet['user']['time_zone'], 'lang': tweet['user']['lang'] }) self.sbs.send_event(self.event_hub_name, output) return True except BaseException as e: print('failed ondata' + str(e)) time.sleep(5) def on_error(self, status): print(status) def get_topics(self, input, keywords): return [ keyword for keyword in self.keywords if self.sanitize_text(keyword) in self.sanitize_text(input) ] def sanitize_text(self, input): return self.whitespace_regex.sub(' ', input.strip().lower())
def on_success(self, data): sbs = ServiceBusService( config.a_event_hub_namespace, shared_access_key_name=config.a_shared_access_key_name, shared_access_key_value=config.a_shared_access_key_value) D = {} if 'text' in data: D["timestamp"] = data['timestamp_ms'] D["tweet_id"] = data['id_str'] D["user_id"] = data['user']['id_str'] D["screen_name"] = data['user']['screen_name'] if data['truncated'] is True: D["tweet"] = re.sub("'", "|", data['extended_tweet']['full_text']) else: D["tweet"] = re.sub("'", "|", data['text']) D["retweeted_id"] = '' D["retweeted_user_id"] = '' D["retweet"] = 0 if 'retweeted_status' in data: D["retweeted_id"] = data['retweeted_status']['id_str'] D["retweeted_user_id"] = data['retweeted_status']['user'][ 'id_str'] D["retweet"] = 1 list = '' for lists in data['entities']['hashtags']: list = list + lists['text'] + ' ' D["hashtags"] = list print(data['timestamp_ms']) sbs.send_event("twitterstreamin", json.dumps(D, ensure_ascii=False).encode('utf8')) else: for key, value in data.items(): print(key, ' : ', value) return True
def main(): parser = argparse.ArgumentParser(description='Run automated diagnostics') parser.add_argument('-y', action='store_true', help='Skip prompts') parser.add_argument('--anonymous', action='store_true', help='No telemetry') parser.add_argument( '--case', help='Link output with a case, for use with Azure Support') parser.add_argument('--human', action='store_true', help='Write human-readable text to stdout') parser.add_argument('--feedback', action='store_true', help='Provide suggestions and/or feedback') args = parser.parse_args() if (args.feedback): suggestion = raw_input("Suggestion (Press return to submit): ") sbkey = '5QcCwDvDXEcrvJrQs/upAi+amTRMXSlGNtIztknUnAA=' sbs = ServiceBusService('linuxdiagnostics-ns', shared_access_key_name='PublicProducer', shared_access_key_value=sbkey) event = {'event': 'feedback', 'feedback': suggestion} sbs.send_event('linuxdiagnostics', json.dumps(event)) exit() if (args.anonymous): if (args.case == True): print "Cannot report case diagnostics in anonymous mode." else: Diagnostics(False, args.case).print_report(args.human) else: if (args.y): Diagnostics(True, args.case).print_report(args.human) else: prompt = "In order to streamline support and drive continuous improvement, this script may transmit system data to Microsoft.\n Do you consent to this? (y/n):" consent = raw_input(prompt) if (consent == 'y' or consent == 'Y'): Diagnostics(True, args.case).print_report(args.human) else: print("To run without telemetry, use the --anonymous flag")
def on_data(self, data): # Twitter returns data in JSON format - we need to decode it first decoded = json.loads(data) # # Also, we convert UTF-8 to ASCII ignoring all bad characters sent by users # print '@%s: %s' % (decoded['user']['screen_name'], decoded['text'].encode('ascii', 'ignore')) # print '' # return True sbs = ServiceBusService(service_namespace=config.servns, shared_access_key_name=config.key_name, shared_access_key_value=config.key_value) searched_tweets = "{ 'source': '" + unicode( decoded['user']['screen_name']) + "' , 'text': '" + unicode( decoded['text'].encode('ascii', 'ignore')) + "' }" print(unicode(searched_tweets)) sbs.send_event('iot', unicode(searched_tweets)) return True
class azure_interface: def __init__(self, name_space, key_name, key_value, proxy = None): self.sbs = ServiceBusService(service_namespace=name_space,shared_access_key_name=key_name, shared_access_key_value=key_value) if proxy: self.sbs.set_proxy('proxy.iisc.ernet.in',3128) def event_send(self, hubname ,msg): try: hubStatus = self.sbs.send_event(hubname, str(msg)) print "Send Status:", repr(hubStatus) except: print sys.exc_info()
def insert_mock_logs_in_EventHub(self): print("Inserting fake logs in EventHub") namespace_name = self.get_eventhub_namespace() eventhub_name = 'insights-metrics-pt1m' defaultauthorule_name = "RootManageSharedAccessKey" eventhub_client = EventHubManagementClient(self.credentials, self.subscription_id) ehkeys = eventhub_client.namespaces.list_keys(self.RESOURCE_GROUP_NAME, namespace_name, defaultauthorule_name) sbs = ServiceBusService(namespace_name, shared_access_key_name=defaultauthorule_name, shared_access_key_value=ehkeys.primary_key, request_session=Session()) mock_logs = json.load(open('metrics_fixtures.json')) print("inserting %s" % (mock_logs)) sbs.send_event(eventhub_name, json.dumps(mock_logs)) print("Event inserted")
def insert_mock_logs_in_EventHub(self, filename): print("Inserting fake logs in EventHub") namespace_name = self.get_resource_name( self.event_hub_namespace_prefix, "Microsoft.EventHub/namespaces") defaultauthorule_name = "RootManageSharedAccessKey" eventhub_client = EventHubManagementClient(self.credentials, self.subscription_id) ehkeys = eventhub_client.namespaces.list_keys(self.RESOURCE_GROUP_NAME, namespace_name, defaultauthorule_name) sbs = ServiceBusService(namespace_name, shared_access_key_name=defaultauthorule_name, shared_access_key_value=ehkeys.primary_key, request_session=Session()) mock_logs = json.load(open(filename)) print("inserting %s" % (mock_logs)) sbs.send_event(self.eventhub_name, json.dumps(mock_logs)) print("Event inserted")
class EventHubWriter(GenericWriter): """ EventHubWriter sends all the events to Microsoft Azure Event Hub Service. """ def __init__(self, eh_name, connection_string, format=None): from azure.servicebus import ServiceBusService """ eh_name - Event Hub service name connection_string - Event Hub namespace connection string """ conn_dict = { i.split('=', 1)[0]: i.split('=', 1)[1] for i in connection_string.split(';') } ns_name = conn_dict['Endpoint'].replace('sb://', '').replace( '.servicebus.windows.net/', '') self.__sbs__ = ServiceBusService( service_namespace=ns_name, shared_access_key_name=conn_dict['SharedAccessKeyName'], shared_access_key_value=conn_dict['SharedAccessKey']) self.__ehname__ = eh_name super(EventHubWriter, self).__init__(format=format) def send(self, event): #converting datetime timestamp to ISO 8601 format event['TimeStamp'] = event['TimeStamp'].isoformat() + "Z" try: self.__sbs__.send_event(self.__ehname__, self.Format.format(event)) except: #adding small delay in case the there is temporary connection issue with Event Hub time.sleep(1) try: self.__sbs__.send_event(self.__ehname__, self.Format.format(event)) except: raise IOError("Cannot send message to Event Hub service")
if args.keyname is not None: ehSharedAccessKeyName = args.keyname #RootManageSharedAccessKey else: ehSharedAccessKeyName = os.environ['EH_SHARED_ACCESS_KEY_NAME'] if args.keyvalue is not None: ehSharedAccessKeyValue = args.keyvalue #IdKZBJi4NXFkyCkPm2X2U3t6zJOPivMAm7WuQJCVGUw= else: ehSharedAccessKeyValue = os.environ['EH_SHARED_ACCESS_KEY_VALUE'] sbs = ServiceBusService(service_namespace=ehNamespace, shared_access_key_name=ehSharedAccessKeyName, shared_access_key_value=ehSharedAccessKeyValue) while (1 > -1): devices = [] for x in range(0, 10): devices.append(str(uuid.uuid4())) for y in range(0, 20): #while (1>-1): for dev in devices: reading = { 'id': str(uuid.uuid4()), 'timestamp': str(datetime.datetime.utcnow()), 'uv': random.random(), 'temperature': random.randint(70, 100), 'humidity': random.randint(70, 100) } s = json.dumps(reading) sbs.send_event(ehName, s) # print y
#Parameter aus dem uebergebenen Query lesen. Vorher pruefen, ob einer uebergeben wurde if (len(sys.argv) > 1): print(sys.argv[1]) tmpstring1 = sys.argv[1] tmpstring1 = tmpstring1.replace("OK", "") tmpstring = {} tmplist = tmpstring1.split("&") for part in tmplist: parts = part.split("=") tmpstring[parts[0]] = parts[1] tmpjson = json.dumps(tmpstring) print(tmpjson) else: print('no arguments') sys.exit(0) key_name = "Sender" key_value = "kzfwcTmKws8qtAF1O8+XCzWb8E983mjyOw4v77W2QQc=" sbs = ServiceBusService("carObdHub", shared_access_key_name=key_name, shared_access_key_value=key_value) while (True): print('sending...') sbs.send_event('myObdHub', tmpjson) print('sent!') sys.exit(0)
class ServiceBusEventHubTest(ServiceBusTestCase): def setUp(self): super(ServiceBusEventHubTest, self).setUp() self.sbs = ServiceBusService( self.settings.EVENTHUB_NAME, shared_access_key_name=self.settings.EVENTHUB_SAS_KEY_NAME, shared_access_key_value=self.settings.EVENTHUB_SAS_KEY_VALUE, request_session=Session(), ) self._set_service_options(self.sbs, self.settings) self.event_hub_name = self.get_resource_name('uthub') def tearDown(self): if not self.is_playback(): try: self.sbs.delete_event_hub(self.event_hub_name) except: pass return super(ServiceBusEventHubTest, self).tearDown() #--Helpers----------------------------------------------------------------- def _create_event_hub(self, hub_name): self.sbs.create_event_hub(hub_name, None, True) #--Test cases for event hubs ---------------------------------------------- @record def test_create_event_hub_no_options(self): # Arrange # Act created = self.sbs.create_event_hub(self.event_hub_name) # Assert self.assertTrue(created) @record def test_create_event_hub_no_options_fail_on_exist(self): # Arrange # Act created = self.sbs.create_event_hub(self.event_hub_name, None, True) # Assert self.assertTrue(created) @record def test_create_event_hub_with_options(self): # Arrange # Act hub = EventHub() hub.message_retention_in_days = 5 hub.status = 'Active' hub.user_metadata = 'hello world' hub.partition_count = 32 created = self.sbs.create_event_hub(self.event_hub_name, hub) # Assert self.assertTrue(created) created_hub = self.sbs.get_event_hub(self.event_hub_name) self.assertEqual(created_hub.name, self.event_hub_name) self.assertEqual(created_hub.message_retention_in_days, hub.message_retention_in_days) self.assertEqual(created_hub.status, hub.status) self.assertEqual(created_hub.partition_count, hub.partition_count) self.assertEqual(created_hub.user_metadata, hub.user_metadata) self.assertEqual(len(created_hub.partition_ids), hub.partition_count) @record def test_create_event_hub_with_authorization(self): # Arrange # Act hub = EventHub() hub.authorization_rules.append( AuthorizationRule( claim_type='SharedAccessKey', claim_value='None', rights=['Manage', 'Send', 'Listen'], key_name='Key1', primary_key='Wli4rewPGuEsLam95nQEwGR+e8b+ynlupZQ7VfjbQnw=', secondary_key='jS+lERPBmbBVGJ5JzIwVRtSGYoFUeunRoADNTjwU3jU=', ) ) created = self.sbs.create_event_hub(self.event_hub_name, hub) # Assert self.assertTrue(created) created_hub = self.sbs.get_event_hub(self.event_hub_name) self.assertEqual(created_hub.name, self.event_hub_name) self.assertEqual(len(created_hub.authorization_rules), 1) self.assertEqual(created_hub.authorization_rules[0].claim_type, hub.authorization_rules[0].claim_type) self.assertEqual(created_hub.authorization_rules[0].claim_value, hub.authorization_rules[0].claim_value) self.assertEqual(created_hub.authorization_rules[0].key_name, hub.authorization_rules[0].key_name) self.assertEqual(created_hub.authorization_rules[0].primary_key, hub.authorization_rules[0].primary_key) self.assertEqual(created_hub.authorization_rules[0].secondary_key, hub.authorization_rules[0].secondary_key) @record def test_update_event_hub(self): # Arrange self._create_event_hub(self.event_hub_name) # Act hub = EventHub(message_retention_in_days=3) result = self.sbs.update_event_hub(self.event_hub_name, hub) # Assert self.assertIsNotNone(result) self.assertEqual(result.name, self.event_hub_name) self.assertEqual(result.message_retention_in_days, hub.message_retention_in_days) @record def test_update_event_hub_with_authorization(self): # Arrange self._create_event_hub(self.event_hub_name) # Act hub = EventHub() hub.authorization_rules.append( AuthorizationRule( claim_type='SharedAccessKey', claim_value='None', rights=['Manage', 'Send', 'Listen'], key_name='Key1', primary_key='Wli4rewPGuEsLam95nQEwGR+e8b+ynlupZQ7VfjbQnw=', secondary_key='jS+lERPBmbBVGJ5JzIwVRtSGYoFUeunRoADNTjwU3jU=', ) ) result = self.sbs.update_event_hub(self.event_hub_name, hub) # Assert self.assertIsNotNone(result) self.assertEqual(result.name, self.event_hub_name) self.assertEqual(len(result.authorization_rules), 1) self.assertEqual(result.authorization_rules[0].claim_type, hub.authorization_rules[0].claim_type) self.assertEqual(result.authorization_rules[0].claim_value, hub.authorization_rules[0].claim_value) self.assertEqual(result.authorization_rules[0].key_name, hub.authorization_rules[0].key_name) self.assertEqual(result.authorization_rules[0].primary_key, hub.authorization_rules[0].primary_key) self.assertEqual(result.authorization_rules[0].secondary_key, hub.authorization_rules[0].secondary_key) @record def test_get_event_hub_with_existing_event_hub(self): # Arrange self._create_event_hub(self.event_hub_name) # Act event_hub = self.sbs.get_event_hub(self.event_hub_name) # Assert self.assertIsNotNone(event_hub) self.assertEqual(event_hub.name, self.event_hub_name) @record def test_get_event_hub_with_non_existing_event_hub(self): # Arrange # Act with self.assertRaises(AzureServiceBusResourceNotFound): resp = self.sbs.get_event_hub(self.event_hub_name) # Assert @record def test_delete_event_hub_with_existing_event_hub(self): # Arrange self._create_event_hub(self.event_hub_name) # Act deleted = self.sbs.delete_event_hub(self.event_hub_name) # Assert self.assertTrue(deleted) @record def test_delete_event_hub_with_existing_event_hub_fail_not_exist(self): # Arrange self._create_event_hub(self.event_hub_name) # Act deleted = self.sbs.delete_event_hub(self.event_hub_name, True) # Assert self.assertTrue(deleted) @record def test_delete_event_hub_with_non_existing_event_hub(self): # Arrange # Act deleted = self.sbs.delete_event_hub(self.event_hub_name) # Assert self.assertFalse(deleted) @record def test_delete_event_hub_with_non_existing_event_hub_fail_not_exist(self): # Arrange # Act with self.assertRaises(AzureMissingResourceHttpError): self.sbs.delete_event_hub(self.event_hub_name, True) # Assert @record def test_send_event(self): # Arrange self._create_event_hub(self.event_hub_name) # Act result = self.sbs.send_event(self.event_hub_name, 'hello world') result = self.sbs.send_event(self.event_hub_name, 'wake up world') result = self.sbs.send_event(self.event_hub_name, 'goodbye!') # Assert self.assertIsNone(result)
from httplib import HTTPConnection from azure.servicebus import ServiceBusService MCAST_GRP = '224.0.0.251' MCAST_PORT = 6000 sock = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP) sock.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1) # bind this to the master node's IP address sock.setsockopt(SOL_IP, IP_ADD_MEMBERSHIP, inet_aton(MCAST_GRP)+inet_aton('10.0.0.1')) sock.bind((MCAST_GRP, MCAST_PORT)) mreq = pack("4sl", inet_aton(MCAST_GRP), INADDR_ANY) sock.setsockopt(IPPROTO_IP, IP_ADD_MEMBERSHIP, mreq) sbs = ServiceBusService(service_namespace='knockknockknock', shared_access_key_name='RootManageSharedAccessKey', shared_access_key_value=environ['ACCESS_KEY]') sbs.create_event_hub('penny') while True: data, srv_sock = sock.recvfrom(8192) srv_addr, srv_srcport = srv_sock[0], srv_sock[1] data = loads(data.replace('\0','')) data['srv_addr'] = srv_addr print data sbs.send_event('penny', unicode(dumps(data)))
channel_list = [11, 12, 13, 15, 16, 18, 22, 29, 31, 33] gpio.setup(channel_list, gpio.IN) key_name = "SendRule" key_value = "YEsTSbHUumqNJfnAr2O6Si0h/DIlblKpvJl3HJHFhiU=" sbs = ServiceBusService("smartwatering-ns", shared_access_key_name=key_name, shared_access_key_value=key_value) event = {} event['device_id'] = 1 event['value'] = 0 while (True): j = '0' j = j + str(gpio.input(11)) j = j + str(gpio.input(12)) j = j + str(gpio.input(13)) j = j + str(gpio.input(15)) j = j + str(gpio.input(16)) j = j + str(gpio.input(18)) j = j + str(gpio.input(22)) j = j + str(gpio.input(29)) j = j + str(gpio.input(31)) j = j + str(gpio.input(33)) value = int(j, 2) print(value) event['value'] = value sbs.send_event('smartwatering', json.dump(event))
from azure.servicebus import ServiceBusService import psutil key_name = '<access_key_name>' # SharedAccessKeyName from Azure portal key_value = '<access_key_value>' # SharedAccessKey from Azure portal sb_namespace = '<namespace_name>' sbs = ServiceBusService(service_namespace = sb_namespace, shared_access_key_name=key_name, shared_access_key_value=key_value) # sbs.create_event_hub('openalt') count = 0; while True: sbs.send_event('<eventhub_name>', '{ "MachineName":"Python-01", "CpuUsage":"'+str(psutil.cpu_percent())+'", "FreeMem":"" }') print(count) print('CpuUsage: '+str(psutil.cpu_percent())) count = count + 1
[13, "Litter Box", "Pets", 30.00], [14, "Cough Syrup", "Medicine", 15.00]] # -------------------------------------------------------- # -------------------------------------------------------- keepRunning = True # This will run for about 2.5 hours which should be fine for labs and demos for y in range(0, 2000): # Get a product from the products variable product = products[random.randint(0, 10)] # define a reading as a python dictionary object reading = { 'storeId': storeids[random.randint(0, 10)], 'timestamp': time.time(), 'producttype': product[0], 'name': product[1], 'category': product[2], 'price': product[3], 'quantity': random.randint(1, 3) } # Add some intrigue... if product[1] == "Cough Syrup": reading['quantity'] += 10 # use json.dumps to convert the dictionary to a JSON format s = json.dumps(reading) # send to Azure Event Hub sbs.send_event("ingestion", s) print(s) # wait 5 seconds time.sleep(5)
import time import sys from azure.servicebus import ServiceBusService import json ## Event hub ## NamespaceName = "<add namespace name here>" ## Namespace is called "Endpoint" in Azure connection string. ## ## From Namespace ignore "sb://" and "servicebus.windows.net/" ## ## Policy ## ## To the Event Hub create a new policy and use these keys for connection ## SharedAccessKeyName="<add event hub policy name here>" SharedAccessKey="<add policy key here>" EntityPath="<add event hub name here>" # This is same as EventHub name with lower case letters ## Create service bus connection ## sbs = ServiceBusService(NamespaceName,shared_access_key_name=SharedAccessKeyName, shared_access_key_value=SharedAccessKey) ## Test with sending some JSON data ## print "Press Ctrl-C to quit." i=1000 while(True): i += 1 temp = {'DeviceId': "RaspberryPi", 'Temperature': float(i)} print temp sbs.send_event(EntityPath, json.dumps(temp)) time.sleep(3)
pm10=sum(PM10) / float(len(PM10)) NO2 = [] CO =[] O3 =[] SO2 =[] PM1=[] PM2=[] PM10=[] message={"DeviceId":boardNo,"TIME":str(Time),"O3":str(o3),"SO2":str(so2),"NO2":str(no2),"CO":str(co), "PM10":str(pm10),"PM1":str(pm1),"PM2.5":str(pm2),"LAT":str(Lat),"LONG":str(Lon), 'TEMP':str(Temp),'HUMID':str(Humidity),'SPEED':str(Speed),'CLIMB':str(Climb), 'HEAD':Head,'EPS':EPS, 'EPX':EPX,'EPV':EPV,'EPT':EPT,'ALT':Alt, 'BATV':BATV, 'BATI':BATI, 'BATP':BATP, 'SOLV':SOLV, 'SOLI':SOLI, 'SOLP':SOLP} print('Sending...') try: sbs.send_event('daqs',json.dumps(message)) print('Sent!') count+=1 print 'Packets sent since start:', count print'Operating at',Temp, 'degrees celsius.' print 'Location:', 'Lat', Lat, 'Lon', Lon, 'Alt', Alt print 'Battery Info:', BATV, 'V', BATI, 'A', BATP, 'W' print 'Solar Panel Info:', SOLV, 'V', SOLI, 'A', SOLP, 'W' except IOError or ConnectionError: firstCycle=False print ('ERROR. Did not send.') except (KeyboardInterrupt, SystemExit): #End program when you press ctrl+c print ("\nEnding Thread...") gpsp.running = False alphasense.off()
class EventHubServiceTest(AzureTestCase): def setUp(self): self.sbs = ServiceBusService( credentials.getEventHubNamespace(), shared_access_key_name=credentials.getEventHubSasKeyName(), shared_access_key_value=credentials.getEventHubSasKeyValue(), ) set_service_options(self.sbs) self.event_hub_name = getUniqueName('uthub') def tearDown(self): self.cleanup() return super(EventHubServiceTest, self).tearDown() def cleanup(self): try: self.sbs.delete_event_hub(self.event_hub_name) except: pass #--Helpers----------------------------------------------------------------- def _create_event_hub(self, hub_name): self.sbs.create_event_hub(hub_name, None, True) #--Test cases for event hubs ---------------------------------------------- def test_create_event_hub_no_options(self): # Arrange # Act created = self.sbs.create_event_hub(self.event_hub_name) # Assert self.assertTrue(created) def test_create_event_hub_no_options_fail_on_exist(self): # Arrange # Act created = self.sbs.create_event_hub(self.event_hub_name, None, True) # Assert self.assertTrue(created) def test_create_event_hub_with_options(self): # Arrange # Act hub = EventHub() hub.message_retention_in_days = 5 hub.status = 'Active' hub.user_metadata = 'hello world' hub.partition_count = 32 created = self.sbs.create_event_hub(self.event_hub_name, hub) # Assert self.assertTrue(created) created_hub = self.sbs.get_event_hub(self.event_hub_name) self.assertEqual(created_hub.name, self.event_hub_name) self.assertEqual(created_hub.message_retention_in_days, hub.message_retention_in_days) self.assertEqual(created_hub.status, hub.status) self.assertEqual(created_hub.partition_count, hub.partition_count) self.assertEqual(created_hub.user_metadata, hub.user_metadata) self.assertEqual(len(created_hub.partition_ids), hub.partition_count) def test_create_event_hub_with_authorization(self): # Arrange # Act hub = EventHub() hub.authorization_rules.append( AuthorizationRule( claim_type='SharedAccessKey', claim_value='None', rights=['Manage', 'Send', 'Listen'], key_name='Key1', primary_key='Wli4rewPGuEsLam95nQEwGR+e8b+ynlupZQ7VfjbQnw=', secondary_key='jS+lERPBmbBVGJ5JzIwVRtSGYoFUeunRoADNTjwU3jU=', ) ) created = self.sbs.create_event_hub(self.event_hub_name, hub) # Assert self.assertTrue(created) created_hub = self.sbs.get_event_hub(self.event_hub_name) self.assertEqual(created_hub.name, self.event_hub_name) self.assertEqual(len(created_hub.authorization_rules), 1) self.assertEqual(created_hub.authorization_rules[0].claim_type, hub.authorization_rules[0].claim_type) self.assertEqual(created_hub.authorization_rules[0].claim_value, hub.authorization_rules[0].claim_value) self.assertEqual(created_hub.authorization_rules[0].key_name, hub.authorization_rules[0].key_name) self.assertEqual(created_hub.authorization_rules[0].primary_key, hub.authorization_rules[0].primary_key) self.assertEqual(created_hub.authorization_rules[0].secondary_key, hub.authorization_rules[0].secondary_key) def test_update_event_hub(self): # Arrange self._create_event_hub(self.event_hub_name) # Act hub = EventHub(message_retention_in_days=3) result = self.sbs.update_event_hub(self.event_hub_name, hub) # Assert self.assertIsNotNone(result) self.assertEqual(result.name, self.event_hub_name) self.assertEqual(result.message_retention_in_days, hub.message_retention_in_days) def test_update_event_hub_with_authorization(self): # Arrange self._create_event_hub(self.event_hub_name) # Act hub = EventHub() hub.authorization_rules.append( AuthorizationRule( claim_type='SharedAccessKey', claim_value='None', rights=['Manage', 'Send', 'Listen'], key_name='Key1', primary_key='Wli4rewPGuEsLam95nQEwGR+e8b+ynlupZQ7VfjbQnw=', secondary_key='jS+lERPBmbBVGJ5JzIwVRtSGYoFUeunRoADNTjwU3jU=', ) ) result = self.sbs.update_event_hub(self.event_hub_name, hub) # Assert self.assertIsNotNone(result) self.assertEqual(result.name, self.event_hub_name) self.assertEqual(len(result.authorization_rules), 1) self.assertEqual(result.authorization_rules[0].claim_type, hub.authorization_rules[0].claim_type) self.assertEqual(result.authorization_rules[0].claim_value, hub.authorization_rules[0].claim_value) self.assertEqual(result.authorization_rules[0].key_name, hub.authorization_rules[0].key_name) self.assertEqual(result.authorization_rules[0].primary_key, hub.authorization_rules[0].primary_key) self.assertEqual(result.authorization_rules[0].secondary_key, hub.authorization_rules[0].secondary_key) def test_get_event_hub_with_existing_event_hub(self): # Arrange self._create_event_hub(self.event_hub_name) # Act event_hub = self.sbs.get_event_hub(self.event_hub_name) # Assert self.assertIsNotNone(event_hub) self.assertEqual(event_hub.name, self.event_hub_name) def test_get_event_hub_with_non_existing_event_hub(self): # Arrange # Act with self.assertRaises(WindowsAzureError): resp = self.sbs.get_event_hub(self.event_hub_name) # Assert def test_delete_event_hub_with_existing_event_hub(self): # Arrange self._create_event_hub(self.event_hub_name) # Act deleted = self.sbs.delete_event_hub(self.event_hub_name) # Assert self.assertTrue(deleted) def test_delete_event_hub_with_existing_event_hub_fail_not_exist(self): # Arrange self._create_event_hub(self.event_hub_name) # Act deleted = self.sbs.delete_event_hub(self.event_hub_name, True) # Assert self.assertTrue(deleted) def test_delete_event_hub_with_non_existing_event_hub(self): # Arrange # Act deleted = self.sbs.delete_event_hub(self.event_hub_name) # Assert self.assertFalse(deleted) def test_delete_event_hub_with_non_existing_event_hub_fail_not_exist(self): # Arrange # Act with self.assertRaises(WindowsAzureError): self.sbs.delete_event_hub(self.event_hub_name, True) # Assert def test_send_event(self): # Arrange self._create_event_hub(self.event_hub_name) # Act result = self.sbs.send_event(self.event_hub_name, 'hello world') result = self.sbs.send_event(self.event_hub_name, 'wake up world') result = self.sbs.send_event(self.event_hub_name, 'goodbye!') # Assert self.assertIsNone(result)
gpio.setmode(gpio.BOARD) channel_list=[11,12,13,15,16,18,22,29,31,33] gpio.setup(channel_list,gpio.IN) key_name = "SendRule" key_value = "YEsTSbHUumqNJfnAr2O6Si0h/DIlblKpvJl3HJHFhiU=" sbs = ServiceBusService("smartwatering-ns",shared_access_key_name=key_name,shared_access_key_value=key_value) event={} event['device_id']=1 event['value']=0 while (True): j='0' j=j+str(gpio.input(11)) j=j+str(gpio.input(12)) j=j+str(gpio.input(13)) j=j+str(gpio.input(15)) j=j+str(gpio.input(16)) j=j+str(gpio.input(18)) j=j+str(gpio.input(22)) j=j+str(gpio.input(29)) j=j+str(gpio.input(31)) j=j+str(gpio.input(33)) value=int(j,2) print(value) event['value']=value sbs.send_event('smartwatering',json.dump(event))
# -*- coding: utf-8 -*- # # install pre-requisite package # pip install azure-servicebus # import json from azure.servicebus import ServiceBusService eventhub_namespace="<Eventhub Top Level Namespace>" entity= "<Eventhub Entity Name>" sasKeyName = "<SAS Policy Name>" sasKeyValue= "<SAS Key Value>" sbs = ServiceBusService(eventhub_namespace, shared_access_key_name=sasKeyName, shared_access_key_value=sasKeyValue) message = { "deviceId": "myDevice001", "temperature": "13.5" } sbs.send_event(entity, json.dumps(message))
lines = read_temp_raw(dfile) while lines[0].strip()[-3:] != 'YES': time.sleep(0.2) lines = read_temp_raw(dfile) equals_pos = lines[1].find('t=') if equals_pos != -1: temp_string = lines[1][equals_pos+2:] temp_c = float(temp_string) / 1000.0 return temp_c host = socket.gethostname() while True: try: temp1 = read_temp(device1_file) temp2 = read_temp(device2_file) body = '{\"DeviceId\": \"' + host + '\" ' now = datetime.now() body += ', \"rowid\":' + now.strftime('%Y%m%d%H%M%S') body += ', \"Time\":\"' + now.strftime('%Y/%m/%d %H:%M:%S') + '\"' body += ', \"Temp1\":' + str(temp1) body += ', \"Temp2\":' + str(temp2) + '}' print body sbs = ServiceBusService(service_namespace=name_space,shared_access_key_name=key_name, shared_access_key_value=key_value) hubStatus = sbs.send_event('sensordemohub',body) print "Send Status:", repr(hubStatus) time.sleep(5) except Exception as e: print "Exception - ", repr(e)
from azure.servicebus import ServiceBusService import json servns = 'Miage2016' # service_bus _namespace key_name = 'manage' # SharedAccessKeyName from Azure portal key_value = 'KEOU/Qun1wrPFO8eLXM4HCEa59WDP2qLcuuhNapYEjQ=' # SharedAccessKey from Azure portal cpt = 0 sbs = ServiceBusService(service_namespace=servns, shared_access_key_name=key_name, shared_access_key_value=key_value) # Create a ServiceBus Service Object with open('telco.json') as f: o=json.load(f) from time import sleep for e in o : print(json.dumps(e)) cpt = cpt + 1 sbs.send_event('iot', json.dumps(e)) sleep(1) print(cpt) print("Finished")
import time import sys from azure.servicebus import ServiceBusService key_name = "MySender" key_value = "MyKeyGoesHere" sbs = ServiceBusService("robotdeskeventhub-ns",shared_access_key_name=key_name, shared_access_key_value=key_value) while(True): print('sending...') sbs.send_event('nameofeventhub', '{ "DeviceId": "smokerpi", "Temperature": "37.0" }') print('sent!') time.sleep(10)
import time import sys from azure.servicebus import ServiceBusService infile = open("tempOutput.txt", "r") temp = infile.readline().rstrip() #print('received temp of: ' + temp) temp = int(temp) key_name = "sendRule" key_value = "9SWS0sNEBQMfTmuBHlxFwUHBFMSBgmJ77/ICSRm9HK4=" sbs = ServiceBusService("pimessage-ns",shared_access_key_name=key_name, shared_access_key_value=key_value) if temp > 65 or temp < 30: # print('sending temp of:' + temp) sbs.send_event('pimessage', '{ "DeviceId": "smokerpi", "Temperature": temp }') print('sent!') print ('got here') else: print('temp was in normal range')
[13, "Litter Box", "Pets", 30.00], [14, "Cough Syrup", "Medicine", 15.00]] # -------------------------------------------------------- # -------------------------------------------------------- # This will run for about 2.5 hours which should be fine for labs and demos for y in range(0, 2000): # Get a product from the products variable product = products[random.randint(0, 10)] # define a reading as a python dictionary object reading = { 'storeId': storeids[random.randint(0, 10)], 'timestamp': time.time(), 'producttype': product[0], 'name': product[1], 'category': product[2], 'price': product[3], 'quantity': random.randint(1, 3) } # Add some intrigue... if product[1] == "Cough Syrup": reading['quantity'] += 150 # use json.dumps to convert the dictionary to a JSON format s = json.dumps(reading) # send to Azure Event Hub sbs.send_event("<hub-name>", s) print(s) # wait 5 seconds time.sleep(5)
# GrovePi + Grove Temperature Sensor import time import grovepi from azure.servicebus import ServiceBusService key_name ='RootManageSharedAccessKey' # SharedAccessKeyName from Azure Portal key_value='' # SharedAccessKey from Azure Portal sbs = ServiceBusService('asatestsn', shared_access_key_name=key_name, shared_access_key_value=key_value) sbs.create_event_hub('hubcreationfromlinux') # Connect the Grove Temperature Sensor to analog port D4 sensor_port = 4 deviceId = "device-1" #Declare direction to the pin. #grovepi.pinMode (Temp_sensor,"INPUT") while True: try: [temp,hum] = grovepi.dht(sensor_port,0) CurrentTime = str(time.localtime(time.time()).tm_hour) + ":" + str(time.localtime(time.time()).tm_min) + ":"+ str(time.localtime(time.time()).tm_sec) print "Temperature : ", temp , "Humidity : ", hum, "RecordTime : ", CurrentTime sbs.send_event('hubcreationfromlinux', '{ "DeviceId":"' + deviceId + '", "Temperature":"' + str(temp) +'", "Humidity":"' + str(hum) +'", "RecordTime":"' + str(CurrentTime) +'"}') # sbs.send_event('hubcreationfromlinux', '{ "DeviceId":"' + deviceId + '", "Temperature":"' + temperature +'"}') time.sleep(1.0) except IOError: print "Error"
if isfirstrun == 1 : if isfirstrunRepeat == 1 : thisRunWaterMark=timecreated isfirstrunRepeat=0 #greedy run first outfile = open("last_time_processed", "w") outfile.write(thisRunWaterMark.strftime("%Y-%m-%dT%H:%M:%S")) outfile.close() #run until end if 'reverse mapping checking getaddrinfo for' in text: count+=1 dns= text.split('for ')[1].split(' [')[0] ip= text.split('for ')[1].split(' failed')[0].split('[')[1].split(']')[0] messagetosend = '{"guid":"62X74059-A444-4797-8A7E-526C3EF9D64B","organization":"SG MIC","timecreated":"'+timecreated.strftime("%Y-%m-%dT%H:%M:%S.0000000Z")+'","displayname":"SSH Sensor","location":"Azure DC Singapore","measurename":"SSH Reverse Mapping","unitofmeasure":"count","value":1,"dns":"'+dns+'","ip":"'+ip+'"}' print('sending event at ' +messagetosend) sbs.send_event('ehdevices', messagetosend) elif 'Failed password for root' in text: count+=1 ip= text.split('from ')[1].split(' port')[0] port= text.split('port ')[1].split(' ssh')[0] messagetosend = '{"guid":"62X74059-A444-4797-8A7E-526C3EF9D64B","organization":"SG MIC","timecreated":"'+timecreated.strftime("%Y-%m-%dT%H:%M:%S.0000000Z")+'","displayname":"SSH Sensor","location":"Azure DC Singapore","measurename":"SSH Failed Login Attempt","unitofmeasure":"count","value":1,"port":"'+port+'","ip":"'+ip+'"}' print('sending event at ' +messagetosend) sbs.send_event('ehdevices', messagetosend) elif 'Failed password for invalid user' in text: count+=1 ip= text.split('from ')[1].split(' port')[0] port= text.split('port ')[1].split(' ssh')[0] user = text.split('user ')[1].split(' from')[0] messagetosend = '{"guid":"62X74059-A444-4797-8A7E-526C3EF9D64B","organization":"SG MIC","timecreated":"'+timecreated.strftime("%Y-%m-%dT%H:%M:%S.0000000Z")+'","displayname":"SSH Sensor","location":"Azure DC Singapore","measurename":"SSH Failed Login Attempt","unitofmeasure":"count","value":1,"port":"'+port+'","ip":"'+ip+'","user":"******"}' print('sending event at ' +messagetosend)
import json import csv import random import time service_namespace = "<NAMESPACE_NAME>" shared_access_key_name = "RootManageSharedAccessKey" shared_access_key_value = "<KEY_VALUE>" sbs = ServiceBusService(service_namespace, shared_access_key_name=shared_access_key_name, shared_access_key_value=shared_access_key_value) def genMessage (): message = { "id": random.randint(1000,100000), "tt_1": random.randint(0, 100), "record": random.randint(0,3), "ts": time.time() } jsonMessage = json.dumps(message) return jsonMessage for i in range(1, 10000): message = genMessage() sbs.send_event("<HUB_NAME>", message) print(message)
} # append the product generated in readingJson to productsInTransaction array productsInTransaction.append(readingJson) # append an array of product jsons generated aboce to the overall transactions list transactions.append(productsInTransaction) # increment id start to get new ID number for transaction id construction transactionIDStart += 1 if kafka == False: # for each transaction generated for transaction in transactions: # for each product in each transaction for reading in transaction: # use json.dumps to convert the dictionary to a JSON format s = json.dumps(reading) # send to Azure Event Hub sbs.send_event(EVENT_HUB_NAME, s) print(s) else: # for each transaction generated for transaction in transactions: # for each product in each transaction for reading in transaction: s = json.dumps(reading) producer.send(TOPIC_NAME, s) print(s) # delay a second time.sleep(1) # add secodn to timestamp timeStamp += 1
key_value = "" event_hub_namespace = "" event_hub_name = "" sbs = ServiceBusService(service_namespace=event_hub_namespace, shared_access_key_name=key_name, shared_access_key_value=key_value) while True: sleep(0.5) soundLevel = grovepi.analogRead(sound_sensor) sleep(0.5) lightLevel = grovepi.analogRead(light_sensor) sleep(0.5) distance = ultrasonicRead(ultrasonic_ranger) sleep(0.3) [temp, hum] = dht(dht_sensor_port, dht_sensor_type) t = str(temp) h = str(hum) dataPoint = DataPoint(t, h, soundLevel, lightLevel, distance) payload = json.dumps(dataPoint, default=encode_data) print(payload) sbs.send_event(event_hub_name, payload) print("sending....")
from azure.servicebus import ServiceBusService NAMESPACE = 'chen-test-eh' KEY = 'ifs5GUcqdBANX8kh5T2DuwXrd6Qfhz1M5MaBtFIyLLY=' EVENTHUB = 'test_cap' sbs = ServiceBusService(service_namespace=NAMESPACE, shared_access_key_name='RootManageSharedAccessKey', shared_access_key_value=KEY, host_base='.servicebus.chinacloudapi.cn') devices = [] for x in range(0, 10): devices.append(str(uuid.uuid4())) for y in range(0, 20000): for dev in devices: reading = { 'id': dev, 'timestamp': str(datetime.datetime.utcnow()), 'uv': random.random(), 'temperature': random.randint(70, 100), 'humidity': random.randint(70, 100) } s = json.dumps(reading) sbs.send_event(EVENTHUB, s) print(y) # for y in range(0,200): # s='hello '*random.randint(1,10) + 'world '*random.randint(1,10) # sbs.send_event(EVENTHUB, s)
def signal(secs): led.write(0) time.sleep(secs) led.write(1) signal(1) #even hub config sbs = ServiceBusService("myhubed-ns", shared_access_key_name="SendReceiveRule", shared_access_key_value="hGRlK8cfxw/nU0SoH/egwJbg33BiUAi def logging(): cells = Cell.all('wlan0') count = len(cells) sbs.send_event('myhub', json.dumps("Count: " + str(count))) print "Count: " + str(count) for i in range(count): message = "SSID: " + cells[i].ssid + ", Signal: " + str(cells[i].signal) sbs.send_event('myhub', json.dumps(message)) print message signal(1) print "Done" # Listen for incoming connections sock.listen(5) print "Connection opened..." while True: try: # Wait for a connection
import json import datetime from grovepi import * from azure.servicebus import ServiceBusService dht_sensor_port = 6 # Connect the DHt sensor to this port dht_sensor_type = 0 # change this depending on your sensor type - see header comment potentiometer=0 # test device on Analog Port i.e. poti ... sbs = ServiceBusService(service_namespace='STITlndf-ns', shared_access_key_name='sendPOLICY', shared_access_key_value='Yil7vtCJx1HwxKXq7F3xDN+sbMUT4nud6QRRqItuxL4=') while True: try: [ temp,hum ] = dht(dht_sensor_port,dht_sensor_type) #Get the temperature and Humidity from the DHT sensor if not math.isnan(temp): if not math.isnan(hum): #itemp=analogRead(potentiometer) #temp= itemp #hum=itemp t = str(temp) h = str(hum) jsn = {'DeviceId': 'room1', 'Temperature': t, 'Humidity': h} print jsn, ' ', datetime.datetime.now() sbs.send_event('stitlndf',json.dumps(jsn) ) except (IOError,TypeError) as e: print 'Error'
import datetime import random import json import time from azure.servicebus import ServiceBusService sbs = ServiceBusService(service_namespace='<event hubs namespace>', shared_access_key_name='<key name>', shared_access_key_value='<key value>') devices = [] for x in range(0, 10): devices.append(str(uuid.uuid4())) cities = [ 'Chicago', 'New York City', 'Los Angeles', 'London', 'Salt Lake City', 'Dallas' ] for y in range(0, 2000): for dev in devices: reading = { 'id': dev, 'timestamp': str(datetime.datetime.utcnow()), 'uv': random.random(), 'temperature': random.randint(70, 100), 'humidity': random.randint(70, 100), 'city': cities[random.randint(0, 4)] } s = json.dumps(reading) sbs.send_event('samplehub', s) print(y) print(reading) time.sleep(5)
import random with open("settings.json") as json_file: api_key = json.load(json_file) sbs = ServiceBusService(api_key["namespace"], shared_access_key_name=api_key["policy_name"], shared_access_key_value=api_key["policy_secret"]) for i in range(100): roomtemp = random.randint(60, 70) dev1 = random.randint(1, 10) temp = {'DeviceId': 'device-1', 'Temperature': str(dev1), 'RoomTemperature': str(roomtemp)} sbs.send_event('woodstove2', json.dumps(temp)) print(json.dumps(temp)) dev2 = random.randint(20, 30) temp = {'DeviceId': 'device-2', 'Temperature': str(dev2), 'RoomTemperature': str(roomtemp)} sbs.send_event('woodstove2', json.dumps(temp)) print(json.dumps(temp)) dev3 = random.randint(30, 40) temp = {'DeviceId': 'device-3', 'Temperature': str(dev3), 'RoomTemperature': str(roomtemp)} sbs.send_event('woodstove2', json.dumps(temp)) print(json.dumps(temp)) dev4 = random.randint(40, 50) temp = {'DeviceId': 'device-4', 'Temperature': str(dev4), 'RoomTemperature': str(roomtemp)} sbs.send_event('woodstove2', json.dumps(temp))
import time import sys from azure.servicebus import ServiceBusService infile = open("tempOutput.txt", "r") temp = infile.readline().rstrip() #print('received temp of: ' + temp) temp = int(temp) key_name = "sendRule" key_value = "9SWS0sNEBQMfTmuBHlxFwUHBFMSBgmJ77/ICSRm9HK4=" sbs = ServiceBusService("pimessage-ns", shared_access_key_name=key_name, shared_access_key_value=key_value) if temp > 65 or temp < 30: # print('sending temp of:' + temp) sbs.send_event('pimessage', '{ "DeviceId": "smokerpi", "Temperature": temp }') print('sent!') print('got here') else: print('temp was in normal range')
def eh_send_func(sbnamespace, ehname, sasname, saskey): sbs = ServiceBusService(sbnamespace, shared_access_key_name=sasname, shared_access_key_value=saskey) return lambda producertoken, encodedmsg: sbs.send_event(ehname, encodedmsg, device_id=producertoken)
def send_events_to_event_hub(p_message): sbs = ServiceBusService("mtrpocehns", shared_access_key_name="RootManageSharedAccessKey", shared_access_key_value=shared_access_key_eh) sbs.send_event('mtrtransactionseh', p_message)
tenant = '1' num_devices = 10 shared_access_key_value = '#REPLACEME' shared_access_key_name = 'RootManageSharedAccessKey' service_namespace = '#REPLACEME' sbs = ServiceBusService(service_namespace, shared_access_key_name=shared_access_key_name, shared_access_key_value=shared_access_key_value) hub_name = 'tenant' + tenant while True: try: msg = {} is_error = choice([True, False]) device_id = randrange(1, num_devices) temperature = randrange(-50, 50) + random() pressure = randrange(0, 500) + random() ts = datetime.now().isoformat() msg["deviceId"] = "tenant" + tenant + "-" + str(device_id) msg["temperature"] = temperature if not is_error: msg["pressure"] = pressure msg["ts"] = ts msg["source"] = "eventhub" print(json.dumps(msg)) sbs.send_event(hub_name, json.dumps(msg)) time.sleep(0.01) except Exception as e: print(e)
arg_query = arg elif opt == '-t': arg_time = float(arg) # if arg_query == '': tweet_id = arg_tweet_id while True: i = 0 for status in tweepy.Cursor(api.home_timeline, since_id = tweet_id).items(max_tweets): if i == 0: last_tweet_id = status.id # print(unicode(status.text)) print("tweet : " + str(status.id)) searched_tweets = "{ 'source': '" + unicode(status.user.name) + "' , 'text': '" + unicode(status.text) + "' }" print(unicode(searched_tweets)) sbs.send_event('iot', unicode(searched_tweets)) i = i + 1 tweet_id = last_tweet_id print('dodo' + ' id : ' + str(last_tweet_id)) sleep(arg_time) # else: # searched_tweets = [status._json for status in tweepy.Cursor(api.home_timeline).items(max_tweets)] # searched_tweets = json.dumps(searched_tweets) # sbs.send_event('iot', searched_tweets) # for result in tweepy.Cursor(api.search, q=query).items(): # sbs.send_event('iot', result) # sleep(1)
#!/usr/bin/python3 import requests import datetime import random import json from azure.servicebus import ServiceBusService creds=json.load(open('/home/chaos/password.json')) armageddon=json.load(open('/home/chaos/armageddon.json')) if not armageddon['state']: sbs = ServiceBusService(service_namespace='chaosMonkeys', shared_access_key_name='RootManageSharedAccessKey', shared_access_key_value=creds['password']) min_level=5.656 max_level=13.563 cl=json.load(open('/home/chaos/tank_stat.json','r')) row= {'name':'StackTank', 'Timestamp':datetime.datetime.now().isoformat(), 'location':{'lat':36.116626,'long':-97.709833},'max':max_level} cl['level']+=(random.random()/10) if cl['level']>max_level: cl['level']=min_level row['level']=cl['level'] json.dump(cl,open('/home/chaos/tank_stat.json','w')) sbs.send_event('tanklevel', json.dumps(row))
def lambda_handler(event, context): key_name = "awscollector" #key_value = os.environ.get('EMF_KEY_VALUE') key_value = "1gsvM56NH02r1qhLs/czbjdjNqEnVnqwi4GZNn20b2s=" service_namespace = "em-lab-ns-intake01" sbs = ServiceBusService(service_namespace, shared_access_key_name=key_name, shared_access_key_value=key_value, timeout=30) sql = ''\ 'SELECT blocked_locks.pid AS blocked_pid, '\ 'blocked_activity.usename AS blocked_user, '\ 'blocking_locks.pid AS blocking_pid, '\ 'blocking_activity.usename AS blocking_user, '\ 'blocked_activity.query AS blocked_statement, '\ 'blocking_activity.query AS current_statement_in_blocking_process '\ 'FROM pg_catalog.pg_locks blocked_locks '\ 'JOIN pg_catalog.pg_stat_activity blocked_activity ON blocked_activity.pid = blocked_locks.pid '\ 'JOIN pg_catalog.pg_locks blocking_locks '\ 'ON blocking_locks.locktype = blocked_locks.locktype '\ 'AND blocking_locks.DATABASE IS NOT DISTINCT FROM blocked_locks.DATABASE '\ 'AND blocking_locks.relation IS NOT DISTINCT FROM blocked_locks.relation '\ 'AND blocking_locks.page IS NOT DISTINCT FROM blocked_locks.page '\ 'AND blocking_locks.tuple IS NOT DISTINCT FROM blocked_locks.tuple '\ 'AND blocking_locks.virtualxid IS NOT DISTINCT FROM blocked_locks.virtualxid '\ 'AND blocking_locks.transactionid IS NOT DISTINCT FROM blocked_locks.transactionid '\ 'AND blocking_locks.classid IS NOT DISTINCT FROM blocked_locks.classid '\ 'AND blocking_locks.objid IS NOT DISTINCT FROM blocked_locks.objid '\ 'AND blocking_locks.objsubid IS NOT DISTINCT FROM blocked_locks.objsubid '\ 'AND blocking_locks.pid != blocked_locks.pid '\ 'JOIN pg_catalog.pg_stat_activity blocking_activity ON blocking_activity.pid = blocking_locks.pid '\ 'WHERE NOT blocked_locks.GRANTED' logger.info("SQL: " + str(sql)) cur = conn.cursor() cur.execute(sql) item_count = 0 for row in cur: #do something with every single row here #optionally print the row print row logger.info("Message: " + str(row)) if item_count < 1: event_out = {} event_out['Source'] = 'RDS Lambda Alarm' event_out['Host'] = rds_host event_out['EventType'] = 'RDS Postgres blocking locks' event_out[ 'Summary'] = 'This is fired when there is blocking happening in the Postgresql' event_out['Severity'] = 0 #event_out['ExtraDetails'] = 'Blocked: ' + row.blocked_statement + ' Blocking: ' + row.current_statement_in_blocking_process + '\n' event_out['ExtraDetails'] = row event_out['emf_id'] = str(uuid.uuid4()) event_out['source_instance'] = db_name else: event_out['ExtraDetails'] = event_out['ExtraDetails'] + row item_count += 1 if item_count > 0: sbs.send_event('lab-eh-aws-intake', json.dumps(event_out)) logger.info("Message: " + str(event_out)) return "Added %d items from RDS Postgresql table"
import time import sys from azure.servicebus import ServiceBusService key_name = "MySender" key_value = "MyKeyGoesHere" sbs = ServiceBusService("robotdeskeventhub-ns", shared_access_key_name=key_name, shared_access_key_value=key_value) while (True): print('sending...') sbs.send_event('nameofeventhub', '{ "DeviceId": "smokerpi", "Temperature": "37.0" }') print('sent!') time.sleep(10)
import uuid import datetime import random import json from azure.servicebus import ServiceBusService sbs = ServiceBusService(service_namespace='cpvevh1', shared_access_key_name='first', shared_access_key_value='WZnrLkWdsWCDehbO5OAUEGIVXpiE+V9Yn9CZqGX/gMs=') devices = [] for x in range(0, 10): devices.append(str(uuid.uuid4())) for y in range(0,20): for dev in devices: reading = {'id': dev, 'timestamp': str(datetime.datetime.utcnow()), 'uv': random.random(), 'temperature': random.randint(70, 100), 'humidity': random.randint(70, 100)} s = json.dumps(reading) sbs.send_event('ev1', s) print(y)