def __init__(self,
device_info: DeviceInfo,
project_name: str,
progress: int = 0,
to_finish: int = 0,
notes: str = '') -> None:
self.progress = progress
self.to_finish = to_finish
self.project_name = project_name
self.notes = notes
self.device_info = device_info.toJSON()
def update(self):
last_date = self.__read_sync_file()
current_time = int(time.time())
device_scanner = DeviceScan()
devices = device_scanner.scan()
for device in devices:
device_info = DeviceInfo(device)
mount_path = device_info.get_mount_path()
if device_info.vendor == GarminSync.supported_devices[0][0] and\
device_info.model == GarminSync.supported_devices[0][1]:
if mount_path is not None:
files_to_upload = self.__scan_files(mount_path, last_date)
if files_to_upload == []:
print('Up to date!')
else:
try:
self.__upload_files(files_to_upload)
except Exception:
return
self.__save_sync_file(current_time)
else:
print('Please mount your Garmin device!')
return
print('Garmin device not found!')
def main() -> None:
device_info = DeviceInfo()
if device_info.path:
logging.basicConfig(
level=get_logging_level(device_info.verbosity),
filename=device_info.path,
)
else:
logging.basicConfig(level=get_logging_level(device_info.verbosity))
while True:
try:
server = udp_discover.find_server(device_info.server_name)
logging.info(
'Server found: {0}:{1}.'.format(server.ip, server.port)
)
tcp_connection_manager.TCPConnectionManager(
server.ip, server.port, device_info
)
except tcp_connection_manager.TCPCommunicationEstablishedError:
logging.error('TCPCommunicationEstablishedError!')
except tcp_connection_manager.TCPTimeoutError:
logging.warning('TCP Timeout!')
except udp_discover.ServerNotFoundError:
time.sleep(10)
logging.error('Server not found!')
except tcp_connection_manager.OutdatedVersionError:
logging.critical('Outdated version of server!')
break
except tcp_connection_manager.DisconnectedError:
logging.error('Disconnected from server!')
except IOError as e:
if e.errno == 101: # Network in unreachable
logging.error('Network is unreachable!')
time.sleep(10)
else:
raise
time.sleep(1)
def process_event(msg: paho.mqtt.client.MQTTMessage):
"""Will process the mqtt message based on the use case. Use case is determined by the message topic."""
payload_str = str(msg.payload.decode("utf-8", "ignore"))
print(payload_str)
payload = json.loads(payload_str)
if msg.topic == DEVICE_INFO_TOPIC:
global deviceInfo, meter_feature
deviceInfo = DeviceInfo(payload)
meter_feature = Feature("performanceTest", "2.0.0",
'measure-performance-feature', mqtt_client,
deviceInfo)
meter_feature.register()
print("======== Feature is ready =============")
# elif msg.topic == "command///req//modified":
# handle_measurement_request(cmd)
else:
handle_measurement_request(msg, payload)
def __init__(self):
self.sno_list = DeviceInfo().get_devices()
self.android = AndroidUtils()
def __init__(self, id: str, device_info: DeviceInfo) -> None:
self.device_info = device_info.toJSON()
self.timestamp = timestamp()
self.id = id
def device_info(self):
return DeviceInfo(self.client)
import paho.mqtt.client as mqtt
import time
import json
from commands import DittoCommand
from device_info import DeviceInfo
from downloader import DownloadManager
from executor import ScriptExecutor
from ditto_response import DittoResponse
from agent import Agent
from software_feature_cache import SoftwareFeatureCache
agent = Agent("script", "2.0.0", "script", 'software-updatable-script-agent')
deviceInfo = DeviceInfo()
DEVICE_INFO_TOPIC = "edge/thing/response"
MQTT_TOPIC = [(DEVICE_INFO_TOPIC, 0), ("command///req/#", 0)]
def on_connect(client, userdata, flags, rc):
print("Connected with result code " + str(rc))
# Subscribing to a topic that sends install or download command
client.subscribe(MQTT_TOPIC)
client.publish('edge/thing/request', '', qos=1)
# hint: to register as agent or operation status, use "e".
def on_publish(client, userdata, result):
print("data published: " + str(result))
# The callback when a install or download command is received
# msg is of type MQTTMessage
import threading
from threading import Thread
from globals import Globals
from device_info import DeviceInfo
import json
from heartbeat import HeartBeat
import time
from event import Event
if __name__ == '__main__':
Globals()
device = DeviceInfo(
device_id='10', device_name='workstation 10', notes='I don not have any notes!')
print(device.toJSON())
while(True):
hb = HeartBeat('10',device)
thread = hb.run_in_background()
thread.join()
print(hb.toJSON())
time.sleep(10)