def TargetsToAzure(targets, sbs):
for i, target in enumerate(targets):
t = TargetPoint(i, target)
if debug: print(t.toJson())
sbs.send_event(walabot_hub, t.toJson())
if __name__ == "__main__":
key_name = "RootManageSharedAccessKey" # SharedAccessKeyName from Azure portal
sbs = ServiceBusService(service_namespace=sn,
shared_access_key_name=key_name,
shared_access_key_value=key_value)
sbs.create_event_hub(walabot_hub)
wala.Init()
wala.SetSettingsFolder()
try:
wala.ConnectAny()
except WalabotError as err:
if err.message == wala.WALABOT_INSTRUMENT_NOT_FOUND:
print('Please connect your Walabot')
else:
print(err.message)
wala.SetProfile(wala.PROF_SENSOR)
wala.SetDynamicImageFilter(wala.FILTER_TYPE_MTI)
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 tweepy.streaming import StreamListener
from tweepy import OAuthHandler
from tweepy import Stream
from azure.servicebus import ServiceBusService
import json
from collections import Counter
import urllib3
import sys
key_value = 'TsPSqYRxHLwMfuZW6C+sMWFlX/NuDDfUzhVT/qQNneM=' # SharedAccessKey from Azure portal
key_name = 'manage' # SharedAccessKeyName from Azure portal
sbs = ServiceBusService('w205Ex2twitter',
shared_access_key_name=key_name,
shared_access_key_value=key_value)
sbs.create_event_hub('w205ex2twitter')
#Variables that contains the user credentials to access Twitter API
access_token = "723321852928487424-6DpOhp2IVLdLHcT5xqOyp3ZF6KfD045"
access_token_secret = "k1kTDSQke2oivdYwFOwS0cP6bTC4TLK0nM4qpkxhs3tjQ"
consumer_key = "UazvoPbRP6S6X890BWVk9srj5"
consumer_secret = "6McwA8RuB2ZWoDpYP0TpOsqOp9I0PZRfZoesJfLwFfoGw28QKz"
def word_count(tweet):
# Split the tweet into words
words = tweet.split()
# Filter out the hash tags, RT, @ and urls
valid_words = []
for word in words:
# Filter the hash tags
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)))
class EventHubServiceTest(AzureTestCase):
def setUp(self):
session = None
if credentials.getUseRequestsLibrary():
from requests import Session
session = Session()
self.sbs = ServiceBusService(
credentials.getEventHubNamespace(),
shared_access_key_name=credentials.getEventHubSasKeyName(),
shared_access_key_value=credentials.getEventHubSasKeyValue(),
request_session=session,
)
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)
# 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"
from rtlsdr import RtlSdr
sdr = RtlSdr()
# sdr
sdr.sample_rate = 2.048e6
sdr.center_freq = 70e6
sdr.freq_correction = 60
sdr.gain = 'auto'
# Azure
key_name = 'RootManageSharedAccessKey'
key_value = '6RS3yrdYH3Ds/+rQPKQjiG56VpzghffyCDNbxGTiivo='
service_namespace = 'hyperfineml'
x = 512
i = 0
samples = sdr.read_samples(x)
sbs = ServiceBusService(service_namespace,
shared_access_key_name=key_name,
shared_access_key_value=key_value)
if (sbs.create_event_hub('sdrhub')):
while (i < x):
sbs.send_event('sdr', '{"signalval": "' + str(samples[i]) + '"}')
i = i + 1
sbs.delete_event_hub('sdrhub')
else:
print "Event Hub creation failed"
from azure.servicebus import ServiceBusService
namespace = 'rumruk'
key_name = 'arduino'
key_value = 'T8macrUAHRksynPCOGdEkUnXkZ/uyVZHNk6Y0Thx1gc='
sbs = ServiceBusService(namespace,
shared_access_key_name=key_name,
shared_access_key_value=key_value)
sbs.create_event_hub('plantduino')
"""
from flask import Flask, request
import datetime, json
app = Flask(__name__)
app.debug = True
# Make the WSGI interface available at the top level so wfastcgi can get it.
wsgi_app = app.wsgi_app
devices = []
from azure.servicebus import ServiceBusService
srvns = 'iotsample0917ns'
key_name = 'rootSAS'
key_value = 'gTTf0bVKzFz2Ufjts8unUQRFMEsQORHwmTzAHtKwJng='
sbs = ServiceBusService(service_namespace=srvns, shared_access_key_name=key_name, shared_access_key_value=key_value)
flag = sbs.create_event_hub('iotsample0917')
print(flag)
@app.route('/')
def hi():
return 'hello world'
@app.route('/Devices/<devid>', methods=['POST'] )
def create_device(devid):
curdevice = None
for device in devices:
if device['deviceid'] == devid:
curdevice=device
break
if curdevice is not None:
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)
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)
from gpiozero import LED
from azure.servicebus import ServiceBusService
# Connection strings for Event Hub
secrets = json.load(open('secrets.json'))
key_name = secrets['key_name']
key_value = secrets['key_value']
service_namespace = secrets['service_namespace']
eventhub_name = secrets['eventhub_name']
# Establish connection to Event Hub
host = socket.gethostname()
sbs = ServiceBusService(service_namespace,
shared_access_key_name=key_name,
shared_access_key_value=key_value)
sbs.create_event_hub(eventhub_name)
# Parameters
interval = 10 #seconds
sensor1 = "28-041700305eff"
sensor2 = "28-0517001488ff"
led_red = LED(23)
led_green = LED(24)
# Current timestamp
start_time = datetime.datetime.now()
# Error Tracker
error = False
# Status timestamps
from flask import Flask, request
import datetime, json
app = Flask(__name__)
app.debug = True
# Make the WSGI interface available at the top level so wfastcgi can get it.
wsgi_app = app.wsgi_app
devices = []
from azure.servicebus import ServiceBusService
srvns = 'iotsample0917ns'
key_name = 'RootManageSharedAccessKey'
key_value = '3nCF6PobWcyDyKxZDsqLkTeVBTA9TMMpFW/ZOCGr2+8='
sbs = ServiceBusService(service_namespace=srvns,
shared_access_key_name=key_name,
shared_access_key_value=key_value)
flag = sbs.create_event_hub('iotsample0917')
print(flag)
@app.route('/')
def hi():
return 'hello world'
@app.route('/Devices/<devid>', methods=['POST'])
def create_device(devid):
curdevice = None
for device in devices:
if device['deviceid'] == devid:
curdevice = device
break
