def get_client(): global client if client == None: AccessKeyId = os.environ.get('AWS_ACCESS_KEY_ID') SecretKey = os.environ.get('AWS_SECRET_ACCESS_KEY') SessionToken = os.environ.get('AWS_SESSION_TOKEN') Host = os.environ.get('OT_IOT_HOST') client = AWSIoTMQTTClient("sharedClient", useWebsocket=True) client.configureEndpoint(Host, 443) client.configureCredentials( "./certs/VeriSign-Class 3-Public-Primary-Certification-Authority-G5.pem" ) client.configureIAMCredentials(AccessKeyId, SecretKey, SessionToken) client.configureAutoReconnectBackoffTime(1, 32, 20) client.configureOfflinePublishQueueing( -1) # Infinite offline Publish queueing client.configureDrainingFrequency(2) # Draining: 2 Hz client.configureConnectDisconnectTimeout(10) # 10 sec client.configureOfflinePublishQueueing( 0) # No offline Publish queueing client.configureConnectDisconnectTimeout(5) # 5 sec client.configureMQTTOperationTimeout(5) # 5 sec client.connect() return client
def config(self): print('Configure MQTT') # Cognito auth identityPoolID = cognitoIdentityPoolID cognitoIdentityClient = boto3.client('cognito-identity', region_name=region) temporaryIdentityId = cognitoIdentityClient.get_id( IdentityPoolId=identityPoolID) identityID = temporaryIdentityId["IdentityId"] temporaryCredentials = cognitoIdentityClient.get_credentials_for_identity( IdentityId=identityID) AccessKeyId = temporaryCredentials["Credentials"]["AccessKeyId"] SecretKey = temporaryCredentials["Credentials"]["SecretKey"] SessionToken = temporaryCredentials["Credentials"]["SessionToken"] # AWSIoTMQTTClient configuration AWSIoTMQTTClient.configureEndpoint(self, host, port) AWSIoTMQTTClient.configureCredentials(self, rootCAPath) AWSIoTMQTTClient.configureIAMCredentials(self, AccessKeyId, SecretKey, SessionToken) AWSIoTMQTTClient.configureAutoReconnectBackoffTime(self, 1, 32, 20) AWSIoTMQTTClient.configureOfflinePublishQueueing( self, -1) # Infinite offline Publish queueing AWSIoTMQTTClient.configureDrainingFrequency(self, 2) # Draining: 2 Hz AWSIoTMQTTClient.configureConnectDisconnectTimeout(self, 10) # 10 sec AWSIoTMQTTClient.configureMQTTOperationTimeout(self, 5) # 5 sec print('Configure MQTT done') return self
def GetInstance(): if (MqttClient.mqttclient == None): MqttClient.mutex.acquire() if (MqttClient.mqttclient == None): rootCAPath = r"/home/mqtt/cert/3-Public-Primary-Certification-Authority-G5.pem" host = r"" obtainedAccessKeyID = "" obtainedSecretAccessKey = "" obtainedSessionToken = "" mqttclient = AWSIoTMQTTClient(str(uuid.uuid1()), useWebsocket=True) mqttclient.configureEndpoint(host, 443) mqttclient.configureCredentials(rootCAPath) mqttclient.configureAutoReconnectBackoffTime(1, 32, 20) mqttclient.configureOfflinePublishQueueing( -1) # Infinite offline Publish queueing mqttclient.configureDrainingFrequency(10) # Draining: 2 Hz mqttclient.configureConnectDisconnectTimeout(10) # 10 sec mqttclient.configureMQTTOperationTimeout(10) # 10 sec mqttclient.configureIAMCredentials(obtainedAccessKeyID, obtainedSecretAccessKey, obtainedSessionToken) mqttclient._mqttCore._pahoClient.on_log = mylog MqttClient.mqttclient = mqttclient try: mqttclient.connect() except Exception, e: logging.error('mqttclient connect error') logging.error(e) MqttClient.mutex.release()
def force_disconnect(client_id): print 'Attempting to force disconnect on client {}'.format(client_id) endpoint, endpoint_port = registration_shared.get_endpoint_and_port('WEBSOCKET') print 'Using endpoint {}:{}'.format(endpoint, endpoint_port) iot_client = AWSIoTMQTTClient(client_id, useWebsocket=True) iot_client.configureEndpoint(endpoint, endpoint_port) iot_client.configureConnectDisconnectTimeout(20) iot_client.configureMQTTOperationTimeout(5) iot_client.configureCredentials('AWSIoTPythonSDK/certs/rootCA.pem') access_key = os.environ.get('AWS_ACCESS_KEY_ID') secret_key = os.environ.get('AWS_SECRET_ACCESS_KEY') session_token = os.environ.get('AWS_SESSION_TOKEN') iot_client.configureIAMCredentials(AWSAccessKeyID=access_key, AWSSecretAccessKey=secret_key, AWSSessionToken=session_token) print 'Configured credentials, attempting connect...' response = iot_client.connect() print 'Connect returns {}'.format(response) if response: print 'Disconnecting..' iot_client.disconnect()
def publish_mqtt(user_data, secret_details, auth_credentials): # Init AWSIoTMQTTClient. # MQTT client can only connect if MQTT client is same as unique identity ID. # Client can only write to CognitoIdentityPoolId/IdentityID/* cognitoIdentityPoolID = user_data['cognitoIdentityPoolID'] mqtttopic = cognitoIdentityPoolID + "/" + \ auth_credentials['identityID'] + "/" + user_data['topic'] # only allow client with identity id to conenct myAWSIoTMQTTClient = AWSIoTMQTTClient(auth_credentials['identityID'], useWebsocket=True) # AWSIoTMQTTClient configuration myAWSIoTMQTTClient.configureEndpoint(secret_details['host'], 443) myAWSIoTMQTTClient.configureCredentials(user_data['rootCAPath']) myAWSIoTMQTTClient.configureIAMCredentials( auth_credentials['AccessKeyId'], auth_credentials['SecretKey'], auth_credentials['SessionToken']) myAWSIoTMQTTClient.configureAutoReconnectBackoffTime(1, 32, 20) # Infinite offline Publish queueing myAWSIoTMQTTClient.configureOfflinePublishQueueing(-1) myAWSIoTMQTTClient.configureDrainingFrequency(2) # Draining: 2 Hz myAWSIoTMQTTClient.configureConnectDisconnectTimeout(10) # 10 sec myAWSIoTMQTTClient.configureMQTTOperationTimeout(5) # 5 sec # Connect and subscribe to AWS IoT print("I am here") print("client id is:" + auth_credentials['identityID']) myAWSIoTMQTTClient.connect() myAWSIoTMQTTClient.subscribe(mqtttopic, 1, customCallback) time.sleep(2) # Publish to the same topic in a loop forever loopCount = 0 while True: message = {'Message from authenticated cognito identity': loopCount} myAWSIoTMQTTClient.publish(mqtttopic, json.dumps(message), 1) loopCount += 1 time.sleep(1)
class Client(): def __init__(self, iot_client=None, iot_data_client=None, credentials=None, ca_path=None, privkey_path=None, cert_path=None): assert ca_path, "Certificate is required" if not iot_client: iot_client = boto3.client('iot') if not iot_data_client: iot_data_client = boto3.client('iot-data') self.iot_client = iot_client self.iot_data_client = iot_data_client self.cert_path = cert_path self.privkey_path = privkey_path self.ca_path = ca_path self.credentials = credentials self.init_mqtt_client() def init_mqtt_client(self): endpoint = self.iot_client.describe_endpoint() use_websocket = True if self.credentials else False endpoint_port = 443 if use_websocket else 8883 self.mqtt_client = AWSIoTMQTTClient("testo", useWebsocket=use_websocket) self.mqtt_client.configureEndpoint(endpoint['endpointAddress'], endpoint_port) self.mqtt_client.configureOfflinePublishQueueing(-1) self.mqtt_client.configureConnectDisconnectTimeout(10) self.mqtt_client.configureMQTTOperationTimeout(10) self.configure_credentials() log.debug("OpenSSL version {}".format(ssl.OPENSSL_VERSION)) log.debug("Connecting MQTT client to {} on port {}...".format( endpoint['endpointAddress'], endpoint_port)) try: self.mqtt_client.connect() log.debug("MQTT client connected") except connectTimeoutException: log.error("Failed to connect MQTT client - timeout (check policy)") self.mqtt_client = None def configure_credentials(self): if self.credentials: self.mqtt_client.configureIAMCredentials( *(self.credentials.values())) self.mqtt_client.configureCredentials(self.ca_path) elif self.privkey_path and self.cert_path: log.debug("Using %s %s %s", str(self.ca_path), str(self.privkey_path), str(self.cert_path)) self.mqtt_client.configureCredentials(self.ca_path, self.privkey_path, self.cert_path) else: raise Exception("No credentials found")
def main(): mqttclient = AWSIoTMQTTClient(clientId, useWebsocket=True) # Websocket SigV4を利用 mqttclient.configureIAMCredentials(accessId, secretKey) mqttclient.configureCredentials(rootCA) # ルート証明書の設定が必要 mqttclient.configureEndpoint(endPoint, mqttport) mqttclient.configureAutoReconnectBackoffTime(1, 32, 20) mqttclient.configureOfflinePublishQueueing(-1) mqttclient.configureDrainingFrequency(2) mqttclient.configureConnectDisconnectTimeout(10) mqttclient.configureMQTTOperationTimeout(5) mqttclient.connect() print("onConnect") mqttclient.subscribe(topic, 1, onSubscribe) while True: time.sleep(5)
def aws_initialize(USERNAME, host="", rootCAPath="", cognitoIdentityPoolID=""): # Missing configuration notification missingConfiguration = False if not host: print("Missing '-e' or '--endpoint'") missingConfiguration = True if not rootCAPath: print("Missing '-r' or '--rootCA'") missingConfiguration = True if not cognitoIdentityPoolID: print("Missing '-C' or '--CognitoIdentityPoolID'") missingConfiguration = True if missingConfiguration: exit(2) identityPoolID = cognitoIdentityPoolID region = host.split('.')[2] cognitoIdentityClient = boto3.client('cognito-identity', region_name=region) temporaryIdentityId = cognitoIdentityClient.get_id( IdentityPoolId=identityPoolID) identityID = temporaryIdentityId["IdentityId"] temporaryCredentials = cognitoIdentityClient.get_credentials_for_identity( IdentityId=identityID) AccessKeyId = temporaryCredentials["Credentials"]["AccessKeyId"] SecretKey = temporaryCredentials["Credentials"]["SecretKey"] SessionToken = temporaryCredentials["Credentials"]["SessionToken"] # Init AWSIoTMQTTClient clientID = USERNAME + " Monitor" myAWSIoTMQTTClient = AWSIoTMQTTClient(clientID, useWebsocket=True) # AWSIoTMQTTClient configuration myAWSIoTMQTTClient.configureEndpoint(host, 443) myAWSIoTMQTTClient.configureCredentials(rootCAPath) myAWSIoTMQTTClient.configureIAMCredentials(AccessKeyId, SecretKey, SessionToken) myAWSIoTMQTTClient.configureAutoReconnectBackoffTime(1, 32, 20) myAWSIoTMQTTClient.configureOfflinePublishQueueing( -1) # Infinite offline Publish queueing myAWSIoTMQTTClient.configureDrainingFrequency(2) # Draining: 2 Hz myAWSIoTMQTTClient.configureConnectDisconnectTimeout(10) # 10 sec myAWSIoTMQTTClient.configureMQTTOperationTimeout(5) # 5 sec return myAWSIoTMQTTClient
def connect(self): port = 443 # Cognito経由の認証では、Websocketしか使用できない rootCA = self.rootCA # ルート証明書も必要 accessId, secretKey, token = self._getAuthentication(self.identityPoolId) client = AWSIoTMQTTClient(self.clientId, useWebsocket=True) client.configureIAMCredentials(accessId, secretKey, token) client.configureCredentials(rootCA) client.configureEndpoint(self.endPoint, port) client.configureAutoReconnectBackoffTime(1, 32, 20) client.configureOfflinePublishQueueing(-1) client.configureDrainingFrequency(2) client.configureConnectDisconnectTimeout(10) client.configureMQTTOperationTimeout(5) client.connect() print("mqtt connect.") client.subscribe(self.topic, 1, self._onSubscribe) print("mqtt subscrib.")
def get_client(credentials): print(credentials['client_id']) myMQTTClient = AWSIoTMQTTClient(credentials['client_id'], useWebsocket=True) myMQTTClient.configureEndpoint(iot_host, 443) myMQTTClient.configureCredentials( './certs/VeriSign-Class 3-Public-Primary-Certification-Authority-G5.pem' ) myMQTTClient.configureIAMCredentials(credentials['access_key_id'], credentials['secret_access_key'], credentials['session_token']) myMQTTClient.configureAutoReconnectBackoffTime(1, 32, 20) myMQTTClient.configureOfflinePublishQueueing( -1) # Infinite offline Publish queueing myMQTTClient.configureDrainingFrequency(2) # Draining: 2 Hz myMQTTClient.configureConnectDisconnectTimeout(10) # 10 sec myMQTTClient.configureMQTTOperationTimeout(5) # 5 sec return myMQTTClient
class Client(): def __init__(self, iot_client=None, iot_data_client=None, credentials=None, ca_path=None, privkey_path=None, cert_path=None): assert ca_path, "Certificate is required" if not iot_client: iot_client = boto3.client('iot') if not iot_data_client: iot_data_client = boto3.client('iot-data') self.iot_client = iot_client self.iot_data_client = iot_data_client self.cert_path = cert_path self.privkey_path = privkey_path self.ca_path = ca_path self.credentials = credentials self.init_mqtt_client() def init_mqtt_client(self): endpoint = self.iot_client.describe_endpoint() use_websocket = True if self.credentials else False endpoint_port = 443 if use_websocket else 8883 self.mqtt_client = AWSIoTMQTTClient("testo", useWebsocket=use_websocket) self.mqtt_client.configureEndpoint(endpoint['endpointAddress'], endpoint_port) self.mqtt_client.configureOfflinePublishQueueing(-1) self.mqtt_client.configureConnectDisconnectTimeout(10) self.mqtt_client.configureMQTTOperationTimeout(10) self.configure_credentials() log.debug("OpenSSL version {}".format(ssl.OPENSSL_VERSION)) log.debug("Connecting MQTT client to {} on port {}...".format(endpoint['endpointAddress'], endpoint_port)) try: self.mqtt_client.connect() log.debug("MQTT client connected") except connectTimeoutException: log.error("Failed to connect MQTT client - timeout (check policy)") self.mqtt_client = None def configure_credentials(self): if self.credentials: self.mqtt_client.configureIAMCredentials(*(self.credentials.values())) self.mqtt_client.configureCredentials(self.ca_path) elif self.privkey_path and self.cert_path: log.debug("Using %s %s %s", str(self.ca_path), str(self.privkey_path), str(self.cert_path)) self.mqtt_client.configureCredentials(self.ca_path, self.privkey_path, self.cert_path) else: raise Exception("No credentials found")
class aws_iot(): def __init__(self): self.client = AWSIoTMQTTClient("myClientID", useWebsocket=True) def aws_connect(self): self.client.configureEndpoint("a247jnsfrl6hqw-ats.iot.ap-south-1.amazonaws.com", 443) # AWS IoT MQTT Client self.client.configureIAMCredentials('AKIAW4YHSL77QXB37PUS', 'jCCtCV6PLsZB8d9eU3SzQ4PVakVxc5+WUoRskJ4q') cwd = os.getcwd() crt_path = os.path.join(cwd,"root_ca.crt") print(crt_path) self.client.configureCredentials(crt_path) self.client.configureOfflinePublishQueueing(-1) # Infinite offline Publish queueing self.client.configureDrainingFrequency(2) # Draining: 2 Hz self.client.configureConnectDisconnectTimeout(10) # 10 sec self.client.configureMQTTOperationTimeout(5) # 5 sec return self.client.connect() def aws_publish(self, data): return self.client.publish("skc", data, 1)
def Setup(): # Cleanup signal.signal(signal.SIGTERM, Cleanup) # Stat activeLed.on() # MQTT cognitoIdentityClient = boto3.client('cognito-identity', region_name=region) temporaryIdentityId = cognitoIdentityClient.get_id(IdentityPoolId=poolId) identityId = temporaryIdentityId["IdentityId"] temporaryCredentials = cognitoIdentityClient.get_credentials_for_identity( IdentityId=identityId) accessKeyId = temporaryCredentials["Credentials"]["AccessKeyId"] secretKey = temporaryCredentials["Credentials"]["SecretKey"] sessionToken = temporaryCredentials["Credentials"]["SessionToken"] mqttClient = AWSIoTMQTTClient(clientId, useWebsocket=True) mqttClient.configureEndpoint(endpoint, port) mqttClient.configureCredentials(rootCaPath) mqttClient.configureIAMCredentials(accessKeyId, secretKey, sessionToken) # Base back off(s), max back off(s), stable time(s) mqttClient.configureAutoReconnectBackoffTime(1, 32, 20) # 0: disabled, -1: infinite queueing mqttClient.configureOfflinePublishQueueing(-1) # Frequency of draining in seconds when connection is established mqttClient.configureDrainingFrequency(2) # Time in seconds to wait for CONNACK or disconnect mqttClient.configureConnectDisconnectTimeout(10) # General timeout in seconds for MQTT operations mqttClient.configureMQTTOperationTimeout(5) mqttClient.connect() mqttClient.subscribe(topic, 1, MessageReceived)
def __init__(self, host, rootCAPath, cognitoIdentityPoolID): self.host = host self.rootCAPath = rootCAPath self.cognitoIdentityPoolID = cognitoIdentityPoolID # Cognito auth identityPoolID = cognitoIdentityPoolID region = host.split('.')[2] cognitoIdentityClient = boto3.client('cognito-identity', region_name=region) # identityPoolInfo = cognitoIdentityClient.describe_identity_pool(IdentityPoolId=identityPoolID) # print identityPoolInfo temporaryIdentityId = cognitoIdentityClient.get_id( IdentityPoolId=identityPoolID) identityID = temporaryIdentityId["IdentityId"] temporaryCredentials = cognitoIdentityClient.get_credentials_for_identity( IdentityId=identityID) self.accesskeyid = temporaryCredentials["Credentials"]["AccessKeyId"] self.secretkeyid = temporaryCredentials["Credentials"]["SecretKey"] self.sessiontoken = temporaryCredentials["Credentials"]["SessionToken"] # Init AWSIoTMQTTClient myAWSIoTMQTTClient = AWSIoTMQTTClient("healthmonitoriot", useWebsocket=True) # AWSIoTMQTTClient configuration myAWSIoTMQTTClient.configureEndpoint(host, 443) myAWSIoTMQTTClient.configureCredentials(rootCAPath) myAWSIoTMQTTClient.configureIAMCredentials(AccessKeyId, SecretKey, SessionToken) myAWSIoTMQTTClient.configureAutoReconnectBackoffTime(1, 32, 20) myAWSIoTMQTTClient.configureOfflinePublishQueueing( -1) # Infinite offline Publish queueing myAWSIoTMQTTClient.configureDrainingFrequency(2) # Draining: 2 Hz myAWSIoTMQTTClient.configureConnectDisconnectTimeout(10) # 10 sec myAWSIoTMQTTClient.configureMQTTOperationTimeout(5) # 5 sec
def setup(): root_ca_file = "root-ca.pem" # Get the CA cert if we need it if not path.exists(root_ca_file): request = requests.get( 'https://www.amazontrust.com/repository/AmazonRootCA1.pem', allow_redirects=True) open(root_ca_file, 'wb').write(request.content) # Get the hostname for the customer's ATS endpoint in this region iot_client = boto3.client('iot') iot_data = iot_client.describe_endpoint(endpointType='iot:Data-ATS') host = iot_data['endpointAddress'] # Get temporary credentials sts_client = boto3.client('sts') sts_data = sts_client.get_session_token() # Extract the temporary credential values credentials = sts_data['Credentials'] access_key_id = credentials['AccessKeyId'] secret_access_key = credentials['SecretAccessKey'] session_token = credentials['SessionToken'] # Create an MQTT client with a random client ID that uses WebSockets mqtt_client = AWSIoTMQTTClient(str(uuid.uuid4()), useWebsocket=True) # Use port 443 + ALPN on the customer's ATS endpoint mqtt_client.configureEndpoint(host, 443) # Explicitly enable the root CA we downloaded mqtt_client.configureCredentials(root_ca_file) # Configure the library to use the specified credentials instead of using another provider to fetch them AWSIoTMQTTClient.configureIAMCredentials(mqtt_client, access_key_id, secret_access_key, session_token) return mqtt_client
# Configure logging logger = logging.getLogger("AWSIoTPythonSDK.core") logger.setLevel(logging.DEBUG) streamHandler = logging.StreamHandler() formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') streamHandler.setFormatter(formatter) logger.addHandler(streamHandler) # Init AWSIoTMQTTClient myAWSIoTMQTTClient = None if useWebsocket: myAWSIoTMQTTClient = AWSIoTMQTTClient(clientId, useWebsocket=True) myAWSIoTMQTTClient.configureEndpoint(host, port) myAWSIoTMQTTClient.configureCredentials(rootCAPath) myAWSIoTMQTTClient.configureIAMCredentials(clientId, keyId) else: myAWSIoTMQTTClient = AWSIoTMQTTClient(clientId) myAWSIoTMQTTClient.configureEndpoint(host, port) myAWSIoTMQTTClient.configureCredentials(rootCAPath, privateKeyPath, certificatePath) # AWSIoTMQTTClient connection configuration myAWSIoTMQTTClient.configureAutoReconnectBackoffTime(1, 32, 20) myAWSIoTMQTTClient.configureOfflinePublishQueueing(-1) # Infinite offline Publish queueing myAWSIoTMQTTClient.configureDrainingFrequency(2) # Draining: 2 Hz myAWSIoTMQTTClient.configureConnectDisconnectTimeout(10) # 10 sec myAWSIoTMQTTClient.configureMQTTOperationTimeout(5) # 5 sec # Connect and subscribe to AWS IoT myAWSIoTMQTTClient.connect() if args.mode == 'both' or args.mode == 'subscribe':
def awsSimulationWS(): from AWSIoTPythonSDK.MQTTLib import AWSIoTMQTTClient import logging import time import argparse import json import random deviceName = "awsDevice" frequency = 5 timeInterval = 10 minRange = 10 maxRange = 100 topic = "sdk/test/Python" obtainedSessionToken = "FQoGZXIvYXdzELH//////////wEaDB4pvTJDS5l4fphjniKYAXKoJCbvQSsAwk23qFdIzESPpKcts38dSpTgyoZtsPLZg/aDL3NR1Vj1LXJpL36z8f3Syt/F7gdNIDME6ZdpH1G/xCAWT10YHM5GL6FKkoJLHiFL3vHAmQU5Tqgqfko+gy4PRJ5yijhQcg/FiR4IYcHVAox9Kl/5d0M59RusolYfGiBygprF9HXn914lZO4A962qS7kEs9R/KP7q8OwF" # For certificate based connection # myMQTTClient = AWSIoTMQTTClient("basicPubSub") # For Websocket connection myMQTTClient = AWSIoTMQTTClient("myClientID", useWebsocket=True) # Configurations # For TLS mutual authentication # myMQTTClient.configureEndpoint("a2on3hwushji1e-ats.iot.us-east-2.amazonaws.com", 8883) # For Websocket myMQTTClient.configureEndpoint( "a2on3hwushji1e-ats.iot.us-east-2.amazonaws.com", 443) myMQTTClient.configureIAMCredentials( "ASIA6FC44LEDBU2CLYC7", "/I7X+ieIAv20k0UGxq3hi0CpIdKQw3Sy4kb3+PGC", obtainedSessionToken) # AWS IoT MQTT Shadow Client # For TLS mutual authentication with TLS ALPN extension # myMQTTClient.configureEndpoint("a2on3hwushji1e-ats.iot.us-east-2.amazonaws.com", 443) # myMQTTClient.configureCredentials("../static/certificates/awsDevice/root-CA.crt","../static/certificates/awsDevice/testDevice.private.key", "../static/certificates/awsDevice/testDevice.cert.pem") # For Websocket, we only need to configure the root CA myMQTTClient.configureCredentials( "../static/certificates/awsDevice/root-CA.crt") # Infinite offline Publish queueing myMQTTClient.configureOfflinePublishQueueing(-1) myMQTTClient.configureDrainingFrequency(2) # Draining: 2 Hz myMQTTClient.configureConnectDisconnectTimeout(10) # 10 sec myMQTTClient.configureMQTTOperationTimeout(5) # 5 sec myMQTTClient.connect() print( "done==================================================================" ) # myMQTTClient.publish("sdk/test/Python", "myPayload", 0) # #myMQTTClient.subscribe("sdk/test/Python", 1, customCallback) # # myMQTTClient.unsubscribe("sdk/test/Python") # myMQTTClient.disconnect() def valueGen(): a = random.randint(minRange, maxRange) return a loopCount = 0 while loopCount < frequency: message = {} value = valueGen() message['value'] = value messageJson = json.dumps(message) myMQTTClient.publish(topic, messageJson, 1) print('Published topic %s: %s\n' % (topic, messageJson)) loopCount += 1 time.sleep(timeInterval)
# 認証情報取得 clientId = mqtt_dict['CLIENT_ID'] endPoint = mqtt_dict['ENDPOINT'] port = mqtt_dict['PORT'] # Cognito経由の認証では、Websocket SigV4 しか使用できない rootCA = mqtt_dict['ROOT_CA'] accessId = mqtt_dict['ACCESS_ID'] secretKey = mqtt_dict['SECRET_KEY'] # TOPIC SUB_TOPIC = "#" PUB_TOPIC_1 = clientId + "/test" PUB_TOPIC_2 = clientId + "/alert/fromServer" client = AWSIoTMQTTClient(clientId, useWebsocket=True) # Websocket SigV4を利用 client.configureIAMCredentials(accessId, secretKey) client.configureCredentials(rootCA) # ルート証明書の設定が必要 client.configureEndpoint(endPoint, port) client.configureAutoReconnectBackoffTime(1, 32, 20) client.configureOfflinePublishQueueing(-1) client.configureDrainingFrequency(2) client.configureConnectDisconnectTimeout(10) client.configureMQTTOperationTimeout(5) # Subscribe したときに呼び出される def onSubscribe(client, userdata, message): print("= Subscribe ========================") print("message:{} topic:{}".format(message.payload, message.topic)) print("topic: " + message.topic) print("payload: " + str(message.payload.decode('utf-8')))
class SimonGame: def __init__(self, deviceId): self.deviceId = deviceId self.gamerunning = False self.currentGame = None self.accesstimer = None self.gameMQTTClient = None self.requestRemoteAccess() def startGame(self, client, userdata, gamedata): if self.gamerunning: return self.gamerunning = True print("start game") #print(gamedata.payload.decode("utf-8")) self.currentGame = json.loads(gamedata.payload.decode("utf-8")) print(self.currentGame) self.gametimer = Timer(45, self.submitGameResults) self.gametimer.start() self.playSound() def downloadSoundClip(self, key): print("download sound clip") r = requests.get(STATICFILES + "/music/" + key, stream=True) if r.status_code == 200: with open("/tmp/" + key, "wb") as f: r.raw.decode_content = True shutil.copyfileobj(r.raw, f) def playSound(self): soundclip = self.currentGame["name"] if self.currentGame["simonsays"]: soundclip += "_simon.mp3" else: soundclip += ".mp3" if not os.path.isfile('/tmp/' + soundclip): print("Need to download file: " + soundclip) self.downloadSoundClip(soundclip) try: mixer.init() mixer.music.load('/tmp/' + soundclip) mixer.music.play() except Exception as e: msg = "Test failed: " + str(e) print msg def submitGameResults(self): self.gamerunning = False if self.gametimer is not None: self.gametimer.cancel() print("Submit Game Results") # Join the global MQTT Simon Game Service def requestRemoteAccess(self): if self.accesstimer is not None: self.accesstimer.cancel() if self.gameMQTTClient is not None: self.gameMQTTClient.disconnect() print("Request Access") req = requests.get(APISERVER + '/prod/activate', {"deviceId": self.deviceId}, headers={"x-api-key": APIKEY}) cred = req.json() self.gameMQTTClient = AWSIoTMQTTClient(self.deviceId, useWebsocket=True) self.gameMQTTClient.configureCredentials("./caroot.pem") self.gameMQTTClient.configureEndpoint(cred['iotEndpoint'], 443) self.gameMQTTClient.configureIAMCredentials(cred["accessKey"], cred["secretKey"], cred["sessionToken"]) if self.gameMQTTClient.connect(): print("connected to global MQTT service") if self.gameMQTTClient.subscribe("simongame", 0, self.startGame): print("subscribed to simon game channel") self.accesstimer = Timer(60 * 45, self.requestRemoteAccess) def getCurrentGame(self): return self.currentGame
# For Websocket connection myMQTTClient = AWSIoTMQTTClient("myClientID", useWebsocket=True) # Configurations # For TLS mutual authentication # For Websocket myMQTTClient.configureEndpoint("a1zetnmz2w4vck.iot.us-east-2.amazonaws.com", 443) # For TLS mutual authentication with TLS ALPN extension # myMQTTClient.configureEndpoint("YOUR.ENDPOINT", 443) # For Websocket, we only need to configure the root CA myMQTTClient.configureCredentials("./certificate/aws-iot-rootCA.crt") # AWS IoT MQTT Client # myMQTTClient.configureIAMCredentials(obtainedAccessKeyID, obtainedSecretAccessKey, obtainedSessionToken) # https://console.aws.amazon.com/iam/ --> users --> create access key myMQTTClient.configureIAMCredentials( "AKIAIMPUZ4N6PLLCB2VA", "sXWou67p1ZJSKMua3kaOZ7r2BThOonLTkKNA5xQu", "") myMQTTClient.configureOfflinePublishQueueing( -1) # Infinite offline Publish queueing myMQTTClient.configureDrainingFrequency(2) # Draining: 2 Hz myMQTTClient.configureConnectDisconnectTimeout(10) # 10 sec myMQTTClient.configureMQTTOperationTimeout(5) # 5 sec def customCallback(client, userdata, message): print("Received a new message: ") print(client) print(userdata) print("from topic: ") print(message.topic) print(message.payload)
message['message'] = json.dumps({"source":device_name, "data":private_data}) message['sequence'] = pri_loopCount messageJson = json.dumps(message) myAWSIoTMQTTClient.publish(private_topic, messageJson, 1) pri_loopCount += 1 time.sleep(2) except: sys.exit() if __name__ == '__main__': # Init AWSIoTMQTTClient myAWSIoTMQTTClient = None myAWSIoTMQTTClient = AWSIoTMQTTClient(device_name, useWebsocket=True) myAWSIoTMQTTClient.configureEndpoint(endpoint, port) myAWSIoTMQTTClient.configureCredentials(server_root_ca_file) myAWSIoTMQTTClient.configureIAMCredentials(access_key_id, secret_access_key) # AWSIoTMQTTClient connection configuration myAWSIoTMQTTClient.configureAutoReconnectBackoffTime(1, 32, 20) myAWSIoTMQTTClient.configureOfflinePublishQueueing(-1) # Infinite offline Publish queueing myAWSIoTMQTTClient.configureDrainingFrequency(2) # Draining: 2 Hz myAWSIoTMQTTClient.configureConnectDisconnectTimeout(10) # 10 sec myAWSIoTMQTTClient.configureMQTTOperationTimeout(5) # 5 sec # Connect and subscribe to AWS IoT myAWSIoTMQTTClient.connect() myAWSIoTMQTTClient.subscribe(private_topic, 1, customCallback) time.sleep(2) pub_msg()
class AWSIoTOperation: ''' AWS IoT Core Error Code and Error Message 400: Bad Request - .Invalid JSON .Missing required node: state .State node must be an object .Desired node must be an object .Reported node must be an object .Invalid version .Invalid clientToken .JSON contains too many levels of nesting; maximum is 6 .State contains an invalid node 401: Unauthorized 403: Forbidden 404: Not Found 409: Conflict 410: Limit Exceeded 413: Payload Too Large - The payload exceeds the maximum size allowed 415: Unsupported Media Type - Unsupported documented encoding; supported encoding is UTF-8 422: Failed to Process Request 429: Too Many Requests - The Device Shadow service will generate this error message when there are more than 10 in-flight requests 500: Internal Server Error 503: Service Unavailable ''' def __init__(self, setting=None): self.setting = setting self.fleet_indexing = False if 'fleet_indexing' in self.setting: if self.setting['fleet_indexing'] == 'true': self.fleet_indexing = True # login by cli for update "~/.aws/credentials" if os.path.exists("~/.aws/credentials") == False: os.system("mkdir -p ~/.aws") os.system("echo \"{}\" > ~/.aws/credentials".format("""[default] aws_access_key_id={} aws_secret_access_key={}""".format(self.setting['access_key_id'], self.setting['secret_access_key']))) # os.system("AWS_ACCESS_KEY_ID={} AWS_SECRET_ACCESS_KEY={} aws ecr get-login --no-include-email --region {}".format( # self.setting['access_key_id'], # self.setting['secret_access_key'], # self.setting['region_name'])) self.iot = boto3.client( 'iot', region_name=self.setting['region_name'], aws_access_key_id=self.setting['access_key_id'], aws_secret_access_key=self.setting['secret_access_key']) self.shadow = boto3.client('iot-data', region_name=self.setting['region_name']) self.account_id = boto3.client('sts').get_caller_identity()['Account'] self.things_content = [] self.myAWSIoTMQTTClient = None def search_devices(self): if self.fleet_indexing == True: response = self.iot.search_index(indexName='AWS_Things', queryString='thingName: *', maxResults=250, queryVersion='2017-09-30') else: response = self.iot.list_things() devices = [] for device in response['things']: new_dev = { 'name': device['thingName'], 'desired': {}, 'reported': {}, 'timestamp': 0, 'connected': False, } if 'connectivity' in device: new_dev['connected'] = device['connectivity']['connected'] new_dev['timestamp'] = device['connectivity']['timestamp'] if 'shadow' not in device: devices.append(new_dev) continue shadow = json.loads(device['shadow']) if 'desired' in shadow: new_dev['desired'] = shadow['desired'] if 'reported' in shadow: new_dev['reported'] = shadow['reported'] devices.append(new_dev) self.things_content = devices return self.things_content def search_device(self, name): stream_body = self.shadow.get_thing_shadow(thingName=name)["payload"] shadows_data = json.loads(stream_body.read()) response = { 'things': [ { 'thingName': name, 'connectivity': { 'connected': False }, 'shadow': json.dumps(shadows_data['state']), }, ] } if self.fleet_indexing == True: index = self.iot.search_index(indexName='AWS_Things', queryString='thingName: ' + name, maxResults=250, queryVersion='2017-09-30') if len(index) > 0: response['things'][0]['connectivity']['connected'] = index[ 'things'][0]['connectivity']['connected'] response['things'][0]['connectivity']['timestamp'] = index[ 'things'][0]['connectivity']['timestamp'] devices = [] for device in response['things']: new_dev = { 'name': device['thingName'], 'desired': {}, 'reported': {}, 'timestamp': 0, 'connected': device['connectivity']['connected'], } if 'shadow' not in device: devices.append(new_dev) continue shadow = json.loads(device['shadow']) if 'desired' in shadow: new_dev['desired'] = shadow['desired'] if 'reported' in shadow: new_dev['reported'] = shadow['reported'] if 'timestamp' in device['connectivity']: new_dev['timestamp'] = device['connectivity']['timestamp'] devices.append(new_dev) return devices def get_properties(self, name): for device in self.things_content: if device['name'] == name: return { 'desired': device['desired'], 'reported': device['reported'] } return {'desired': {}, 'reported': {}} def desired(self, device_name, desired_payload): desired_dict = json.loads(desired_payload) data = {"state": {"desired": desired_dict}} response = self.shadow.update_thing_shadow( thingName=device_name, payload=json.dumps(data).encode("utf-8")) return response['ResponseMetadata']['HTTPStatusCode'] def message_callback(self, client, userdata, message): print(message.topic) print(message.payload.decode('utf-8')) self.callback(message.topic, message.payload.decode('utf-8')) def unsubscribe_messages(self, topic): if self.myAWSIoTMQTTClient == None: return self.myAWSIoTMQTTClient.unsubscribe(topic) self.myAWSIoTMQTTClient.disconnect() def subscribe_messages(self, callback, topic='#', second=-1): self.callback = callback self.myAWSIoTMQTTClient = None self.myAWSIoTMQTTClient = AWSIoTMQTTClient('', useWebsocket=True) self.myAWSIoTMQTTClient.configureIAMCredentials( self.setting['access_key_id'], self.setting['secret_access_key']) self.myAWSIoTMQTTClient.configureEndpoint(self.setting['host'], 443) self.myAWSIoTMQTTClient.configureCredentials( self.setting['root_ca_path']) if self.myAWSIoTMQTTClient.connect() == False: print('connect failed') self.myAWSIoTMQTTClient = None return print('connect:ok, subscribe topic[%s] %d sec\n' % (topic, second)) self.myAWSIoTMQTTClient.subscribe(topic, 1, self.message_callback) if second <= 0: return time.sleep(second) self.myAWSIoTMQTTClient.unsubscribe(topic) self.myAWSIoTMQTTClient.disconnect() self.myAWSIoTMQTTClient = None def open_tunnel(self, device_id, service, port): p = subprocess.Popen([ 'aws', 'iotsecuretunneling', 'open-tunnel', '--destination-config', 'thingName={},services={}'.format(device_id, service), '--timeout-config', 'maxLifetimeTimeoutMinutes=30', '--region', self.setting['region_name'] ], stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE) output, err = p.communicate() rc = p.returncode if rc != 0: return err token = json.loads(output)['sourceAccessToken'] # setup tunnel conf os.system("mkdir -p /data") os.system("echo \"{}\" > /data/.aws_tunnel.ini".format("""region = {} source-listen-port = {} access-token = {}""".format(self.setting['region_name'], port, token))) # start tunnel service # os.system("docker kill aws-tunnel 2> /dev/null") # os.system("docker rm -f aws-tunnel 2> /dev/null") # os.system( # 'docker run -d --network host -v /tmp/:/tmp/ --name aws-tunnel bibbylong/aws-localproxy-cli:1.0.1-amd64 sh -c "localproxy --config /tmp/.aws_tunnel.ini"') return '' def command(self, device_id, name, payload, retry_time=10): job_id = "{}_{}".format( device_id, datetime.datetime.now().strftime('%Y%m%d%H%M%S%f')) status, response = self.create_jobs([device_id], name, payload, job_id) if status < 200 or status > 299: return status, {'error': 'create command failed'} for i in range(retry_time): try: job_info = self.get_job_exec_status(device_id, job_id) if job_info['status'] != 'IN_PROGRESS' and job_info[ 'status'] != 'QUEUED': break time.sleep(1) except: time.sleep(1) if job_info['status'] == 'IN_PROGRESS' or job_info[ 'status'] == 'QUEUED': return 400, {'error': 'command panding'} elif job_info['status'] == 'SUCCEEDED': try: json_object = json.loads( job_info['statusDetails']['detailsMap']['data']) return 200, json_object except ValueError as e: return 200, { 'data': job_info['statusDetails']['detailsMap']['data'] } else: return 400, {'error': 'process command failed'} def get_shadow(self, device_id): response = self.shadow.get_thing_shadow(thingName=device_id) status = response['ResponseMetadata']['HTTPStatusCode'] result = json.loads(response['payload'].read().decode('utf-8')) result.pop('metadata', None) return status, result def update_shadow(self, device_id, data): # data format example: # data = {'state': {'desired': {'general': {'description': 'new name'}}}} try: response = self.shadow.update_thing_shadow( thingName=device_id, payload=json.dumps(data).encode('utf-8')) status = response['ResponseMetadata']['HTTPStatusCode'] result = json.loads(response['payload'].read().decode('utf-8')) except botocore.exceptions.ClientError as err: status = err.response['ResponseMetadata']['HTTPStatusCode'] result = err.response return status, result def get_application_list(self, device_id): status, shadow = self.get_shadow(device_id) list = [] if 'state' in shadow and 'reported' in shadow['state']: reported = shadow['state']['reported'] if 'applications' in reported and 'list' in reported[ 'applications']: list = reported['applications']['list'] return status, list def install_application(self, device_id, app_url): params = json.dumps({'url': app_url}) status, response = self.create_jobs( [device_id], 'thingspro-applications-installation', params, datetime.datetime.now().strftime('%Y%m%d%H%M%S%f')) return status, response def application_control(self, device_id, app_name, action): if action in ['start', 'stop', 'restart']: params = json.dumps({'appName': app_name, 'command': action}) status, response = self.create_jobs( [device_id], 'thingspro-applications-control', params, datetime.datetime.now().strftime('%Y%m%d%H%M%S%f')) return status, response else: return 400, None def create_jobs(self, device_id_list, method, params, job_id): body = json.dumps({'name': method, 'payload': params}) target_list = [] for device_id in device_id_list: target_string = 'arn:aws:iot:%s:%s:thing/%s' % ( self.setting['region_name'], self.account_id, device_id) target_list.append(target_string) try: response = self.iot.create_job(jobId=job_id, targets=target_list, document=body, description='create a new job', targetSelection='SNAPSHOT') status = response['ResponseMetadata']['HTTPStatusCode'] except botocore.exceptions.ClientError as err: print(err) status = err.response['ResponseMetadata']['HTTPStatusCode'] response = err.response return status, response def reboot(self, device_id_list): status, response = self.create_jobs( device_id_list, 'system-reboot', '{}', datetime.datetime.now().strftime('%Y%m%d%H%M%S%f')) return status, response def get_all_jobs(self, count): if count > 250: count = 250 response = self.iot.list_jobs(maxResults=count) return response['jobs'] def get_device_jobs(self, device_id, count=250): if count > 250: count = 250 response = self.iot.list_job_executions_for_thing(thingName=device_id, maxResults=count) return response['executionSummaries'] def get_job(self, job_id): response = self.iot.describe_job(jobId=job_id) return response['job'] def get_job_exec_status(self, device_id, job_id): response = self.iot.describe_job_execution( jobId=job_id, thingName=device_id, ) return response['execution'] def get_job_payload(self, job_id): response = self.iot.get_job_document(jobId=job_id) return response['document']
class AwsIotMessageHubClient(AbstractMessageHubClient): def __init__(self, host, port, access_key, secret_key, cert_path, client_id, osc_client=None): """ :param str host: :param int port: :param str cert_path: The path to the aws root ca file that allows this client access to the Aws Iot service. :param str client_id: A string (name) that identifies this client within the Aws Iot message broker (this should be unique per client). :param str access_key: The AWS access key for the IoT platform. :param str secret_key: The AWS secret key for the IoT platform. :param OscMessageHubClient osc_client: An OscMessageHubClient object that is optional in case it is needed for a message callback. """ super(AwsIotMessageHubClient, self).__init__(host, port) self.cert_path = cert_path self.client_id = client_id self.osc_client = osc_client self._access_key = access_key self._secret_key = secret_key def connect(self): try: self._client = AWSIoTMQTTClient(self.client_id, useWebsocket=True) self._client.configureEndpoint(self.host, self.port) self._client.configureIAMCredentials(self._access_key, self._secret_key) self._client.configureCredentials(self.cert_path) self._client.configureAutoReconnectBackoffTime(1, 32, 20) self._client.configureOfflinePublishQueueing(-1) self._client.configureDrainingFrequency(2) self._client.configureConnectDisconnectTimeout(10) self._client.configureMQTTOperationTimeout(5) self._client.connect() except (OSError, ValueError, AWSIoTExceptions.connectTimeoutException) as err: raise MessageHubConnectionError(err) from None def disconnect(self): if not self._client.disconnect(): raise MessageHubConnectionError( "AwsIotPythonSDK disconnect error!") def publish(self, channel, message): if not self._client.publish(channel, message, 1): raise MessageHubSubscribeError("AwsIotPythonSDK publish error!") def subscribe(self, channels): for channel in channels: if not self._client.subscribe(channel, 1, self._message_callback): raise MessageHubSubscribeError( "AwsIotPythonSDK subscribe error!") def _message_callback(self, client, user_data, message): if self.osc_client is not None: self.osc_client.publish(message.topic, message.payload)
headers={'Authorization': op_auth}) creds = json.loads(r.data.decode())['data'] # print(json.dumps(creds, indent=2)) print('fetched credentials') client = AWSIoTMQTTClient(creds['clientId'], useWebsocket=True) print('created client') client.configureEndpoint(creds['atsEndpoint'], 443) print('configured endpoint') client.configureCredentials('./AmazonRootCA1.pem') print('configured root CA') client.configureIAMCredentials(creds['accessKeyId'], creds['secretAccessKey'], creds['sessionToken']) print('configured IAM credentials') client.connect() print('connected') for topic in creds['subscribeTopics']: client.subscribe(topic, 1, messageHandler) print('subscribed', topic) r = sess.request('POST', '%s/orgs/%s/acus/%s/refreshShadow' % (api_base, org_id, acu_id), headers={'Authorization': op_auth}) print('requested shadow refresh')
def main(): logger = logging.getLogger("AWSIoTPythonSDK.core") logger.setLevel(logging.DEBUG) stream_handler = logging.StreamHandler() formatter = logging.Formatter( "%(asctime)s - %(name)s - %(levelname)s - %(message)s" ) stream_handler.setFormatter(formatter) logger.addHandler(stream_handler) args = parse_args() if args.region: region_name = args.region else: region_name = get_region() if args.domain: domain_name = args.domain else: domain_name = "prod" if args.cp_endpoint_url: cp_endpoint_url = args.cp_endpoint_url else: cp_endpoint_url = get_cp_endpoint_url(domain=domain_name, region=region_name) session = boto3.session.Session(region_name=region_name) if args.name: client_id = args.name else: client_id = ( get_client_id() ) # This will set the client-id based on the ec2 instance id if not client_id: logging.info("Failed to determine client_id, quitting") exit(1) logging.info( "Running agent with domain: {}, region: {}, clientId: {}, cp_endpoint_url: {}".format( domain_name, region_name, client_id, cp_endpoint_url ) ) ca_cert_file = get_root_ca() if args.mqtt_endpoint: mqtt_endpoint = args.mqtt_endpoint else: logging.info("Attempting to retrieve Mqtt endpoint") mqtt_endpoint = get_mqtt_endpoint(session, cp_endpoint_url) logging.info("Using Mqtt endpoint: {}".format(mqtt_endpoint)) iot_client = AWSIoTMQTTClient(client_id, useWebsocket=True) iot_client.configureEndpoint(mqtt_endpoint, 443, region_name) credentials = session.get_credentials() iot_client.configureCredentials(ca_cert_file.name) iot_client.configureIAMCredentials( credentials.access_key, credentials.secret_key, credentials.token ) # AWSIoTMQTTClient connection configuration iot_client.configureAutoReconnectBackoffTime(1, 32, 20) iot_client.configureOfflinePublishQueueing(-1) # Infinite offline Publish queueing iot_client.configureDrainingFrequency(2) # Draining: 2 Hz iot_client.configureConnectDisconnectTimeout(30) iot_client.configureMQTTOperationTimeout(20) # 5 sec # Connect and subscribe to AWS IoT iot_client.connect() sleep(2) topic = "$aws/things/{}/defender/metrics/{}".format(client_id, "json") # Subscribe to the accepted/rejected topics to indicate status of published metrics reports # topic=subscribe_to_topic, callback=callback, QoS=1, iot_client.subscribe( topic="{}/accepted".format(topic), callback=ack_callback, QoS=1 ) iot_client.subscribe( topic="{}/rejected".format(topic), callback=ack_callback, QoS=1 ) start_metrics_collection( region_name=region_name, cp_endpoint_url=cp_endpoint_url, client_id=client_id, iot_client=iot_client, topic=topic, sample_rate=300, ) ca_cert_file.close()
temporaryIdentityId = cognitoIdentityClient.get_id(IdentityPoolId=identityPoolID) identityID = temporaryIdentityId["IdentityId"] temporaryCredentials = cognitoIdentityClient.get_credentials_for_identity(IdentityId=identityID) AccessKeyId = temporaryCredentials["Credentials"]["AccessKeyId"] SecretKey = temporaryCredentials["Credentials"]["SecretKey"] SessionToken = temporaryCredentials["Credentials"]["SessionToken"] # Init AWSIoTMQTTClient myAWSIoTMQTTClient = AWSIoTMQTTClient(clientId, useWebsocket=True) # AWSIoTMQTTClient configuration myAWSIoTMQTTClient.configureEndpoint(host, 443) myAWSIoTMQTTClient.configureCredentials(rootCAPath) myAWSIoTMQTTClient.configureIAMCredentials(AccessKeyId, SecretKey, SessionToken) myAWSIoTMQTTClient.configureAutoReconnectBackoffTime(1, 32, 20) myAWSIoTMQTTClient.configureOfflinePublishQueueing(-1) # Infinite offline Publish queueing myAWSIoTMQTTClient.configureDrainingFrequency(2) # Draining: 2 Hz myAWSIoTMQTTClient.configureConnectDisconnectTimeout(10) # 10 sec myAWSIoTMQTTClient.configureMQTTOperationTimeout(5) # 5 sec # Connect and subscribe to AWS IoT myAWSIoTMQTTClient.connect() myAWSIoTMQTTClient.subscribe(topic, 1, customCallback) time.sleep(2) # Publish to the same topic in a loop forever loopCount = 0 while True: myAWSIoTMQTTClient.publish(topic, "New Message " + str(loopCount), 1)
# Change Repoted Value def report_status(name, val): obj = {'state': {'reported': {name: val}}} client.publish(aws_topic_shadow, json.dumps(obj), 0) # GPIO Initialization pig = pigpio.pi() pig.set_mode(17, pigpio.OUTPUT) pig.write(17, 0) print('GPIO Initialization Finished !') # Connect AWS IoT Core client = AWSIoTMQTTClient('', useWebsocket=True) client.configureIAMCredentials(aws_iam_key, aws_iam_secret_key) client.configureCredentials(aws_root_ca_path) client.configureEndpoint(aws_endpoint, aws_port) client.connect() #client.subscribe(aws_topic_shadow_delta, 1, callback) client.subscribe(aws_topic_shadow, 1, callback) print('AWS IoT Core Connection & Subscription Established !') try: while True: time.sleep(5) except KeyboardInterrupt: pig.stop()
shadow_client.connect() device_shadow_handler = shadow_client.createShadowHandlerWithName( THING_NAME, True) device_shadow_handler.shadowRegisterDeltaCallback(delta_callback) current_state = {**DEFAULT_STATE, 'door_is_closed': check_door_is_closed()} mqtt_connection = shadow_client.getMQTTConnection() mqtt_connection.subscribe(current_state['request_door_state_topic'], 0, on_request_door_state) device_shadow_handler.shadowUpdate(make_shadow_json(current_state), update_callback, 5) c = AWSIoTMQTTClient() c.configureIAMCredentials() # Main loop is_closed = None while True: time.sleep(1) old_is_closed = is_closed is_closed = check_door_is_closed() if is_closed != old_is_closed: print('Space is occupied!' if is_closed else 'Space is unoccupied!') current_state['door_is_closed'] = is_closed device_shadow_handler.shadowUpdate(make_shadow_json(current_state), update_callback, 5)
temporaryIdentityId = cognitoIdentityClient.get_id(IdentityPoolId=identityPoolID) identityID = temporaryIdentityId["IdentityId"] temporaryCredentials = cognitoIdentityClient.get_credentials_for_identity(IdentityId=identityID) AccessKeyId = temporaryCredentials["Credentials"]["AccessKeyId"] SecretKey = temporaryCredentials["Credentials"]["SecretKey"] SessionToken = temporaryCredentials["Credentials"]["SessionToken"] # Init AWSIoTMQTTClient myAWSIoTMQTTClient = AWSIoTMQTTClient(clientId, useWebsocket=True) # AWSIoTMQTTClient configuration myAWSIoTMQTTClient.configureEndpoint(host, 443) myAWSIoTMQTTClient.configureCredentials(rootCAPath) myAWSIoTMQTTClient.configureIAMCredentials(AccessKeyId, SecretKey, SessionToken) myAWSIoTMQTTClient.configureAutoReconnectBackoffTime(1, 32, 20) myAWSIoTMQTTClient.configureOfflinePublishQueueing(-1) # Infinite offline Publish queueing myAWSIoTMQTTClient.configureDrainingFrequency(2) # Draining: 2 Hz myAWSIoTMQTTClient.configureConnectDisconnectTimeout(10) # 10 sec myAWSIoTMQTTClient.configureMQTTOperationTimeout(5) # 5 sec # Connect and subscribe to AWS IoT myAWSIoTMQTTClient.connect() myAWSIoTMQTTClient.subscribe(topic, 1, customCallback) time.sleep(2) # Publish to the same topic in a loop forever loopCount = 0 while True: myAWSIoTMQTTClient.publish(topic, "New Message " + str(loopCount), 1)
def event_loop(event_queue, ui=None): gs = game_state.GameState() ignore_period = None # for certificate based connection myMQTTClient = AWSIoTMQTTClient("pi", useWebsocket=True) # For Websocket connection # myMQTTClient = AWSIoTMQTTClient("myClientID", useWebsocket=True) # Configurations # For TLS mutual authentication myMQTTClient.configureEndpoint("a1h19cgwtbfelq-ats.iot.us-west-2.amazonaws.com", 443) # For Websocket # myMQTTClient.configureEndpoint("YOUR.ENDPOINT", 443) # For TLS mutual authentication with TLS ALPN extension # myMQTTClient.configureEndpoint("YOUR.ENDPOINT", 443) myMQTTClient.configureIAMCredentials("insert here", "insert here") myMQTTClient.configureCredentials("ca.pem") # For Websocket, we only need to configure the root CA # myMQTTClient.configureCredentials("YOUR/ROOT/CA/PATH") myMQTTClient.configureOfflinePublishQueueing(-1) # Infinite offline Publish queueing myMQTTClient.configureDrainingFrequency(2) # Draining: 2 Hz myMQTTClient.configureConnectDisconnectTimeout(10) # 10 sec myMQTTClient.configureMQTTOperationTimeout(5) # 5 sec myMQTTClient.connect() print('connected') myMQTTClient.subscribe('golf/switchPlayer', 0, functools.partial(aws_switch_player, event_queue)) myMQTTClient.subscribe('golf/ping', 0, functools.partial(aws_ping, event_queue)) myMQTTClient.subscribe('golf/quit', 0, functools.partial(aws_quit, event_queue)) print('subscribed') while True: print('event: event_queue waiting') event = event_queue.get() if event is None: return # Poison pill elif event[0] == EventTypes.IGNORE_PERIOD: print('event:ignore period') ignore_period = event[1] elif event[0] == EventTypes.USB_MOTION0 and (ignore_period is None or event[1] - ignore_period > datetime.timedelta(seconds=4)): print('event:start motion') remaining_time = datetime.timedelta(seconds=3.75) deferred_events = [] while True: try: next_event = event_queue.get(timeout=remaining_time.total_seconds()) if next_event[0] == EventTypes.USB_MOTION0: pass elif next_event[0] != EventTypes.USB_MOTION1 and next_event[0] != EventTypes.PICAM_MOTION: deferred_events.append(event) else: remaining_time -= next_event[1] - event[1] if next_event is None: return # More poison ppill elif remaining_time.total_seconds() < 0 or next_event[0] == EventTypes.PICAM_MOTION: raise queue.Empty() elif next_event[0] == EventTypes.USB_MOTION1: print('event: made shot!') gs.add_shot(event[1], True) myMQTTClient.publish('golf/update', json.dumps(get_message_dict(gs, True)), 0) break except queue.Empty as e: print('event: missed shot! empty queue') gs.add_shot(event[1], False) myMQTTClient.publish('golf/update', json.dumps(get_message_dict(gs, False)), 0) break [event_queue.put(e) for e in deferred_events] if ui is not None: ui.refresh(gs) elif event[0] == EventTypes.SWITCH_PLAYER: player_switched_to, is_new_player = switch_player(gs, event[1]) if ui is not None: ui.refresh(gs, is_new_player, player_switched_to) elif event[0] == EventTypes.RFID_SCAN: uid = event[1] player = gs.get_player_from_uid(uid) if player is None: if gs.get_uid_for_player() == '': print('event: setting id {} for current player'.format(uid)) gs.set_uid_for_player(uid) else: print('event: RFID UID not recognized') else: print('event: switch to {} from rfid'.format(player)) event_queue.put((EventTypes.SWITCH_PLAYER, player)) if event[0] in (EventTypes.SWITCH_PLAYER, EventTypes.PING): myMQTTClient.publish('golf/update', json.dumps(get_message_dict(gs)), 0)