jspruance · alansealy0914 · Aug 13, 2021 · Aug 13, 2021 · Aug 17, 2021 · Aug 19, 2021
diff --git a/.vscode/launch.json b/.vscode/launch.json
@@ -0,0 +1,19 @@
+{
+    "configurations": [
+        {
+            "type": "aws-sam",
+            "request": "direct-invoke",
+            "name": "hexal-serverless-starter:src/hexal-severless-lambda/hexalPut.handler (nodejs14.x)",
+            "invokeTarget": {
+                "target": "code",
+                "projectRoot": "${workspaceFolder}/",
+                "lambdaHandler": "src/hexal-severless-lambda/hexalPut.handler"
+            },
+            "lambda": {
+                "runtime": "nodejs14.x",
+                "payload": {},
+                "environmentVariables": {}
+            }
+        }
+    ]
+}
diff --git a/package-lock.json b/package-lock.json
diff --git a/package.json b/package.json
@@ -6,6 +6,7 @@
     "@fortawesome/fontawesome-svg-core": "^1.2.15",
     "@fortawesome/free-solid-svg-icons": "^5.7.2",
     "@fortawesome/react-fontawesome": "^0.1.4",
+    "aws-iot-device-sdk": "^2.2.11",
     "axios": "^0.18.0",
     "bulma": "^0.7.2",
     "react": "^16.7.0",

diff --git a/public/Courier.png b/public/Courier.png
diff --git a/public/MOTMPost.jpg b/public/MOTMPost.jpg
diff --git a/public/MyPost.png b/public/MyPost.png
diff --git a/public/Picture1.jpg b/public/Picture1.jpg
diff --git a/public/Picture2.jpg b/public/Picture2.jpg
diff --git a/public/TransAtlanticTrucking.jpg b/public/TransAtlanticTrucking.jpg
diff --git a/public/Transparent-Trucking.png b/public/Transparent-Trucking.png
diff --git a/public/flyer/Courier.png b/public/flyer/Courier.png
diff --git a/public/flyer/Transparent-Trucking.png b/public/flyer/Transparent-Trucking.png
diff --git a/public/flyer/fleetowner_38823_tbn_lead_graphic_traffic.png b/public/flyer/fleetowner_38823_tbn_lead_graphic_traffic.png
diff --git a/public/flyer/timeismoney.png b/public/flyer/timeismoney.png
diff --git a/public/flyer/trucking.png b/public/flyer/trucking.png
diff --git a/public/index.html b/public/index.html
@@ -8,7 +8,7 @@
     />
     <meta name="theme-color" content="#000000" />
     <link rel="manifest" href="%PUBLIC_URL%/manifest.json" />
-    <title>Hexal Energy</title>
+    <title>Middle of the Map Trucking</title>
   </head>
   <body style="visibility: hidden;">
     <noscript>You need to enable JavaScript to run this app.</noscript>

diff --git a/public/map-navigation-system.jpg b/public/map-navigation-system.jpg
diff --git a/public/package-tracking.png b/public/package-tracking.png
diff --git a/public/system-tracking.png b/public/system-tracking.png
diff --git a/public/timeismoney.png b/public/timeismoney.png
diff --git a/public/tire-track.png b/public/tire-track.png
diff --git a/public/truck-trailer-tracking-generic.jpg b/public/truck-trailer-tracking-generic.jpg
diff --git a/public/trucking (2).jpg b/public/trucking (2).jpg
diff --git a/public/vehicle-system-tracking.jpg b/public/vehicle-system-tracking.jpg
diff --git a/pubsub.py b/pubsub.py
@@ -0,0 +1,179 @@
+# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+# SPDX-License-Identifier: Apache-2.0.
+
+import argparse
+from awscrt import io, mqtt, auth, http
+from awsiot import mqtt_connection_builder
+import sys
+import threading
+import time
+from uuid import uuid4
+import json
+
+# This sample uses the Message Broker for AWS IoT to send and receive messages
+# through an MQTT connection. On startup, the device connects to the server,
+# subscribes to a topic, and begins publishing messages to that topic.
+# The device should receive those same messages back from the message broker,
+# since it is subscribed to that same topic.
+
+parser = argparse.ArgumentParser(description="Send and receive messages through and MQTT connection.")
+parser.add_argument('--endpoint', required=True, help="Your AWS IoT custom endpoint, not including a port. " +
+                                                      "Ex: \"abcd123456wxyz-ats.iot.us-east-1.amazonaws.com\"")
+parser.add_argument('--port', type=int, help="Specify port. AWS IoT supports 443 and 8883.")
+parser.add_argument('--cert', help="File path to your client certificate, in PEM format.")
+parser.add_argument('--key', help="File path to your private key, in PEM format.")
+parser.add_argument('--root-ca', help="File path to root certificate authority, in PEM format. " +
+                                      "Necessary if MQTT server uses a certificate that's not already in " +
+                                      "your trust store.")
+parser.add_argument('--client-id', default="test-" + str(uuid4()), help="Client ID for MQTT connection.")
+parser.add_argument('--topic', default="test/topic", help="Topic to subscribe to, and publish messages to.")
+parser.add_argument('--message', default="Hello World!", help="Message to publish. " +
+                                                              "Specify empty string to publish nothing.")
+parser.add_argument('--count', default=10, type=int, help="Number of messages to publish/receive before exiting. " +
+                                                          "Specify 0 to run forever.")
+parser.add_argument('--use-websocket', default=False, action='store_true',
+    help="To use a websocket instead of raw mqtt. If you " +
+    "specify this option you must specify a region for signing.")
+parser.add_argument('--signing-region', default='us-east-1', help="If you specify --use-web-socket, this " +
+    "is the region that will be used for computing the Sigv4 signature")
+parser.add_argument('--proxy-host', help="Hostname of proxy to connect to.")
+parser.add_argument('--proxy-port', type=int, default=8080, help="Port of proxy to connect to.")
+parser.add_argument('--verbosity', choices=[x.name for x in io.LogLevel], default=io.LogLevel.NoLogs.name,
+    help='Logging level')
+
+# Using globals to simplify sample code
+args = parser.parse_args()
+
+io.init_logging(getattr(io.LogLevel, args.verbosity), 'stderr')
+
+received_count = 0
+received_all_event = threading.Event()
+
+# Callback when connection is accidentally lost.
+def on_connection_interrupted(connection, error, **kwargs):
+    print("Connection interrupted. error: {}".format(error))
+
+
+# Callback when an interrupted connection is re-established.
+def on_connection_resumed(connection, return_code, session_present, **kwargs):
+    print("Connection resumed. return_code: {} session_present: {}".format(return_code, session_present))
+
+    if return_code == mqtt.ConnectReturnCode.ACCEPTED and not session_present:
+        print("Session did not persist. Resubscribing to existing topics...")
+        resubscribe_future, _ = connection.resubscribe_existing_topics()
+
+        # Cannot synchronously wait for resubscribe result because we're on the connection's event-loop thread,
+        # evaluate result with a callback instead.
+        resubscribe_future.add_done_callback(on_resubscribe_complete)
+
+
+def on_resubscribe_complete(resubscribe_future):
+        resubscribe_results = resubscribe_future.result()
+        print("Resubscribe results: {}".format(resubscribe_results))
+
+        for topic, qos in resubscribe_results['topics']:
+            if qos is None:
+                sys.exit("Server rejected resubscribe to topic: {}".format(topic))
+
+
+# Callback when the subscribed topic receives a message
+def on_message_received(topic, payload, dup, qos, retain, **kwargs):
+    print("Received message from topic '{}': {}".format(topic, payload))
+    global received_count
+    received_count += 1
+    if received_count == args.count:
+        received_all_event.set()
+
+if __name__ == '__main__':
+    # Spin up resources
+    event_loop_group = io.EventLoopGroup(1)
+    host_resolver = io.DefaultHostResolver(event_loop_group)
+    client_bootstrap = io.ClientBootstrap(event_loop_group, host_resolver)
+
+    proxy_options = None
+    if (args.proxy_host):
+        proxy_options = http.HttpProxyOptions(host_name=args.proxy_host, port=args.proxy_port)
+
+    if args.use_websocket == True:
+        credentials_provider = auth.AwsCredentialsProvider.new_default_chain(client_bootstrap)
+        mqtt_connection = mqtt_connection_builder.websockets_with_default_aws_signing(
+            endpoint=args.endpoint,
+            client_bootstrap=client_bootstrap,
+            region=args.signing_region,
+            credentials_provider=credentials_provider,
+            http_proxy_options=proxy_options,
+            ca_filepath=args.root_ca,
+            on_connection_interrupted=on_connection_interrupted,
+            on_connection_resumed=on_connection_resumed,
+            client_id=args.client_id,
+            clean_session=False,
+            keep_alive_secs=30)
+
+    else:
+        mqtt_connection = mqtt_connection_builder.mtls_from_path(
+            endpoint=args.endpoint,
+            port=args.port,
+            cert_filepath=args.cert,
+            pri_key_filepath=args.key,
+            client_bootstrap=client_bootstrap,
+            ca_filepath=args.root_ca,
+            on_connection_interrupted=on_connection_interrupted,
+            on_connection_resumed=on_connection_resumed,
+            client_id=args.client_id,
+            clean_session=False,
+            keep_alive_secs=30,
+            http_proxy_options=proxy_options)
+
+    print("Connecting to {} with client ID '{}'...".format(
+        args.endpoint, args.client_id))
+
+    connect_future = mqtt_connection.connect()
+
+    # Future.result() waits until a result is available
+    connect_future.result()
+    print("Connected!")
+
+    # Subscribe
+    print("Subscribing to topic '{}'...".format(args.topic))
+    subscribe_future, packet_id = mqtt_connection.subscribe(
+        topic=args.topic,
+        qos=mqtt.QoS.AT_LEAST_ONCE,
+        callback=on_message_received)
+
+    subscribe_result = subscribe_future.result()
+    print("Subscribed with {}".format(str(subscribe_result['qos'])))
+
+    # Publish message to server desired number of times.
+    # This step is skipped if message is blank.
+    # This step loops forever if count was set to 0.
+    if args.message:
+        if args.count == 0:
+            print ("Sending messages until program killed")
+        else:
+            print ("Sending {} message(s)".format(args.count))
+
+        publish_count = 1
+        while (publish_count <= args.count) or (args.count == 0):
+            message = "{} [{}]".format(args.message, publish_count)
+            print("Publishing message to topic '{}': {}".format(args.topic, message))
+            message_json = json.dumps(message)
+            mqtt_connection.publish(
+                topic=args.topic,
+                payload=message_json,
+                qos=mqtt.QoS.AT_LEAST_ONCE)
+            time.sleep(1)
+            publish_count += 1
+
+    # Wait for all messages to be received.
+    # This waits forever if count was set to 0.
+    if args.count != 0 and not received_all_event.is_set():
+        print("Waiting for all messages to be received...")
+
+    received_all_event.wait()
+    print("{} message(s) received.".format(received_count))
+
+    # Disconnect
+    print("Disconnecting...")
+    disconnect_future = mqtt_connection.disconnect()
+    disconnect_future.result()
+    print("Disconnected!")