def all(zcli): """ .. _zdm-cmd-device-get-all: List devices ------------ To list all the devices, use this command to see a table with a device for each rows with the device uid, name and the uid of the fleet and workspace containing them. To see all the devices use the command: :: zdm device all """ table = [] devs = zcli.zdm.devices.list() if env.human: for d in devs: table.append([ d.id, d.name, d.fleet_id if d.fleet_id else "<none>", d.workspace_id, d.workspace_name ]) log_table( table, headers=["ID", "Name", "FleeId", "WorkspaceID", "WorkspaceName"]) else: log_json([dev.toJson for dev in devs])
def get(zcli, id): """ .. _zdm-cmd-device-get-device: Get device ---------- To get a single device information, use this command to see the device name and the uid of the fleet and the workspace that contain the device. :: zdm device get uid where :samp:`uid` is the device uid. """ device = zcli.zdm.devices.get(id) if env.human: log_table( [[ device.id, device.name, device.fleet_id, device.workspace_id, device.workspace_name ]], headers=["ID", "Name", "FleetID", "WorkspaceID", "WorkspaceName"]) else: dev = device.toJson dev.update({"workspace_id": device.workspace_id}) log_json(dev)
def create(zcli, fleet_id, name): """ .. _zdm-cmd-device-create: Device creation --------------- To connect a device to the ZDM, create a new device on ZDM to obtain a new device uid. The creation command is: :: zdm device create name where :samp:`name` is the name that of the device Creating a device with this command, will associate it to the default fleet inside the default workspace. To associate the device to another fleet with the optional argument: :option:`--fleet-id uid` To associate the device to another fleet, see the :ref:`update command <zdm-cmd-device-update>` """ dev = zcli.zdm.devices.create(name, fleet_id) if env.human: log_table([[dev.id, dev.name, dev.fleet_id]], headers=["ID", "Name", "fleet_id"]) else: log_json(dev.toJson)
def check(zcli, device_id): """ .. _zdm-cmd-fota-check: Check FOTA status ----------------- To check the status of a FOTA update, to know if the device finished the task or if an error occurred, type the following command: :: zdm fota check device_uid where :samp:`device_uid` is the uid of the device to check. """ fota_exp = zcli.zdm.fota.status_expected(device_id) fota_cur = zcli.zdm.fota.status_current(device_id) schedule_at = fota_exp.version if fota_exp else "<none>" if fota_exp is None and fota_cur is not None: # the job has been scheduled (exp is None) and the device has sent the response (fota_cur not None) status = "done" result = fota_cur.value if fota_cur is not None else "<no result>" result_at = fota_cur.version if fota_cur is not None else "<no result>" elif fota_exp is None and fota_cur is None: # the job has not been scheduled nor a response has been received status = "<none>" result = "<none>" result_at = "<none>" elif fota_exp is not None and fota_cur is not None: if fota_cur.version > fota_exp.version: # fota has been scheduled and the device has sent a response status = "done" result = fota_cur.value if fota_cur is not None else "<no result>" result_at = fota_cur.version if fota_cur is not None else "<no result>" else: status = "pending" result = "<none>" result_at = "<none>" elif fota_exp is not None and fota_cur is None: # the job has been scheduled bu the device has not sent a response status = "pending" result = "<none>" result_at = "<none>" else: status = "<unknown>" result = "<none>" result_at = "<none>" log_table([[ status, schedule_at, result, result_at, ]], headers=["Status", "ScheduleAt", "Result", "ResultAt"])
def list_fleets(zcli, workspace_id): """ List fleets of a workspace """ resp = zcli.zdm.fleets.list(workspace_id) if env.human: log_table([[fleet.id, fleet.name, fleet.workspace_id]], headers=["ID", "Name", "WorkspaceID"]) else: log_json(fleet.toJson)
def check(zcli, name, device_id): """ .. _zdm-cmd-job-check: Check a job status ------------------ To check the status of a scheduled job, type the command: :: zdm job check job uid where :samp:`job` is the job name and :samp:`uid` is the device uid to check """ status_exp = zcli.zdm.jobs.status_expected(name, device_id) status_cur = zcli.zdm.jobs.status_current(name, device_id) schedule_at = status_exp.version if status_exp else "<unknown>" if status_exp is None and status_cur is not None: # the job has been scheduled (exp is None) and the device has sent the response (status_cur not None) status = "done" result = status_cur.value if status_cur is not None else "<no result>" result_at = status_cur.version if status_cur is not None else "<no result>" elif status_exp is None and status_cur is None: # the job has not been scheduled nor a device has not sent a response status = "<none>" result = "<none>" result_at = "<none>" elif status_exp is not None and status_cur is not None: if status_cur.version > status_exp.version: # job has been scheduled and the device has sent a response status = "done" result = status_cur.value if status_cur is not None else "<no result>" result_at = status_cur.version if status_cur is not None else "<no result>" else: status = "pending" result = "<none>" result_at = "<none>" elif status_exp is not None and status_cur is None: # the job has been scheduled bu the device has not sent a response status = "pending" result = "<none>" result_at = "<none>" else: status = "<unknown>" result = "<none>" result_at = "<none>" log_table([[name, status, schedule_at, result, result_at, ]], headers=["Name", "Status", "ScheduleAt", "Result", "ResultAt"])
def all(zcli, workspace_id, status): table = [] alerts = zcli.zdm.alerts.list(workspace_id, status) if env.human: for a in alerts: table.append( [a.name, a.threshold, a.status, a.last_time_scheduled]) log_table(table, headers=["Name", "Threshold", "Status", "LastSchedule"]) else: log_json([a.toJson for a in alerts])
def all(zcli, workspace_id, status): dstream = zcli.zdm.streams.list(workspace_id, "condition", status) if env.human: table = [] for stream in dstream: table.append([ stream.name, stream.status, stream.period, stream.subtype, stream.last_time_scheduled ]) log_table( table, headers=["Name", "Status", "Period (s)", "To", "Last Schedule"]) else: log_json([s.toJson for s in dstream])
def get(zcli, export_id): """ .. _zdm-cmd-workspace-data-export-get: Get export ---------- To get an existing export information use the command: :: zdm workspace data export get export_id where :samp:`export_id` is the uid of the export """ exp = zcli.zdm.exports.get(export_id) log_table([[exp.id, exp.Name, exp.Type, exp.Status, exp.Url]], headers=["ID", "Name", "Type", "Status", "URL"])
def all(zcli, workspace_id, tag, device_id, start, end): """ .. _zdm-cmd-workspace-data-get: Get data -------- To get all the data of a workspace associated to a tag use the command: :: zdm workspace data all uid tag where :samp:`uid` is the uid of the workspace, and :samp:`tag` is the tag of the data to download. To filter result use the options: * :option:`--device-id` * :option:`--start` * :option:`--end` """ tags = zcli.zdm.data.get(workspace_id, tag, device_id=device_id, start=start, end=end) if env.human: if len(tags) > 0: table = [] for tag in tags: table.append([ tag.Tag, tag.Payload, tag.DeviceId, tag.DeviceName, tag.TimestampDevice, tag.TimestampCloud ]) log_table(table, headers=[ "Tag", "Payload", "DeviceId", "DeviceName", "TimestampDevice", "TimestampCloud" ]) else: info("No data present for to tag [{}].".format(tag)) else: log_json([tag.toJson for tag in tags])
def get(zcli, id): """ .. _zdm-cmd-fleet-get-fleet: Get fleet --------- To get a single fleet information, use this command to see its name, the uid of the workspace that contains it and the list of devices inside:: zdm fleet get uid where :samp:`uid` is the fleet uid """ fleet = zcli.zdm.fleets.get(id) if env.human: log_table([[fleet.id, fleet.name, fleet.workspace_id]], headers=["ID", "Name", "WorkspaceID"]) else: log_json(fleet.toJson)
def create(zcli, name, workspaceid): """ .. _zdm-cmd-fleet-create: Fleet creation -------------- To create a new fleet of devices inside a workspace use the command: :: zdm fleet create name workspace_uid where :samp:`name` is the fleet name and :samp:`workspace_id` is the uid of the workspace that will contain the fleet. """ fleet = zcli.zdm.fleets.create(name, workspaceid) if env.human: log_table([[fleet.id, fleet.name, fleet.workspace_id]], headers=["ID", "Name", "WorkspaceID"]) else: log_json(fleet.toJson)
def get(zcli, id): """ .. _zdm-cmd-workspace-get-workspace: Get workspace ------------- To get a single workspace information, use this command: :: zdm workspace get uid where :samp:`uid` is the workspace uid. """ ws = zcli.zdm.workspaces.get(id) if env.human: data = [ws.id, ws.name, ws.description] log_table([data], headers=["ID", "Name", "Description"]) else: log_json(ws.toJson)
def all(zcli, workspace_id, tag, device_id, threshold, status): """ .. _zdm-cmd-workspace-conditions-all: List conditions -------------- To get all the conditions of a device use the command: :: zdm workspace condition all workspace_id tag where :samp:`workspace_id` is the uid of the workspace and `tag` is the tag of the conditions :samp:`device_id` is the uid of the device :samp:`threshold` is the min duration of the conditions in seconds It's also possible to filter results using the options: * :option:`--status` to filter on conditions status [open, closed] * :option:`--device_id` to filter on devices * :option:`--threshold` to indicate the minimum duration of the conditions to return """ conditions = zcli.zdm.conditions.list(workspace_id, tag, device_id, threshold, status) if env.human: table = [] for condition in conditions: table.append([ condition.Uuid, condition.Tag, condition.DeviceId, condition.Start, condition.Finish, condition.Duration ]) log_table( table, headers=["ID", "Tag", "Device", "Start", "Finish", "Duration"]) else: cc = [] for c in conditions: cc.append(c.toJson) log_json(c)
def create(zcli, name, description): """ .. _zdm-cmd-workspace-create: Create workspace ------------------ To create a new workspace on the ZDM use the command: :: zdm workspace create name where :samp:`name` is the name of the new workspace It's possible to insert a description of the workspace adding the option :option:`--description desc` """ wks = zcli.zdm.workspaces.create(name, description) if env.human: log_table([[wks.id, wks.name, wks.description]], headers=["ID", "Name", "Description"]) else: log_json(wks.toJson)
def firmwares(zcli, workspace_id): """ .. _zdm-cmd-workspace-firmware: List firmwares -------------- To have a list of the firmwares uploaded to the ZDM associated to a workspace use the command: :: zdm workspace firmwares uid where :samp:`uid` is the uid of the workspace. """ table = [] firmwares = zcli.zdm.firmwares.list(workspace_id) if env.human: for d in firmwares: table.append([d.id, d.version, d.metadata, d.workspace_id]) log_table(table, headers=["ID", "Version", "Metadata", "WorkspaceID"]) else: log_json([frm.toJson for frm in firmwares])
def all(zcli): """ .. _zdm-cmd-workspace-get-all: List workspaces --------------- To see the list of all workspaces, use the command: :: zdm workspace all The output is a table containing workspaces with ID, name, description """ wks = zcli.zdm.workspaces.list() if env.human: table = [] for ws in wks: table.append([ws.id, ws.name, ws.description]) log_table(table, headers=["ID", "Name", "Description"]) else: log_json([wk.toJson for wk in wks])
def fleets(zcli, workspace_id): """ .. _zdm-cmd-workspace-get-all-fleets: List fleets ------------ Use this command to have the list of fleets inside a workspace: :: zdm workspace fleet all uid where :samp:`uid` is the uid of the workspace. """ fleets = zcli.zdm.fleets.list(workspace_id) if env.human: table = [] for fl in fleets: table.append([fl.id, fl.name, fl.description, fl.workspace_id]) log_table(table, headers=["ID", "Name", "Description", "WorkspaceId"]) else: log_json([fl.toJson for fl in fleets])
def tags(zcli, workspace_id): """ .. _zdm-cmd-workspace-data-tags: List tags --------- When a device publish data to the ZDM it label them with a string called tag. With the following command it's possible to see all the tags that devices associated to the workspace used as data label. :: zdm workspace data tags uid where :samp:`uid` is the uid of the workspace """ tags = zcli.zdm.data.list(workspace_id) if env.human: if len(tags) > 0: log_table([[tags]], headers=["Tags"]) else: info("Empty tags for workspace {}.".format(workspace_id)) else: log_json([tag.toJson for tag in tags])
def do_prepare(zcli, project, device_id, version): status = zcli.zdm.status.get_device_vm_info(device_id) if status is None: fatal( "Fota cannot be prepared. Please connect device '{}' to the ZDM at least one time." .format(device_id)) vm_info = status.value if "vm_target" not in vm_info: fatal( "The target of the virutal machine is missing. Please reconnect the device '{}' to the ZDM." .format(device_id)) vm_target = vm_info['vm_target'] if "vm_uid" not in vm_info: fatal( "The ID of the virtual machine is missing. Please reconnect the device '{}' to the ZDM." .format(device_id)) vm_uid = vm_info['vm_uid'] if "vm_version" in vm_info: vm_version = vm_info['vm_version'] vm_hash_feature = "" target_device = "" vms = _ztc_vm_list() if vms['total'] > 0: for vm in vms['list']: if vm['uid'] == vm_uid: if "ota" not in vm['features']: fatal( "The vm '{}' of device '{}' doesn't support FOTA. Please use a VM with feature OTA enabled." .format(vm_uid, device_id)) else: vm_hash_feature = vm['hash_features'] target_device = vm['dev_type'] else: fatal("No virtual machine found. Please create a virtual machine") device = zcli.zdm.devices.get(device_id) workspace_id = device.workspace_id info("workspace id '{}'".format(workspace_id)) vbo_file = fs.path(env.tmp, 'test_temp_fw.vbo') try: _ztc_compile(project, vm_target, vbo_file) fw_json1 = _ztc_link(vbo_file, vm_uid, '0') fw_json2 = _ztc_link(vbo_file, vm_uid, '1') fw_bin1 = fw_json1['bcbin'] fw_bin2 = fw_json2['bcbin'] except Exception as e: fatal(e) metadata = { "vm_version": vm_version, "vm_feature": vm_hash_feature, "dev_type": target_device } res = zcli.zdm.firmwares.upload(workspace_id, version, [fw_bin1, fw_bin2], metadata) if env.human: log_table([[res.id, res.version, res.metadata]], headers=["ID", "Version", "Metadata"]) else: raw = res.toJson del raw['firmware'] log_json(raw)