This application for letters patent disclosure document describes inventive aspects that include various novel innovations (hereinafter “disclosure”) and contains material that is subject to copyright, mask work, and/or other intellectual property protection. The respective owners of such intellectual property have no objection to the facsimile reproduction of the disclosure by anyone as it appears in published Patent Office file/records, but otherwise reserve all rights.
Applicant hereby claims benefit to priority under 35 USC §120 as a continuation-in-part of: U.S. patent application Ser. No. 14/793,679, filed Jul. 7, 2015, entitled REMOTE EMBEDDED DEVICE UPDATE PLATFORM APPARATUSES, METHODS AND SYSTEMS,” (attorney docket no. SYMTELECA0003US); and which in turn claims benefit to priority under 35 USC §119 as a non-provisional conversion of: U.S. provisional patent application Ser. No. 62/021,672, filed Jul. 7, 2014, entitled “Remote Embedded Device Update Platform Apparatuses, Methods and Systems,” (attorney docket no. STC-1003PV).
Applicant hereby claims benefit to priority under 35 USC 119, 365 as a national stage entry and continuation-in-part of: Patent Cooperation Treaty application, serial no. PCT/US15/39457, filed Jul. 7, 2015, entitled REMOTE EMBEDDED DEVICE UPDATE PLATFORM APPARATUSES, METHODS AND SYSTEMS,” (attorney docket no. SYMTELECA0003PC); and which in turn claims benefit to priority under 35 USC §119 as a non-provisional conversion of: U.S. provisional patent application Ser. No. 62/021,672, filed Jul. 7, 2014, entitled “Remote Embedded Device Update Platform Apparatuses, Methods and Systems,” (attorney docket no. STC-1003PV).
The entire contents of the aforementioned applications are herein expressly incorporated by reference.
The present innovations generally address embedded software, and more particularly, include Remote Embedded Device Update Platform Apparatuses, Methods and Systems.
However, in order to develop a reader's understanding of the innovations, disclosures have been compiled into a single description to illustrate and clarify how aspects of these innovations operate independently, interoperate as between individual innovations, and/or cooperate collectively. The application goes on to further describe the interrelations and synergies as between the various innovations; all of which is to further compliance with 35 U.S.C. 112.
Many devices have embedded software, such as cars and appliances. Sometimes, the embedded software may be upgraded by a technician who physically connects to the device and runs special updating software.
Appendices and/or drawings illustrating various, non-limiting, example, innovative aspects of the Remote Embedded Device Update Platform Apparatuses, Methods and Systems (hereinafter “REDUP”) disclosure, include:
Generally, the leading number of each citation number within the drawings indicates the figure in which that citation number is introduced and/or detailed. As such, a detailed discussion of citation number 101 would be found and/or introduced in
The Remote Embedded Device Update Platform Apparatuses, Methods and Systems (hereinafter “REDUP”) transforms telemetry inputs, via REDUP components (e.g., DSD, UDA, PDA, UTA, PSC, UPC, ELA, AC, etc. components), into remote embedded updates outputs. The REDUP components, in various embodiments, implement advantageous features as set forth below.
REDUP helps manage and update embedded devices that traditionally have been inaccessible and impracticable to update. Via its update and communication mechanisms, REDUP may also obtain data, both real-time and deferred, and perform analysis as feedback to determine existing problems, but also to diagnose potential and future problems. This feedback and analytics component may then be used to create updates that may be sent to the affected devices to fix the problem, in many instances, before any problem manifests itself. Also, REDUP allows for the determination of what other devices may similarly be affected and similarly provide updates to those, as yet, unaffected devices. In turn, all those other devices may also be examined, and each, may also contribute to the refinement of embedded devices in aggregate. Also, REDUP may obtain and use telemetry and device usage data streams, by first tagging the information with device features, model, serial number, subsystem and other metadata, and then storing that information for post processing analytics.
A connected device (e.g., a vehicle, a smartphone, an appliance, a smart lock, and/or the like device that is capable of network connectivity) is configured to log specified events. For example, logged events may include software and configuration updates events, system fault and performance events, system service usage notifications, telematic data, and/or the like. These events may be logged by the device's software system or by individual device components (e.g., peripheral units or electronic control units (ECUs)) and may be securely delivered in a structured data format to the cloud platform for storage in a big data storage repository and/or databases of individual analytics applications. In one implementation, events data may be structured based on a graph format that facilitates flexible and configurable logging without having to tightly couple the data model to the back end system.
Various analytics applications may utilize subsets of logged events data to conduct analytics. Such analytics may also utilize third party data (e.g., information regarding vehicle components obtained from manufacturers, environmental data, information regarding users and/or user preferences) in combination with the logged events data. For example, predictive analytics may be utilized to provide answers to a range of questions, from small-scale questions around individual devices to large-scale questions at a product level. In some implementations, analytics results may be utilized to create updates for the connected device.
The device may be notified (e.g., on start up, periodically, upon update availability) when updates are available. For example, updates may include software updates, firmware updates, application updates, and/or the like. In one implementation, a notification may be sent to the device when updates are available for one or more segments associated with the device. The device may download updates (e.g., in the form of update packages) via network (e.g., via LTE, via WiFi) from the cloud platform server and install them using an update client. A rules engine may be utilized to configure updates for specific segments and to ensure that dependencies and restrictions associated with update package components (e.g., modules) are satisfied.
The update server may determine segments associated with the device and whether any updates are available for device components using a device segment determining (DSD) component 325. See
The update server may send an update notification 329 to the device. For example, the update server may send the update notification to notify the device regarding any applicable updates. In one implementation, the update notification may include the device's identifier (e.g., a device token used to identify the device anonymously), a list of updates available for the device, description of each update, an update package identifier associated with each update, priority associated with each update, and/or the like. For example, the update server may provide the following example update notification, substantially in the form of a HTTP(S) POST message including XML-formatted data, as provided below:
The device may determine available updates and administer downloading of updates using an update download administering (UDA) component 333. See
The device may send an update download request 337 to the update server. For example, the device may send the update download request to request update download from the update server. In one implementation, the update download request may include the device's identifier, an update identifier, an update package identifier, and/or the like. For example, the device may provide the following example update download request, substantially in the form of a HTTP(S) POST message including XML-formatted data, as provided below:
The update server may facilitate sending the requested update package to the device using a package download administering (PDA) component 341. See
The update server may send an update download response 345 to the device. For example, the update server may send the requested update package to the device. In one implementation, the package file may be sent to the device. For example, the package file may include package parameters (e.g., package name, package version, package priority, package segment identifier, package rules, package checksum), software update modules (SUMs) and associated rules, and/or the like.
Installation confirmation output 349 may be provided to a user 310. For example, installation confirmation output may be provided in cases where a user approval should be obtained before installing an update (e.g., an update to an app downloaded by the user to the device from an app store). In another example, installation confirmation may be skipped if an update is mandatory and/or critical. In one implementation, a confirmation dialog may be displayed to the user (e.g., on the screen of the vehicle's infotainment system). In another implementation an audio notification may be played back to the user (e.g., a voice recording or a beep to alert the user that updates are awaiting installation confirmation). The user may provide installation confirmation input 353 to the device. For example, the user may confirm that the update should be installed (e.g., using a touchscreen or a button of the vehicle's infotainment system, using a voice command) or indicate that the update should be installed at a later time.
The device may administer update installation using an update installation administering (UIA) component 357. See
Segments for the device may be determined at 405. A segment may be configured to link a group of devices that are a set (e.g., a set of vehicles with specified VINs), and/or that have specified components (e.g., vehicles that utilize a specified ECU) and/or component attributes (e.g., the ECU utilizes a specified firmware version). A device may be associated with one or more segments. In one embodiment, information regarding the device (e.g., the device's bill of materials, versions of components) may be analyzed (e.g., when the device is added to the REDUP) to determine segments associated with the device. Updates installed on the device may be tracked and segments associated with the device may be updated accordingly (e.g., if the ECU is updated with a new firmware version, the device may be placed in the segment associated with the new firmware version and removed from the segment associated with the old firmware version). In one implementation, segments associated with the device may be determined via a MySQL database command similar to the following:
SELECT segmentIDs
FROM Devices
WHERE deviceID=“identifier of the device”;
A determination may be made at 409 whether there remain segments to analyze. In one embodiment, each of the segments associated with the device may be analyzed. If there remain segments to analyze, the next segment may be selected at 413. Device components for the segment may be determined at 417. In one implementation, components associated with the segment may be determined via a MySQL database command similar to the following:
SELECT componentList
FROM Segments
WHERE segmentID=“identifier of the currently analyzed segment”;
A determination may be made at 421 whether there remain components to analyze. In one embodiment, each of the components associated with the segment may be analyzed. If there remain components to analyze, the next component may be selected at 425. A determination may be made at 429 whether an update is available for the component. For example, if a manufacturer of the component released a software update, a data field associated with the component may be set to indicate that an update is available, and this data field may be checked to make this determination. If an update for the component is available, a determination may be made at 433 whether the update is applicable to the segment. For example, a component may utilize different firmware versions (e.g., the component manufacturer may utilize a different firmware version for each vehicle manufacturer that uses the component) and it may be determined whether the update is applicable to the firmware version associated with the segment (e.g., by checking a data field associated with the component update that indicates firmware versions to which the update is applicable). If the update is applicable to the segment, the update may be added to a list of available updates at 437.
If there are no more segments to analyze, an update notification may be generated at 441 that includes the list of available updates. The update notification may be sent to the device at 445. For example, the update notification may be sent via network (e.g., LTE, WiFi).
A determination may be made at 509 whether there remain more updates to process. In one embodiment, each of the available updates may be processed. If there remain updates to process, the next update may be selected at 513. For example, the next highest priority is update may be selected. In another example, the next update in a list of available updates may be selected. A determination may be made whether it is OK to download the update (e.g., based on network connection status). For example, if connection is available and free, it may be OK to download the update. In another example, if connection is unavailable or if connection is busy (e.g., the driver is streaming a movie for occupants of a vehicle), it may not be OK to download the update. If it is not OK to download the update now, the update may be downloaded later 521. In one implementation, a specified period of time may be allowed to elapse and then a check may be made whether it is OK to download the update. In another implementation, the update may be skipped for now and another update may be processed, and a check may be made at a later time whether it is OK to download the update.
If it is OK to download the update, an update download request may be generated and sent at 525. An update download response may be received at 529. In one embodiment, the update download response may include a package with contents of the update. For example, the package may be a file.
A determination may be made at 533 whether it is OK to install the update (e.g., based on package rules). For example, an update to an engine component may be configured to be installable upon vehicle startup while the vehicle is stationary. Accordingly, if the vehicle is currently in motion, it may not be OK to install the update, and the update may be installed the next time the vehicle is turned on. If it is not OK to install the update now, the update may be installed later 537. In one implementation, a specified period of time may be allowed to elapse and then a check may be made whether it is OK to install the update. In another implementation, the update may be skipped for now and another update may be processed, and a check may be made at a later time whether it is OK to install the update.
If it is OK to install the update, the update may be installed at 541 using the UIA component. See
A device identifier associated with the update download request may be determined at 605. In one embodiment, the update download request may be parsed (e.g., using PHP commands) to determine the device identifier. An update identifier and/or an update package identifier associated with the update download request may be determined at 609. In one embodiment, the update download request may be parsed (e.g., using PHP commands) to determine the update identifier and/or the update package identifier.
A determination may be made at 613 whether the device associated with the device identifier is authorized to get the update associated with the update identifier and/or the update package identifier. In one embodiment, a segment associated with the update may be determined (e.g., based on the update identifier, based on the update package identifier), and a determination may be made whether the device is associated with the segment. A device associated with the segment may be authorized to get the update, while a device not associated with the segment may not be authorized to get the update.
If the device is not authorized to get the update, an error event may be logged at 617. If the device is authorized to get the update, the update package associated with the update may be sent to the device at 621.
The integrity of package contents may be verified at 705. In one embodiment, a is checksum associated with the package may be calculated and checked against the package checksum included with the package. If the checksums match, the integrity of the package may be verified. In another embodiment, integrity of individual SUMs may be similarly verified. Accordingly, a determination may be made at 709 whether the integrity is verified. If the integrity is not verified, a corresponding event may be logged at 741.
If the integrity is verified, a determination may be made at 713 whether there remain SUMS to install. In various embodiments, a SUM may comprise a firmware image, a binary application, middleware, drivers, end user applications (e.g., HTML5, Android, QT), configuration files, libraries, scripts, user profiles, and/or the like. For example, a SUM may be a ZIP file that includes SUM contents. In another example, a SUM may be an RPM file. In yet another example, a SUM may be a script file (e.g., that specifies the order in which other SUMs should be installed). In one embodiment, each of the applicable modules may be installed. If there remain modules to install, the next module may be selected at 717. For example, if there are rules that specify how modules in the package depend on each other, a module may be installed after modules on which it depends are installed. In another example, if there are no dependencies, modules may be installed in any order.
A determination may be made at 721 whether rules associated with the module are satisfied. For example, a rule may be to verify whether dependent SUMs have been installed. In another example, a rule may be to check for presence or absence of a specified device component (e.g., ECU) and/or for a specified state of the device component (e.g., the component is turned off, the component uses a specified firmware version). In yet another example, a rule may be to check the state of the device (e.g., the vehicle is stationary) If it is determined that module rules are not satisfied, package installation may be rolled back (e.g., to the old package version using backup files) at 733 and a corresponding event may be logged at 741.
If it is determined that module rules are satisfied, the module may be installed at 725. For example, installation files for the SUM may be executed. A determination may be made at 729 whether the module was installed successfully. If it is determined that the module was is not installed successfully, package installation may be rolled back (e.g., to the old package version using backup files) at 733 and a corresponding event may be logged at 741.
If it is determined that the module was installed successfully, the next module, if any, may be installed. If it is determined that there are no SUMs remaining to be installed, the old package version (e.g., backup files) may be removed from the device at 737. A corresponding event indicating successful installation may be logged at 741.
The connected device may be associated with one or more segments (e.g., based on the vehicle's model and trim). A REDUP administrator (e.g., a product manager) may define which apps are available for which segments. Accordingly, the user may install apps, which are approved for segments associated with the connected device, on the connected device. In one embodiment, the user may utilize the connected device (e.g., the user interface of the vehicle's infotainment system) to select a desired app available from a storefront server (e.g., a separate cloud hosted storefront, a part of the hosted cloud platform).
An app selected by the user may be delivered from the storefront server via the SOTA server and installed on the device. Updates to the app may similarly be delivered via the SOTA server and installed on the device.
A connected device may be notified (e.g., on start up, periodically, upon update availability) when updates (e.g., new apps approved for the device, updates to installed apps) are available. In one implementation, a notification may be sent to the device when updates are available for one or more segments associated with the device. The device may download updates (e.g., in the form of update packages) via network (e.g., via LTE, via WiFi) from the cloud hosted storefront and install them using an update client. A rules engine may be utilized to configure updates for specific segments and to ensure that dependencies and restrictions associated with update package components (e.g., modules) are satisfied.
The device may log specified events associated with apps. For example, logged events may include installation and configuration events, app usage data, app error events, telematic data, and/or the like. Logged events data may be securely delivered in structured data format via the cloud hosted storefront to various analytics applications.
A determination may be made at 1405 whether there remain more settings to configure. For example, there may be more settings to configure until the REDUP administrator indicates otherwise. If there remain more settings to configure, a determination may be made at 1409 regarding a segment setting type.
In one embodiment, a segment setting may be specified based on a set of devices. For example, the set of devices may be a set of vehicles that are used by a manufacturer for testing purposes. In another example, the set of devices may be a set of vehicles that may have been manufactured using an older part number and may have to utilize a custom software fix. In yet another example, the set of devices may be a set of vehicles that are associated (e.g., located in, sold in) with a geographic location (e.g., a country, a state). A set of devices for the segment may be determined at 1413. For example, the set of devices may be specified as a list of vehicle VIN numbers (e.g., provided by the REDUP administrator). Specified devices may be associated with the segment at 1417. For example, a database record associated with the segment may be updated to include the list of specified vehicles. In one implementation, specified devices may be associated with the segment via a MySQL database command similar to the following:
UPDATE Segments
SET segmentDevicesList=“list of specified devices”
WHERE segmentID=“identifier of the segment”;
In another embodiment, a segment setting may be specified based on a set of parameters. For example, the set of parameters may be a collection of components and attributes associated with the components. A set of components for the segment may be determined at 1421. For example, the set of components may be specified as a set of ECUs (e.g., provided by the REDUP administrator). Attributes for components may be determined at 1425. For example, one segment may be defined for vehicles utilizing ECU with version one of the firmware and another segment may be defined for vehicles utilizing ECU with version two of the firmware. In another example, one segment may be defined for vehicles utilizing ECU configured to use normal settings and another segment may be defined for vehicles utilizing ECU configured to use sports settings. Specified parameters may be associated with the segment at 1429. For example, a database record associated with the segment may be updated to include the parameters. In one implementation, specified parameters may be associated with the segment via a MySQL database command similar to the following:
UPDATE Segments
SET segmentParameters=“specified parameters”
WHERE segmentID=“identifier of the segment”;
Parameters for the package may be determined at 1905. In one embodiment, parameters for the package may be specified by a REDUP administrator. For example, the REDUP administrator may specify a priority associated with the package. In another embodiment, parameters for the package may be calculated. For example, a checksum may be calculated for the package. The determined parameters may be associated with the package at 1909. For example, the parameters may be saved as part of the package file.
SUMs associated with the package may be determined at 1913. In one embodiment, SUMs for the package may be specified by a REDUP administrator. For example, the REDUP administrator may specify a list of SUMs associated with the package. In another embodiment, SUMs for the package may be determined based on dependencies. For example, if a first SUM is included in the package and depends on a second SUM, the second SUM may be included in the package. In some implementations, packages may be configured based on attributes of a device requesting an update. Accordingly, if the second SUM was previously installed on the device, the second SUM may not be included in the package, but if the second SUM was not previously installed on the device, the second SUM may be included in the package.
A determination may be made at 1917 whether there remain more SUMs to configure. For example, there may be more SUMs to configure until the REDUP administrator indicates otherwise. If there remain more SUMs to configure, the next SUM may be selected at 1921. The SUM (e.g., a ZIP file) may be added to the package at 1925. Rules for the SUM may be determined at 1929. For example, the REDUP administrator may specify rules (e.g., dependencies, restrictions) associated with the SUM. The determined rules may be associated with the SUM at 1933. For example, the rules may be saved in a rules file and included in the ZIP file associated with the SUM.
If it is determined that there are no SUMs remaining to be configured, the package may be validated at 1937. In one embodiment, dependencies and/or restrictions may be checked. For example, a check may be performed to ensure that SUMs upon which other SUMs depend are included in the package. In another example, a check may be performed to ensure that a component (e.g., ECU) upon which a SUM in the package depends is a part of each segment to which the package is applicable. In another embodiment, a confirmation may be obtained from a REDUP administrator (e.g., via a REDUP user interface) that parameters have been specified correctly.
SUMs are created to facilitate changing the version of a product component from one to another. In one embodiment, SUMs may be created via a REDUP workflow (e.g., as described with regard to
SUMs may be organized into packages. Packages may provide a convenient bag for SUMs managed and published at the same time. Packages may be published onto segments. The segment may manage components (e.g., ECUs) for the SUMs in a package. Packages may be linked to update campaigns. A campaign for a software update may facilitate publishing packages from the cloud to a product (e.g., a vehicle) and results of the campaign may be subsequently reported back to the cloud. Publishing a package may involve sending out notifications to products (e.g., vehicles) that are members of the segment. When notified, the products may request installers to update the attributes in the tree and then request the server to download any SUMs. SUMs are routed to the correct installers (e.g., different components may utilize different installers) and executed. An installation report may be delivered back to the cloud indicating success of failure of the update session. This also facilitates measuring the effectiveness of the campaign.
The device may upload logged events data 2725 to a data storage 2714 and/or to an analytics server 2718. For example, logged events data may be uploaded to the data storage comprising a cloud data storage repository. In another example, logged events data may be uploaded to a database of the analytics server, which is associated with an analytics application. In one implementation, logged events data may be uploaded using a resource description framework (RDF) file format. See
The analytics server may send an analytics data request 2733 to the data storage or to a third party database. For example, the analytics data request may be utilized to obtain additional data utilized in conducting analytics. In some implementations, data from a variety of databases (e.g., logged events data, third party data) may be obtained and combined (e.g., by combining graphs) by the analytics server to conduct analytics. For example, the analytics server may provide the following example analytics data request, substantially in the form of a HTTP(S) POST message including XML-formatted data, as provided below:
The data storage or the third party database may send an analytics data response 2737 with the requested data (e.g., in RDF file format) to the analytics server.
The analytics server may conduct analytics using an analytics conducting (AC) component 2741. See
Device data may be analyzed at 2809. For example, device data may be analyzed to determine software and configuration updates events, system fault and performance events, system service usage notifications, installation and configuration events, app usage data, app error events, telematic data, and/or the like events that should be logged.
A determination may be made at 2809 whether an event that should be logged was reported (e.g., by an ECU, by an application). If so, a determination may be made at 2813 whether a connection to a server is available. For example, it may be determined whether a connection with the server has been established, and, if not, an attempt to establish a connection with the server may be made. In another example, it may be determined that there is no network connectivity, and, therefore, a connection with the server is not available. The connected device may opportunistically look to establish a communicative connection to the server (e.g., to check for updates, to download updates, to upload event data). For example, the connected device may periodically check whether a WiFi, cellular, Bluetooth, and/or the like network connection is available and may attempt to establish a communicative connection to the server when a network connection is available.
If it is determined that a connection with the server is available, a determination may be made at 2817 whether there are events to offload to the server. In one implementation, the currently reported event may be offloaded to the server. In another implementation, previously reported events that have not yet been offloaded to the server (e.g., because there was no network connectivity until now) may be offloaded to the server. If there remain events to offload to the server, the highest priority newest event may be determined (e.g., based on the value of a priority data field associated with the event) at 2821. In various implementations, a variety of ways may be utilized to determine the highest priority newest event. For example, first, events with a timestamp within the last hour may be offloaded with the highest priority events offloaded first; second, events with a timestamp within the last day may be offloaded with the highest priority events offloaded first; third, events with a timestamp within the last week may be offloaded with the highest priority events offloaded first; and so on. Thus, if network connectivity is lost during offloading, the more important events have a higher chance of being offloaded to the server. Data for the determined event may be uploaded to the server and removed from device memory at 2825. In one implementation, event data may be uploaded using RDF file format. In various implementations, event data may be stored on the device in volatile memory or in non-volatile memory (e.g., when the volatile memory is too full).
If it is determined that a connection with the server is not available, event data may be stored in device memory at 2835 so that it may be offloaded to the server at a later time. In one implementation, event data may be stored in faster volatile memory. In another implementation, if the volatile memory is too full, some of the data (e.g., data for lowest priority oldest events) may be transferred to slower non-volatile memory. A determination may be made at 2835 whether a memory usage threshold for events data has been exceeded. For example, the memory usage threshold may be exceeded for volatile memory (e.g., if the device does not use non-volatile memory to store events). In another example, the memory usage threshold may be exceeded for non-volatile memory (e.g., if the device uses non-volatile memory to store events). If it is determined that the memory usage threshold has been exceeded, a determination may be made at 2839 whether there remain events to delete. In one implementation, events may be deleted until memory usage falls below the memory usage threshold. If there remain events to delete, the lowest priority oldest event may be determined at 2843. In various implementations, a variety of ways may be utilized to determine the lowest priority oldest event. For example, first, events with a timestamp older than within the last week may be deleted with the lowest priority events deleted first; second, events with a timestamp older than within the last day may be deleted with the lowest priority events deleted first; third, events with a timestamp older than within the last hour may be deleted with the lowest priority events deleted first; and so on. Thus, if there is not enough memory to store events data, the less important events may be deleted first. Data for the determined event may be deleted from device memory (e.g., volatile memory, non-volatile memory) at 2847.
Application specific analytics event data may be obtained at 2905. In one implementation, application specific analytics event data may be obtained from a database associated with the application. In another implementation, application specific analytics event data may be obtained from a big data storage repository. In some implementations, federated querying (e.g., using SPARQL standard) may be used to obtain and combine data from a plurality of sources. See
A determination may be made at 2909 whether to utilize third party data. For example, this determination may be made based on parameters of the analytics application. If it is determined that third party data should be utilized, third party data may be obtained at 2913. In one implementation, third party data may be obtained from one or more third party databases. In some implementations, federated querying (e.g., using SPARQL standard) may be used to obtain and combine data from a plurality of sources (e.g., from a plurality of application specific and third party sources). See
Desired analytics may be performed at 2917. In one embodiment, analytics may be performed to determine issues with devices and/or with device components. See
SELECT segmentID
FROM Segments
WHERE componentList LIKE “identifier of the ECU with a bug”;
A determination may be made at 2929 whether there remain more affected segments to process. In one embodiment, each of the affected segments may be processed (e.g., in a priority order based on the severity of the issue with regard to the segment, in a priority order based on the importance (e.g., size, value) of the segment). If it is determined that there remain more affected segments to process, the next segment may be selected at 2933. Segment specific changes to fix the issue may be determined at 2937 and an update for the segment may be generated at 2941. The update may be distributed to devices using the REDUP.
The following 8 alternative example embodiments provide a number of variations of some of the core principles already discussed for expanded color on the abilities of the REDUP.
In some alternative embodiments, the REDUP includes a cloud hosted server application and a device-based client platform. As shown in
1. Notification and Software update client
2. LENC—Logging and Event Notification client
3. Examples, such as the console application and a webserver
Historically the Notification and Software update client is known as the REDUP Client. As shown in
1. Event-based Architecture
The REDUP Client architecture is heavily based on the Observer software design pattern. The REDUP client utilizes an event loop into which different modules emit “events”. Functions and routines from other modules can “observe” the events created by a single module.
For example, if a network connection is lost, then any download will need to be cancelled, and the client should stop listening for notifications. In this case the EVENT_TYPE_NETWORK_DISCONNECTED event is emitted by the Network Monitor and is observed by both the Notification Client and the Downloader.
REDUP Client uses libev to manage which event is currently being processed. Each observing function is executed synchronously by the event loop, requiring that any observing function not to block the path of execution. If the observing function waits upon a response it should either break out and use a separate thread or preferably use the libev APIs to wait for a change.
Elements of REDUP such as the Downloader use the libev extensively to simulate synchronous activity by waiting upon IO handles.
1.1. Event Emitter API
1.1.1. event_emitter_on: Register a callback function to be invoked when a specified event happens
1.1.1.1. Parameters
A function which will be invoked when the event occurs
1.1.1.2. Returns
1.1.2. event_emitter_invoke_and_free: Invoke all callback functions that are associated with a specified event_type
1.1.2.1. Parameters
1.1.3. Greeting Example
2. Network Monitor
The Network Monitor is responsible for monitoring the availability of a network connection. It is intended that this component is replaced by a platform-specific component.
The default implementation polls the network interfaces of the device using the POSIX APIs and if a preconfigured network interface has a change of IP address then issues a network connected or disconnected event.
These events are heavily used by the other modules in REDUP.
2.1. Events
2.1.1. EVENT_TYPE_NETWORK_CONNECTED: Network Connected
2.1.1.1. Event data
2.1.2. EVENT_TYPE_NETWORK_DISCONNECTED: Network
2.1.2.1. Event data
2.2. Nimon API
2.2.1. nimon_init: Initialize the network interface monitor
2.3. Disabling the Network Interface Monitor
The other modules in REDUP still require the EVENT_TYPE_NETWORK_CONNECTED or EVENT_TYPE_NETWORK_DISCONNECTED events to be emitted. This is demonstrated in the following example:
3. Notification Client
The purpose of the Notification Client is to provide a notification system that can be used to inform the system of available software updates and to provide a mechanism for applications to receive custom notifications.
3.1. Architecture—shown in
3.2. Subcomponents
The Notification Client includes 2 sub-components:
3.2.1. Presence Client
The Presence Client is responsible for the informing the Notification Server that the REDUP client is available to receive messages for a given user and application.
This includes the receipt of a device identity from the Notification Server which will be used by the MQTT client to subscribe to device notification topics. The Presence Client is invoked by the User Manager when a user authenticates with the device, this allows the Presence Client to request a user identity that can be used to subscribe to user notification topics.
Requests by the Presence Client to the Notification Server should include a timestamp which will be used to ensure that duplicate and invalid requests are ignored.
3.2.2. MQTT Client
The MQTT Client is responsible for subscribing to topics published by the off-board MQTT Broker.
This component is based on the libmosquitto C/C++ library.
3.3. Sequence Diagrams
3.3.1. SEQ030—Device Presence & Notification—shown in
3.3.2. SEQ031—Connection lost—shown in
If the internet connection is lost, then the client should re-subscribe to the notification topic.
Step Description
3.3.3. SEQ033—Application notification—shown in
3.3.4. SEQ026—Notify an off-board server of a user's presence on the device—shown in
This sequence is Connected Infotainment specific
3.3.5. SEQ027—Notify a user logged into the device—shown in
This sequence is Connected Infotainment specific
3.4. Events
3.4.1. Presence Client
3.4.1.1. Create Channel
Register an application with the off-board presence service.
Event data:
3.4.1.2. Remove Channel
Unregister an application with the off-board presence service.
3.4.1.2.1. Event data
3.4.1.3. Remote Token Received
Emitted when a new remote token has been acquired by the Notification Client.
This event can be used as an alternative to Create Channel
3.4.1.3.1. Event data
3.4.2. MQTT Client
3.4.2.1. Notification Received
Emitted when a new application notification is received.
Event data:
3.5. Observed Events
Network Connected/Network Disconnected
Presence Client listens to the Network Connected and Network Disconnected events from the Network Monitor in-order to determine whether an TCP/IP connection is available.
If a connection is made available then the Presence Client will subscribe to device notifications. If a previous connection is re-established then it will reconnect to any existing topics subscribed to.
If no network connection is available, then no notifications will be received.
4. Update Client—shown in
The purpose of the Update Client is to provide software updates in an atomic fashion.
4.1. Data Model
4.1.1. Types of Update
HTML applications
User Profiles
4.1.2. FUMO Nodes
Node Path—Description
4.1.3. States available in the x.State FUMO Property
States marked transient indicate the Client is still processing the update, and are not normally visible in the x/State property during a sync.
State—Description—Transient
4.1.4. FUMO Extensions
For each FUMO node the REDUP has metadata associated with the file that is going to be downloaded. This is held within the Ext node, which is provided by the OMA-DM specification for vendor customization.
4.1.5. Application Extensions to FUMO node
All application FUMO nodes are placed within the ./Vendor/Website/Packages/directory.
Node Path—Description
4.1.5.1. Application Hash
The ApplicationHash value can be generated using the following Linux command. find \‘%s\’ −type f|LC_COLLATE=C sort|xargs md5sum|awk \‘{printf $1}\’ md5sum
The hash generated will be used to designate the name of the folder which contains the version of the application installed.
4.1.6. User Profile Extensions to FUMO node
All User Profile FUMO nodes are placed within the ./Vendor/Website/Profiles/directory.
Node Path—Description
4.1.7. Configuration File Extensions to FUMO node
All Configuration File FUMO nodes are placed within the ./Vendor/Website/Files/ directory.
Node Path—Description
4.1.8. Session Extensions to Packages node
Information which is related entirely to the session is stored within the ./Vendor/Website/Session directory structure.
The current use for this is to indicate if an update is critical, and should be installed without user confirmation. This flag is stored in the Session/Critical node, using string values “true” and “false”. The lack of a Session/Critical node also indicates a false value.
Connected Infotainment uses the /Session/Critical flag to indicate that updates require no user confirmation.
4.1.9. FUMO Ext/State
State—Description
4.1.10. DevInfo node
The DevInfo node specifies the unique object id of the OMA-DM DevInfo management object. Management Object Identifier for the DevInfo MO should be urn:oma:mo:oma-dm-devinfo:1.1.
Current meaningful nodes are listed below:
Node Path—Description
4.2. Sub Components
4.2.1. OMA-DM client
The OMA-DM client is responsible for handing the OMA-DM communication and updating the OMA-DM tree.
4.2.2. Application Installer
The Application Installer is responsible for installing HTML5 applications.
4.2.3. RPM Installer
4.2.4. File Installer
4.2.5. LENC Configuration Installer
4.3. Sequence Diagrams
4.3.1. SEQ001—Client is notified of available updates—shown in
This sequence diagram describes the events that are emitted when the client receives a notification that there are updates available to install. It shows how the payload of the message determines the type of the update, and that the example application determines whether a synchronization should take place immediately, or after custom application logic.
Step Description
4.3.2. SEQ002—Confirmation received to check for updates—shown in
This sequence diagram describes the events that are emitted when the client is asked to check for updates. The client will perform an OMA-DM synchronization, and collect all the application and user profile updates together. Once the synchronization is complete, then different events will be emitted based on the type of updates received.
Step Description
4.3.3. SEQ003—Client downloads available updates—shown in
This sequence diagram describes the actions after a EVENT_TYPE_START_DOWNLOAD event is invoked. When this event is received the client will attempt to download all known updates.
Step Description
4.3.4. SEQ004—User cancels download of updates—shown in
This sequence diagram describes how an example application of the client can cancel the download of applications. During the download of an update the user can issue the EVENT_TYPE_CANCEL_DOWNLOAD event, which will stop the download. The example application can resume the download by issuing the EVENT_TYPE_START_DOWNLOAD event.
Step Description
4.3.5. SEQ005—Client interrupted during download of updates—shown in
The client will store the state of the current installation process, so that it can be continued when it next starts. The state of the FUMO will be set to DOWNLOAD_IN_PROGRESS when the download starts, and will be remain so when the EVENT_TYPE_START_DOWNLOAD is re-invoked. The client will not have the opportunity to change the state on receipt of a kill/terminate signal.
Step Description
4.3.5.1. Scenario: Client resumes update on restart at the point where downloads have completed
The REDUP client itself is not responsible for restarting the download after the process has been killed.
4.3.5.2. Scenario: Client receives server instruction to update a FUMO node which has previously failed download
This behavior occurs when the server updates an existing FUMO node. The server should send a new FUMO node for every change.
4.3.5.2.1. Sync 1: Server informs client of App1 as {random1}
GET ./Vendor/Website/Packages
[empty]
ADD ./Vendor/Website/Packages/{random1}
ADD ./Vendor/Website/Packages/{random1}/State: IDLE
EXEC ./Vendor/Website/Packages/{random1}/DownloadAndUpdate
4.3.5.2.2. Client fails to download App1
ADD App1 v.1 @ ./Vendor/Website/Packages/{random1}: OK
SET ./Vendor/Website/Packages/{random1}/State: DOWNLOAD_FAILED
4.3.5.2.3. Sync 2: Client indicates download has failed
GET ./Vendor/Website/Packages
./Vendor/Website/Packages/{random1}/PkgName: App1
./Vendor/Website/Packages/{random1}/PkgVersion: 1
./Vendor/Website/Packages/{random1}/State: DOWNLOAD_FAILED
WARNING This demonstrates the server updating an existing FUMO node. If the server wishes to retrieve the previous./State of the FUMO node when the rollback fails, then it should create a new FUMO node instead of updating the existing one.
ADD ./Vendor/Website/Packages/{random1}
UPDATE ./Vendor/Website/Packages/{random1}/State: IDLE
UPDATE ./Vendor/Website/Packages/{random1}/DownloadAndUpdate/PkgURL
EXEC ./Vendor/Website/Packages/{random1}/DownloadAndUpdate
4.3.5.2.4. Client downloads App1 successfully but fails to perform custom installation so rollbacks
ADD App1 v.1 @ ./Vendor/Website/Packages/{random1}: OK
SET ./Vendor/Website/Packages/{random1}/State: UPDATE_FAILED_HAVE_DATA
SET ./Vendor/Website/Packages/{random1}/Ext/State: CUSTOM_ROLLBACK_OK
The previous values of DownloadAndUpdate/PkgURL and ./State are not reverted.
The values of the child nodes for the first FUMO node sent by the client is no longer stored in the by the client local tree.
4.3.6. SEQ006 & SEQ007—Client installs available updates
This sequence diagram describes the actions of the client after a EVENT_TYPE_START_INSTALL event is invoked. When this event is received the client will attempt to install all of the downloaded updates. The installation is split into two steps:
1. Extract and verify all applications
2. Perform custom installation for each application
4.3.7. SEQ006—Client installs available updates—shown in
Step Description
4.3.8. SEQ007—Client invokes custom installer—shown in
Step Description
4.3.9. Scenario: Client resumes update on restart at the point where applications have been verified
The REDUP client itself is not responsible for restarting the application installation after the process has been killed.
4.3.10. Scenario: FUMO states are restored after rollback of installation
4.3.10.1. Sync 1: Server informs client of App1 as {random1}
4.3.10.1.1. Server->Client: Request list of Packages node
GET ./Vendor/Website/Packages
4.3.10.1.2. Client->Server: Client responds with empty local FUMO OMA-DM tree
[empty]
4.3.10.1.3. Server->Client: Server adds FUMO node representing App1
ADD ./Vendor/Website/Packages/{random1}
ADD ./Vendor/Website/Packages/{random1}/State: IDLE
EXEC ./Vendor/Website/Packages/{random1}/DownloadAndUpdate
4.3.10.2. Client successfully installs App1
./Vendor/Website/Packages/{random1}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random1}/Ext/State: CUSTOM_INSTALL_OK
4.3.10.3. Sync 2: Client indicates installation is successful, and server provisions App2
4.3.10.3.1. Server->Client: Request list of Packages node
GET ./Vendor/Website/Packages
4.3.10.3.2. Client->Server: Client responds with local FUMO OMA-DM tree showing App1 installed
./Vendor/Website/Packages/{random1}/PkgName: App1
./Vendor/Website/Packages/{random1}/PkgVersion: 1
./Vendor/Website/Packages/{random1}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
4.3.10.3.3. Server->Client: Server provisions App2
ADD ./Vendor/Website/Packages/{random2}
ADD ./Vendor/Website/Packages/{random2}/State: IDLE
ADD ./Vendor/Website/Packages/{random2}/EXT/FileVersionID: {uri: App2 v.1}
EXEC ./Vendor/Website/Packages/{random2}/DownloadAndUpdate
4.3.10.4. Client fails to download App2
SET ./Vendor/Website/Packages/{random2}/State: DOWNLOAD_FAILED
4.3.10.5. Sync 3: Client reports failure of download to App2, and server deletes App2, App1 and adds App3
4.3.10.5.1. Server->Client: Request list of Packages node
GET ./Vendor/Website/Packages
4.3.10.5.2. Client->Server: Client responds with local FUMO OMA-DM tree showing App2 failed to download
./Vendor/Website/Packages/{random1}/PkgName: App1
./Vendor/Website/Packages/{random1}/PkgVersion: 1
./Vendor/Website/Packages/{random1}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
./Vendor/Website/Packages/{random2}/PkgName: App2
./Vendor/Website/Packages/{random2}/PkgVersion: 1
./Vendor/Website/Packages/{random2}/State: DOWNLOAD_FAILED
./Vendor/Website/Packages/{random2}/EXT/FileVersionID: {uri: App2 v.1}
4.3.10.5.3. Server->Client: Delete App1 and App2, and install App3
DEL ./Vendor/Website/Packages/{random1}
DEL ./Vendor/Website/Packages/{random2}
ADD ./Vendor/Website/Packages/{random3}
ADD ./Vendor/Website/Packages/{random3}/State: IDLE
ADD ./Vendor/Website/Packages/{random3}/EXT/FileVersionID: {uri: App3 v.1}
EXEC ./Vendor/Website/Packages/{random3}/DownloadAndUpdate
4.3.10.6. Client successfully download App3, but fails during installation so needs to rollback
./Vendor/Website/Packages/{random1}/PkgName: App1
./Vendor/Website/Packages/{random1}/PkgVersion: 1
./Vendor/Website/Packages/{random1}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
./Vendor/Website/Packages/{random2}/PkgName: App2
./Vendor/Website/Packages/{random2}/PkgVersion: 1
./Vendor/Website/Packages/{random2}/State: DOWNLOAD_FAILED
./Vendor/Website/Packages/{random2}/EXT/FileVersionID: {uri: App2 v.1}
./Vendor/Website/Packages/{random2}/PkgName: App3
./Vendor/Website/Packages/{random2}/PkgVersion: 1
./Vendor/Website/Packages/{random3}/State: UPDATE_FAILED_HAVE_DATA
./Vendor/Website/Packages/{random2}/EXT/FileVersionID: {uri: App2 v.1}
4.3.11. SEQ010—Remote removal of installed applications—shown in
Step Description
4.3.12. SEQ012—Application framework installation
Flow is the same as SEQ001-SEQ-009.
4.3.13. SEQ014—Removal of all applications—shown in
Step Description
4.3.14. SEQ015—Update available event ignored by application—shown in
It is possible to receive an update notification and issue the EVENT_TYPE_UPDATE_AVAILABLE but not to receive a corresponding EVENT_TYPE_CHECK_UPDATES event. The FUMO nodes which would be associated to the update notification would be sent on the subsequent OMA-DM sync request.
Step Description
4.3.14.1. Scenario: Notification of new updates received during download of existing update—shown in
Step Description
4.3.15. SEQ016—Download of an application fails—shown in
It is possible for the download of a file to fail. This can occur in the following situations:
On failure the client will set the FUMO State value to be DOWNLOAD_FAILED and the Ext/State to DOWNLOAD_FAILED.
At this point the client can either receive another START_APPLICATION_INSTALL prompting the download to be attempted again, or the client will wait for the next synchronization request. The subsequent changes to the OMA-DM tree may result in the download being re-attempted.
Step Description
4.3.16. SEQ017—Download partially completes
When the client downloads a file from the server it will keep a copy of the bytes downloaded on disk, so that it can resume the download at a later date. However if the FUMO node associated with the download is removed during a remote removal request, then the partially downloaded file should be removed.
See SEQ010.
4.3.17. SEQ018—User rejects installation of updates
4.3.17.1. Scenario: User rejects installation of updates—re-use of same FUMO node
4.3.17.1.1. Sync 1: Initial attempt to update App1 from version 1 to version 2
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
./Vendor/Website/Packages/{random1}/PkgName: App1
./Vendor/Website/Packages/{random1}/PkgVersion: 1
./Vendor/Website/Packages/{random1}/State: UPDATE_SUCCESSFUL_HAVE_NO_DATA
./Vendor/Website/Packages/{random1}/Ext/FileVersionID: {uri: App1 v.1}
./Vendor/Website/Packages/{random1}/Ext/State: POST_CUSTOM_INSTALL_OK
UPDATE ./Vendor/Website/Packages/{random1}/State: IDLE
UPDATE ./Vendor/Website/Packages/{random1}/PkgVersion: 2
UPDATE ./Vendor/Website/Packages/{random1}/Ext/FileVersionID: {uri: App1 v.2}
UPDATE ./Vendor/Website/Packages/{random1}/DownloadAndUpdate/PkgURL: URL to download App1 v.2
EXEC ./Vendor/Website/Packages/{random1}/DownloadAndUpdate
4.3.17.1.2. Client rejects installation based on user input
./Vendor/Website/Packages/{random1}/State: IDLE
./Vendor/Website/Packages/{random1}/Ext/State: READY_TO_DOWNLOAD
4.3.17.1.3. Sync 2: Server discovers update has failed and re-applies App1
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
The server knows that App1 v.2 has failed to install, and that App1 v.1 was previously installed.
./Vendor/Website/Packages/{random1}/PkgName: App1
./Vendor/Website/Packages/{random1}/PkgVersion: 2
./Vendor/Website/Packages/{random1}/State: UPDATE_FAILED_HAVE_DATA
./Vendor/Website/Packages/{random1}/Ext/State: READY_TO_DOWNLOAD
./Vendor/Website/Packages/{random1}/Ext/FileVersionID: {uri: App1 v.2}
If there are no additional changes to the software for the device, then only the EXEC command for the {random1} node should be sent.
EXEC ./Vendor/Website/Packages/{random1}/DownloadAndUpdate
4.3.18. SEQ019—Notification of updates received during installation—shown in
Step Description
4.3.19. SEQ041—Whilst downloading an application the corresponding FUMO node removed by a OMA-DM sync—shown in
Step Description
4.3.20. SEQ042—Whilst downloading an application an additional FUMO is added by a OMA-DM sync—shown in
Step Description
4.3.21. SEQ043—Whilst downloading an application an additional FUMO of type User Profile is added by a OMA-DM sync—shown in
Step Description
4.3.22. SEQ045—Installer registers with OMA-DM client—shown in
Step Description
4.3.23. SEQ046—Installation of an RPM file—shown in
Step Description
4.3.24. SEQ047—Installation of a configuration file—shown in
Step Description
4.4. Events
4.4.1. OMA-DM Client
4.4.1.1. EVENT_TYPE_SYNC_COMPLETE: An OMA-DM synchronization has completed
Emitted when a OMA-DM sync has completed.
4.4.1.1.1. Event data (FR1.2.*)
4.4.1.1.2. Event data (FR1.3.*)
4.4.1.2. EVENT_TYPE_HTML5_APP_AVAILABLE: New or changed HTML applications are available
This event indicates that new HTML5 application/s are available for download. This event is normally emitted as at the end of OMA-DM sync, if new/updated HTML5 applications are available.
At this point the Update Client has not parsed the OMA-DM tree to expose what the applications are, only that the sub-tree containing applications has been modified.
4.4.1.2.1. Event data
4.4.1.3. EVENT_TYPE_USERPROFILE_AVAILABLE: New or changed User Profiles are available
This event indicates that an User Profile should be downloaded by the client. This event is normally emitted as at the end of OMA-DM sync, if a new/updated User Profile has been made available.
Event data:
4.4.2. Generic Installer
4.4.2.1. EVENT_TYPE_DOWNLOAD_FAILED: The download of an update has failed
Emitted if any of the files in the update fail to complete.
4.4.2.2. EVENT_TYPE_DISK_SPACE_UNAVAILABLE: Not enough storage space to install an update
There is not enough storage space on the configured medium to install updates.
The data associated with this event should be a structure that contains:
4.4.2.3. EVENT_TYPE_UPDATE_COMPLETE: The installation of an update has completed
This event is emitted by the client when an application update has been completed.
Event data:
4.4.2.4. EVENT_TYPE_APPLICATION_DOWNLOAD_COMPLETE: Download of all applications have completed
Event data:
4.4.2.5. EVENT_TYPE_USERPROFILE_DOWNLOAD_COMPLETE:
Download of all user profiles have completed
Event data:
4.4.3. Application Installer
4.4.3.1. EVENT_TYPE_VERIFICATION_COMPLETE: Update has been verified successfully
The EVENT_TYPE_VERIFICATION_COMPLETE event is emitted by the client when the verification process has been completed for all applications in the update. If any of the applications that form part of this update fail, then this event will be emitted.
The data associated with this event should be a structure that contains:
If the verification has been successful, then the system should respond by emitting a Error: Reference source not found event.
Event data:
4.4.3.2. EVENT_TYPE_CUSTOM_DEINSTALL: Perform a custom de-installation of an application
EVENT_TYPE_CUSTOM_DEINSTALL is emitted by the client when an application has been deinstalled from disk This event allows the system to extend the deinstallation process by reacting to this event.
Once the system has deinstalled the application, then it should emit the Error: Reference source not found event.
Event data:
4.4.3.3. EVENT_TYPE_CUSTOM_INSTALL: Perform custom installation of an application
EVENT_TYPE_CUSTOM_INSTALL is emitted by the client when an application has been installed onto disk but has not been activated by the system. This event allows the system to extend the installation process by reacting to this event.
Once the system has installed the application, then it should emit the EVENT_TYPE_CUSTOM_INSTALL_RESPONSE event.
Event data:
4.4.3.4. EVENT_TYPE_CUSTOM_ROLLBACK: A custom application rollback request
EVENT_TYPE_CUSTOM_ROLLBACK is emitted by the client when the installation of the application has failed and client is attempting to rollback the procedure. This event allows the system to revert any custom installation taken place during a EVENT_TYPE_CUSTOM_INSTALL.
Event data:
4.4.3.5. EVENT_TYPE_READY_TO_DOWNLOAD: Details of updates are known, and are ready to be downloaded
Once a OMA-DM synchronization has completed, then the resulting FUMO nodes are processed.
If there are any FUMO nodes that require download and installation then the EVENT_TYPE_READY_TO_DOWNLOAD event is emitted.
The data associated with this event is a ready_to_download_request_t that contains list of Application UUIDs in a application_uuid_t structure, and the update identifier.
Event data:
4.4.4. RPM Installer
4.4.4.1. EVENT_TYPE_RPM_READYTODOWNLOAD: An RPM-based update is available for download
4.4.4.1.1. Event data
An identifier for all of the FUMO nodes which are RPM files
4.4.4.1.2. Event data
4.4.5. Configuration File Installer
4.4.5.1. EVENT_TYPE_CONFIG_FILE_READY_TO_DOWNLOAD: New or changed configuration files are available for download
Once the OMA-DM synchronization has completed then the Configuration File Installer processes the changed FUMO nodes.
If any of the FUMO nodes require download and installation then the EVENT_TYPE_CONFIG_FILE_AVAILABLE event is issued with information about all of the configuration files updated.
4.4.5.1.1. Event data
4.5. Observed Events
4.5.1. OMA-DM Client
4.5.1.1. EVENT_TYPE_CHECK_UPDATES: Inform the client that it should check for updates
When the EVENT_TYPE_CHECK_UPDATES event is invoked when the client should check the nature of any updates. Typically this is an OMA-DM synchronization, but is implementation dependent. This event should be emitted as a result of some user interaction prompted by the EVENT_TYPE_UPDATE_AVAILABLE event.
4.5.2. Generic Installer
4.5.2.1. EVENT_TYPE_START_INSTALL: Updates are available, have been downloaded but not verified
The EVENT_TYPE_START_INSTALL event is issued when the application has confirmed that it wishes to install the update after it has been downloaded. At the point of entry the update has not been verified, so verification will normally take place in the listener for this event.
Event data:
4.5.3. Application Installer
4.5.3.1. EVENT_TYPE_START_APPLICATION_INSTALL: Inform the client that it should begin the installation of updates
EVENT_TYPE_START_APPLICATION_INSTALL indicates that the system is ready to install applications. This should be the response from EVENT_TYPE_VERIFICATION_COMPLETE.
Event data:
4.5.3.2. EVENT_TYPE_CUSTOM_DEINSTALL_RESPONSE: Inform the client that custom deinstallation of application is complete
EVENT_TYPE_CUSTOM_DEINSTALL response is sent by the custom installer once it has completed the custom de-installation procedure started by EVENT_TYPE_CUSTOM_DEINSTALL.
Event data:
4.5.3.3. EVENT_TYPE_CUSTOM_ROLLBACK_RESPONSE: Inform the client that the custom rollback of the application is complete.
Sent by the system, or other library once the EVENT_TYPE_CUSTOM_ROLLBACK has been processed.
Event data:
4.5.3.4. EVENT_TYPE_REMOVE_ALL_APPLICATIONS: Remove all applications installed on the device
The EVENT_TYPE_REMOVE_ALL_APPLICATIONS is issued when the user wishes to remove all applications currently installed by the client.
Event data:
4.6. DM Client API
4.6.1. dmclientmarkfumosubtree: Mark an area of the OMA-DM tree as containing FUMO nodes (FR1.3.*)
Inform the OMA-DM client that a sub tree contains FUMO nodes. Any EXEC or DELETE OMA-DM commands to this sub-tree are interpreted as commands to install or remove software components, and will be included in the event data to EVENT_TYPE_SYNC_COMPLETE.
4.6.1.1. Parameters
4.6.1.2. Returns
5. Download Client
5.1. Events
5.1.1. EVENT_TYPE_START_DOWNLOAD: Inform the client that it should download updates.
The EVENT_TYPE_START_DOWNLOAD event indicates that an update should be downloaded by the client. This event is normally emitted as a result of some user interaction prompted by the EVENT_TYPE_READY_TO_DOWNLOAD event.
5.1.1.1. Event data
5.1.2. EVENT_TYPE_DOWNLOAD_COMPLETE: All downloads in the update have completed
The EVENT_TYPE_DOWNLOAD_COMPLETE event is fired when all the files matching an update_id have finished downloading.
Event data:
5.1.3. EVENT_TYPE_FILE_DOWNLOAD_PROGRESS: Indicates the download progress of a file
Emitted during a file download when the percentage of the file complete meets a pre-configured interval. E.g. If configured to 20, then this event is emitted at 20%, 40%, 60%, and 80%
The pre-configured interval is defined by the configuration option download_progress_interval.
Event data:
5.1.4. EVENT_TYPE_DOWNLOAD_CANCELLED: Indicate that an ongoing download has been cancelled
The EVENT_TYPE_DOWNLOAD_CANCELLED is issued for every group of downloads which are cancelled as a result of the EVENT_TYPE_CANCEL_DOWNLOAD event.
5.1.4.1. Event data
5.1.5. EVENT_TYPE_UPDATE_DOWNLOAD_PROGRESS: Indicates the download progress of an update
Emitted during a update download when the percentage of the update complete meets a pre-configured interval. E.g. If configured to 20, then this event is emitted at 20%, 40%, 60%, and 80%
The pre-configured interval is defined by the configuration option download_progress_interval.
Event data:
5.1.6. EVENT_TYPE_DOWNLOAD_CANCELLED: Indicate that an ongoing download has been cancelled
The EVENT_TYPE_DOWNLOAD_CANCELLED is issued for every group of downloads which are cancelled as a result of the EVENT_TYPE_CANCEL_DOWNLOAD event.
5.1.6.1. Event data
5.1.7. EVENT_TYPE_FILE_DOWNLOAD_COMPLETE: An individual file in the update has completed download (FR1.3.*)
The EVENT_TYPE_FILE_DOWNLOAD_COMPLETE is emitted when an individual file with a given update_id has completed download.
5.2. Observed Events
5.2.1. EVENT_TYPE_CANCEL_DOWNLOAD: Cancel any on-going download
The EVENT_TYPE_CANCEL_DOWNLOAD event is issued when the application or user wishes to cancel any on-going download.
It will cancel all downloads, regardless of type.
5.2.1.1. Event data
5.2.2. EVENT_TYPE_DOWNLOAD_FILE: Queue a URL to be downloaded (FR1.3.*)
5.2.2.1. Event data
5.2.3. EVENT_TYPE_DOWNLOAD_UPDATE: Download all the files in an update (FR1.3.*)
The EVENT_TYPE_DOWNLOAD_UPDATE event starts the download of all the files in an update.
5.2.3.1. Event data
An identifier which is used to aggregate a collection of files which needed to be downloaded at the same time. This would typically by an update identifier, and can be used to identify the type of file which is being downloaded.
5.3. API
5.3.1. downloader_init: Initialize the Downloader
5.3.1.1. Parameters
None
5.3.1.2. Return
None
5.3.2. downloader_cleanup: Remove any download timers
5.3.2.1. Parameters
None
5.3.2.2. Return
None
5.3.3. downloadFile: Download a URL and place it in the specified location
deprecated This function is replaced with EVENT_TYPE_DOWNLOAD_FILE.
5.3.3.1. Parameters
6. User Data Client
The purpose of the User Data Client provides an API to manage and authenticate Users on a system.
6.1. Sub Components—shown in
6.1.1. User Profile Installer
The User Profile Installer component interacts with the Update Client to receive and install User Profiles.
6.1.2. User Data Store
The User Data Store component provides a C Library for managing user data which is stored in an SQLite3 database.
6.1.3. User Auth
The User Auth component provides a C Library used to authenticate a user with an off-board server.
6.1.4. JLR Service Gateway
The JLR Service Gateway is an off-board HTTP server capable of handing presence requests of a user on the device. It is used with the set_user_presence API.
6.1.5. Authentication Server
The Authentication Server is and off-board HTTP server capable of handling OAuth requests. It is used with the authenticate_user API.
6.2. Events
6.2.1. User Profile Installer
6.2.1.1. EVENTTYPEUSERPROFILEUPDATED: User Profile Updated
This event is issued by the User Profile Installer when the User Profile specified by the event data has been updated.
6.2.1.1.1. Event data
6.2.1.2. EVENTTYPEUSERPROFILEREMOVED: User Profile Removed
This event is issued by the User Profile Installer when the User Profile specified by the event data has been updated.
6.2.1.2.1. Event data
See User Profile Updated—Event data
6.2.2. User Data Store
6.2.2.1. EVENTTYPEUSERPROFILEEXPIRED: User Profile Expired
This event is issued by the User Data Store when the User Profile specified by the event data has expired.
6.2.2.1.1. Event data
See User Profile Updated—Event data
6.3. Observed Events
6.3.1. User Profile Available
The User Profile Available event indicates that an User Profile should be downloaded by the client. This event is normally emitted as at the end of OMA-DM sync, if a new/updated User Profile has been made available.
6.4. Data Model
6.4.1. User Table
The User Table contains information related to a user that has successfully authenticated with a remote authentication server. Once remote authentication was successful, this table contains information allowing the user to be authenticated locally, through the use of an alias and pin number.
user_id
6.4.2. Zone Table
The Zone Table contains information related to a “zone” which a user can authenticate to. Zones are roughly equivalent to any device which can be connected to the system.
6.4.3. User Zone State table
The User Zone State Table contains information regarding a user in a given zone. It is a link table between User Table and Zone Table.
6.5. User Auth API
6.5.1. authenticate_user: Authenticates a user against a remote authentication server
The authenticate_user function attempts to authenticate a user against a remote OAuth server that supports “Resource Owner Password Credentials Grant”.
On receipt of the access token it will be stored against the user in the User Data Table
6.5.1.1. Parameters
6.5.1.2. Returns (FR1.2.3)
6.5.1.3. Returns (FR1.2.5)
6.5.2. change_pin_by_user_id: Authenticate a user and then change the PIN
The change_pin_by_user_id function changes the PIN number for a given username. Performs an OAuth request to the off-board server which verifies that the username and password are correct and match the provided user_id.
If the username and password are correct, and the server responds with HTTP 200 (OK) then the PIN number for that alias is changed.
The OAuth request uses includes the HTTP parameter ACUserID which is populated by the method parameter user_id. This method expects this value to be the same as the user_id in the result of authenticate user.
6.5.2.1. Parameters
6.5.2.2. Returns
6.5.3. renew_access_token: Request a new access token from the Authentication Server
As per authenticate_user, renew_access_token makes a request to the off-board Authentication Server.
The OAuth request uses includes the HTTP parameter ACUserID which is populated by the user_id of the active user in the zone identified by zone_id. This method expects this value to be the same as the user_id in the result of authenticate_user.
On success, this function should update the secure_token for the user in the User Table.
6.5.3.1. Parameters
6.5.3.2. Returns
6.5.3.3. Examples
6.5.3.3.1. Example Data—shown in
[user_auth]
client_id=MyClientId
auth_dev_id=MyDeviceId
auth_secret=MySecretToken
6.5.3.3.2. Username and password match active user in zone
In this example the Authentication Server confirms that the username and password belong to the user who is active in zone 1.
Upon receipt of the HTTP response, the secure_token field of the User Table will be updated.
6.5.3.3.3. Incorrect username and password for active user in zone
In this example the Authentication Server indicates that the active user in zone 2, “mary.bloggs”, is not identified by using the username “joe.blogg@example.com”.
oauth_err is set to NULL because no OAuth request has been made.
6.5.3.3.4. Invalid password for active user in zone
In this example the username matches the user_id for the given zone, but the password parameter is incorrect.
POST /authorization-server/token HTTP/1.1
6.5.4. set_user_presence: Set the user presence on the off-board server
The set_user_presence API makes a request to the JLR Service Gateway with a notification token indicating that a user has authenticated on the device, and is able to receive notifications.
See External Interfaces fr1.2.2.18 Section 5.1.3: HTTP POST /rest/presence/user/register
6.5.4.1. Parameters
6.5.4.2. Returns
6.6. User API
6.6.1. create_alias-Create an alias for a user used for local authentication
6.6.1.1. Parameters
6.6.1.2. Returns
6.6.2. get_secure_token: Retrieve the secure access token for a user
The secure access token is used to authenticate a user with the off-board server. It is stored in the secure_token field of the User Table.
6.6.2.1. Parameters
6.6.2.2. Returns
6.6.3. get_user_profile: Return the User Profile for a User (FR1.2.4)
6.6.3.1. Parameters
6.6.3.2. Returns
6.6.4. get_user_profile: Return the User Profile for a User (FR1.2.5)
Return the User Profile for a given User. This will return the contents of the profile field in the User Table.
6.6.4.1. Parameters
6.6.4.2. Returns
6.6.5. set_remember_me: Set the “Remember Me” flag for a User in a given Zone
Updates the remember_me column for a matching User and Zone.
6.6.5.1. Parameters
6.6.6. get_remember_me: Return the “Remember Me” flag for a User in a given Zone
6.6.6.1. Returns
6.6.7. change_pin: Modify the PIN number for a given alias
Allows the application to change the PIN number for a specified alias. If the user does not currently have a PIN number then the old_pin should be set to NULL.
6.6.7.1. Parameters
6.6.7.2. Returns
6.6.8. set_pin: Set the PIN number for a given alias
If an error occurs, the enum will be a negative value. This allows a simple if(set_pin( . . . )) { } check.
6.6.8.1. Parameters
6.6.8.2. Returns
6.6.9. get_user_id_for_alias-Returns a user id for a given alias
6.6.9.1. Parameters
6.6.9.2. Returns
6.6.10. get_alias_for_user_id: Return an alias matching a specified user id
6.6.10.1. Parameters
6.6.10.2. Returns
6.6.11. add_user: Add the given User ID to the database.
6.6.11.1. Parameters
6.6.11.2. Returns
6.6.12. delete_user: Delete a user from the database
6.6.12.1. Parameters
6.6.12.2. Returns
6.6.13. delete_all_users: Delete all users from the database and the OMA-DM tree
6.6.13.1. Parameters
6.6.13.2. Returns
6.6.14. delete_user_by_alias
Deletes a user with the matching alias from the User Table. Marks the corresponding FUMO node in the OMA-DM tree with the REMOTE REMOVE state.
6.6.14.1. Parameters
6.6.14.2. Returns
6.6.15. authenticate_alias-Authenticate alias based on a PIN
Authenticate a user against the alias and pin fields in the User Table.
If provided pin and alias parameters match an entry in the User Table then reset the number of failed authentication attempts. If the parameters do not match then increment the number of failed authentication attempts. The number of failed authentication attempts is held in the failed count field of the User Table.
6.6.15.1. Parameters
6.6.15.2. Returns
6.6.16. create_alias-Create an alias used for local authentication
6.6.16.1. Parameters
6.6.16.2. TODO Returns
6.6.17. change_alias-Change the alias for a given user
6.6.17.1. Parameters
6.6.17.2. Returns
6.7. Zone API
6.7.1. create_zone: Create a new zone in the database
6.7.1.1. Parameters
6.7.1.2. Returns
6.7.2. list_internal_zones: List internal zones from the database
6.7.2.1. Parameters
6.7.2.2. Returns
6.7.3. list_virtual_zones: List virtual zones from the database
6.7.3.1. Parameters
6.7.3.2. Returns
6.7.4. list_suspended_users: List suspended users for a given zone
6.7.4.1. Parameters
6.7.4.2. Returns
6.7.5. get_active_user: Find the active user in a given zone
Returns the user_id of an active user in a given zone, in case of an error it returns NULL.
6.7.5.1. Parameters
6.7.5.2. Returns
6.7.6. set_user_state: Set the current state of a user in a given zone
6.7.6.1. Parameters
6.7.6.2. Returns
6.7.7. get_user_state: Set the current state of a user in a given zone
6.7.7.1. Parameters
6.7.7.2. Returns
6.7.8. list_aliases_for_zone: List the aliases which have been created on the system
Return a list of all users which have been created on the system and the state which they are in for a given zone and the remember_me flag.
6.7.8.1. Parameters
6.7.8.2. Returns
6.7.8.3. Example—shown in
6.7.8.3.1. list_aliases_for_zone(zone1)
6.7.8.3.2. list_aliases_for_zone(zone2)
6.7.8.3.3. list_aliases_for_zone(zone3)
6.7.8.3.4. list_aliases_for_zone(zone4)
6.8. Sequence Diagrams
6.8.1. SEQ020—User information is updated—shown in
This sequence diagram displays the intended flow for when a user profile is updated by a remote server and the applications that are using the profile are informed.
Step Description
6.8.2. SEQ021—User profile expires—shown in
This diagram describes how the client monitors the expiry time of a user profile, and if the expiry time is reached, then it is removed from the system.
Step Description
6.8.3. SEQ022—Remote removal of user profile—shown in
The update server can send an OMA-DM command that removes the User Profile from the device. On receipt of this command, the users data will be removed.
Step Description
6.8.4. SEQ023—User requests removal of user profile—shown in
The application may wish to manually remove the user data from the device. The delete_user method supports this.
6.8.5. SEQ024—Remote user authentication—shown in
The authentication of a user takes place in two steps; retrieval of an access token, and, creation of a user alias
The retrieval of an access token uses the OAuth Resource Owner Password Credentials flow.
The second part of remote user authentication is to create local authentication credentials
7. Configuration
7.1. Config API
7.1.1. set_device_identity: Modify the device identity
The set_device_identity function modifies the device_identity configuration value.
7.1.1.1. Parameters
7.1.2. set_imc_version: Modify the DevInfo/IMC value
The set_imc_version function sets the value in the OMA-DM tree which is used for identifying the version of the Connected Infotainment framework.
7.1.2.1. Parameters
7.1.3. set_device_manufacturer: Set the device manufacturer
The set_device_manufacturer function sets the value in the OMA-DM tree for the DevInfo/Man node.
This will override the configuration value omadm-device_man.
7.1.3.1. Parameters
7.1.4. set_device_model: Sets the device model
The set_device_model function sets the value in the OMA-DM tree for the DevInfo/Mod node.
This will override the configuration value omadm-device_mod.
7.1.4.1. Parameters
7.1.5. set_device_language: Sets the device model
The set_device_language function sets the value in the OMA-DM tree for the DevInfo/Lang node.
This will override the configuration value omadm-device_lang.
7.1.5.1. Parameters
7.2. General
7.2.1. device_identity: The identity of the device
The device_identity configuration parameter stores the pre-configured identity of the device.
device_identity is used by all modules of the REDUP client. It is not subject to any restrictions, however since it is used by the DevInfo/DevId OMA-DM tree node it should be a globally unique URN, but the client does not enforce this restriction.
7.2.2. server-use_ssl: Use SSL for all HTTP and MQTT requests
If server-use_ssl is set to true, the client will use SSL for connections to the server.
[server]
use_ssl=true
7.2.3. server-ca_file: Filename of CA certificate file
The server-ca_file specifies the name of a file which contains PEM encoded Certificate Authority certificates that have signed the server certificate.
Either server-ca_file or server-ca_path should be defined if server-use_ssl is set to true.
[server]
ca_file=myca.pem
7.2.4. server-ca_path: Folder containing CA certificate
The server-ca_path specifies a directory which will be searched for files containing a contains PEM encoded Certificate Authority certificates that have signed the server certificate.
Either server-ca_file or server-ca_path should be defined if server-use_ssl is set to true.
[server]
ca_path=/etc/ssl/
7.2.5. server-trust_unknown_certificates: Trust certificates that have not been verified by the CA
The server-trust_unknown_certificates will allow the SSL connections to skip the hostname verification against the common name in the server certificate.
This can be useful when testing initial server configurations but makes it possible for a malicious third party to impersonate your server through DNS spoofing, for example. Use this option in testing only. If you need to resort to using this option in a production environment, your setup is at fault and there is no point using encryption.
[server]
trust_unknown_certificates=0
7.2.6. server-client_cert_path: Path to client certificate
The server-client_cert_path allows the specification of a client SSL certificate for authentication. The value of this option should be a path to a file on the filesystem. It should be used in conjunction with serverclient_key_path.
Ignore this option if client certificates are not required.
This option only affects the MQTT interface.
[server]
client_cert_path=/opt/certificates/my_cert.pem
7.2.7. server-client_key_path: Path to the client private key
The server-client_key_path allows the specification of client private SSL key. The value of this option should be a path to a file on the fileystem. It should be used in conjunction with server-client_cert_path.
Ignore this option if client certificates are not required.
This option only affects the MQTT interface.
[server]
client_key_path=/opt/certificates/my_key.pem
7.2.8. mqtt-tls_version: Version of TLS protocol for use with MQTT connection
The mqtt-tls_version option defines the version of the TLS protocol to use for the client. The default value will be the highest version that is available for the version of openssl that the broker was compiled against. For openssl>=1.0.1 the valid values are tlsv1.2 tlsv1.1 and tlsv1. For openssl<1.0.1 the valid values are tlsv1.
This option only affects the MQTT interface.
[mqtt]
tls_version=
7.3. Notification
7.3.1. presence-register_device_wait_period: Number of seconds to wait before retrying a device registration request
[presence]
register_device_wait_period=30
7.4. OMA-DM
7.4.1. omadm-device_man-Manufacturer of the device reported in OMADM tree
The omadm-device_man configuration value changes the value of the DevInfo/Man OMA-DM tree node.
[omadm]
device_man=MyManufacturer
7.4.2. omadm-device_model: Model of the device reported in the OMADM tree
The omadm-device_mod configuration value changes the value of the DevInfo/Mod OMA-DM tree node.
[omadm]
device_mod=MyModel
7.4.3. omadm-device_lang: Language of the device reported in the OMADM tree
The omadm-device_lang configuration value changes the value of the DevInfo/Lang OMA-DM tree node.
[omadm]
device_lang=eng
7.4.4. omadm-restart_downloads_in_progress_without_exec: Restart downloads with DOWNLOAD_PROGRESSING even without an EXEC command
The mechanism whereby the server indicates to the client that a FUMO node should be installed is by sending an OMA-DM EXEC command Some servers may not send the EXEC command if the State is set to DOWNLOAD_PROGRESSING.
This omadm-restart_downloads_in_progress_without_exec option will treat any node which has the DOWNLOAD_PROGRESSING state after the sync has completed as having received the EXEC command too. Thus the installation for this FUMO node will be continued.
[omadm]
restart_downloads_in_progress_without_exec=1
7.5. RPM Installer
7.5.1. rpm_installer-verify_cmd: Command used to verify a downloaded RPM file
[rpm_installer]
verify_cmd=rpm −K
7.5.2. rpm_installer-install_cmd: Command used to install and RPM file
[rpm_installer]
verify_cmd=rpm −i
7.5.3. rpm_installer-uninstall_cmd: Command used to uninstall an RPM file
[rpm_installer]
verify_cmd=rpm −E
7.6. User Data Client
7.6.1. user_auth-max_auth_users_allowed-Maximum users allowed
The maximum number of users allowed to be authenticated to the device.
7.6.2. user-service_gateway_url: URL of the JLR Service Gateway
The user-service_gateway_url is the URL of the JLR Service Gateway.
7.6.3. user-auth_client_id: OAuth client identity
The user_auth-client_id configuration value changes the client_id parameter for all OAuth requests made by the User Data client.
[user_auth]
client_id=REDUP_Client
7.6.4. user-enable_remove_all: Remove all users in the database and OMA-DM tree
When set to 1 the user-enable_remove_all configuration option will invoke the delete_all_users method on start-up.
[user]
enable_remove_all=1
In some alternative embodiments, REDUP M2M Cloud is a product designed to provide the capability to remotely manage and update connected devices in scenarios where an M2M gateway is used. The M2M gateway acts as a proxy to connected devices, providing local services. REDUP Cloud provides Enterprise services for multiple M2M gateways. The main services are remote software management and event data collection and analysis. There are two objectives. The first is to remove the need to handle devices on-site, which obfuscates the expense incurred through returning devices to service centers for maintenance and upgrade. The second is to provide an aggregation point for streams of data into a Big Data processing environment as a platform for predictive analytics.
The product's features may include: Cloud service to remotely manage, deliver and install software updates and configuration files; Secure distribution and installation of software updates to M2M gateway, Secure intelligent device software management and delivery to gateway for installation; Cloud to gateway notifications; Standards compliant OMA-DM/IETF software update client server protocol; Segmentation service to enable targeted software delivery to intelligent device groups; Rules Engine for software version checking; Network agnostic client-server communication; Efficient use of managed connection resource; Optional device client for telematic event reporting; Optional back-end big data solution. Reporting, predictive and diagnostic analytics platform; Workflow enabled platform.
The product may be compatible with REDUP M2M Gateway; REDUP Cloud Software Manager; REDUP Analytics; REDUP Update Client—Client to download and install updates and configuration files into the devices; REDUP Event Notification Client; REDUP Big Data reporting and Analytics.
The Value of REDUP M2M Cloud
Benefits for the OEM may include: Secure cloud storage and delivery of software updates and configuration to the M2M gateway and Intelligent Devices; Secure throughout: communications, authentication and integrity; Over the air updates delivery reduces the cost of management; Single enterprise environment for remotely managing updates to devices; Customizable software delta creation tools; Bearer aware cost efficient software download process; Multiple module updates installed according to version and sequencing rules; Aggregation point for reported data for processing and analytics.
Benefits for the device administrator may include: Admin Console; Aggregated data analytics; Safe remote updates; Less device downtime; Software updating for new features and configuration; Prognostic reporting prevents serious faults developing; Reduces cost of ownership.
2.1 REDUP M2M Overview
The M2M Cloud product is build using REDUP technology. This is a suite of client/server components supporting remote cloud software management server, client reporting and analytics. The product is highly customizable and can be readily integrated into various scenarios.
A typical M2M deployment scenario is shown in
Many embedded systems are now connected devices. Cloud connectivity means that many functions, previously requiring manual intervention, can now be performed remotely. The sophistication of services provided by the Internet of Things increases as the cost and availability of processing improves. Software-based features are much more flexible than hardware but the downside is that the complexity of the solution increases. With complexity comes the risk that software is delivered without every feature interaction being tested fully. This can mean product recalls or expensive field visits. However, with cloud connectivity, remote software management can substantially mitigate this problem. See
Using the M2M Cloud, device network administrators can remotely monitor the state of the network and analyze collected data to proactively plan and deploy software and configuration updates. This prognostic approach to software mean that faults can be corrected before they become a serious problem and, potentially, before network administrators are aware of emerging issue. The REDUP M2M Cloud solution enables updates to be securely downloaded and installed onto devices. See
In a typical deployment, devices report events regarding activity including software faults. The M2M gateway transcodes sensor data into a format conforming to the Resource Description Framework (RDF). The event reports are uploaded to the server. Product and device related analytics helps to manage the devices and analyze device data. This helps software updates to be planned and deployed via the REDUP Cloud Software Manager. Updates are triggered via notifications and delivered to the Gateways over secure channel using one of a number of types of secure link (VPN, IPSEC, TLS). The M2M gateway distributes updates to devices according to device specific update mechanisms.
2.2 Software and Configuration Management
Devices can be segmented into groups to enable the targeted application of updates. Updates can be applied to the device according to rules based on a flexible configuration of parameters including version numbers and other model dependencies.
The Cloud to gateway software update process is based on the OMA-DM protocol. The REDUP Update client manages the download of software updates via a Managed Object tree. See
The managed object tree is part of the update client in the M2M gateway. The MO tree helps the update client to manage software objects on behalf of each connected device.
The Cloud Software Manager supports devices using a sophisticated package management process. Intelligent device products are mapped to segments. Each segment is a structure that get be use to target software updates to specific collections of devices that match the product.
Packages of software updates and configuration are assigned to segments. In this way an M2M gate can pick up software changes for any device connected to it by passing the device agents back to the Cloud Software Manager as part of a software update request. This is shown in
In a typical scenario like that shown, the gateway is responsible for multiple devices and the cloud server is set up to handles each device product as a separate segment. In the case above, the system is managing three just devices. Two are product A types and one Product B. Three segments are therefore set up on the server, corresponding to product A and B and one for the gateway itself. Versioned packages of software updates and configuration are managed for the devices and these are assigned to the proper segments.
When software changes are published, notifications are sent to gateways and server rules decide which versions of software are delivered to the devices by acting through the OMA-DM managed object tree.
2.3 REDUP Client
The REDUP M2M Cloud solution includes client products that are incorporated into the M2M gateway. This section outlines the services of the clients.
2.3.1 Client Architecture
The M2M client comprises three main components: the Update Client, the Cloud Notification Client and the Log Event Notification Client. These can be separately deployed as appropriate in different scenarios.
The update client is responsible for coordinating with the cloud server to download the latest updates that are appropriate for the segments to which gateway-managed devices belong. Segment management is a feature of the cloud server (see section [00725]).
The notification client allows the M2M gateway to notify of software updates. In addition it can act as a general publish/subscribe service to the gateway.
The event notification client is responsible for collecting and passing device data to a big data repository. The Event notification client is able to augment the logging event with additional supporting information extracted from the M2M gateway. For example, a software installation event can trigger the event notification engine to collect the complete manifest of software components so that the complete software state of the device can be updated to the sever after a software change is made. The design and implementation of logging scenarios is specified as part of a deployment project.
2.3.2 REDUP Update Client
The REDUP Client is a component resident on the M2M gateway. It provides the capability for device component software, media or configuration to be updated remotely and for the device to report installation and software faults via the M2M gateway. The update client can be configured to run as part of the M2M gateway. See
The product provides the following client side features: OMA-DM compliant download; Secure download of update package; Rollback; External System control of download and install; Connection control and resume download; Customizable installation client for updates.
A typical update sequence is shown in
2.3.3 Supported Platforms
The supported platforms operating systems (Oss) include: Linux; Android.
2.3.4 Typical client size
The deployed size of the update client varies on the complexity of updates but a typical size of the complete update client is around 20 k, not including libraries.
2.3.5 Libraries:
libdmclient, libxml2, libwbxml, libsoap, sqlite, libcurl
2.3.6 REDUP Cloud Notification Client
The REDUP Cloud Notification Client is a publish-and-subscribe-based notification service. It can be installed as part of the gateway. The gateway business logic is able to create subscriptions via an API to the subscription manager. See
Notifications from the cloud server are delivered to the client. A notification registration API allows notifiable components to register a class of notifications. A notification router component of the client is able to identify the subscribing component and deliver notifications via a callback.
2.3.7 Libraries:
MQTT
2.3.8 REDUP Log Event Notification Client
The log event notification client (LEN) is a flexible component installed in the gateway that accepts log event and processes these for uploading into a cloud big data storage repository. The LEN provides logging in a graph format that facilitates very flexible and configurable logging without the need to tightly couple the gateway's data model into the back end system. See
Events are triggered within the gateway or within intelligent devices. In the gateway events may be triggered for any number of reasons. These include: Software and configuration updates events; System fault and performance events; System service usage notifications; Gateway Telematic data.
In addition intelligent devices that produce telematic data can deliver the data via the gateway and the LEN. Gateways will normally transcode intelligent device reported data into a homogeneous data model such as RDF before passing it onto the LEN.
The client records events according to rules and caches the records onto the solid state or flash storage device. The records are offloaded to the cloud server under the control of connectivity business logic. For example, on a project basis, the upload logic may be on a schedule basis, business logic control or available connectivity.
2.3.9 Supported Platforms
The supported platforms OSs include: Linux; Android.
2.4 The REDUP VRM Server—shown in
2.4.1 The M2M Cloud Server
The REDUP Cloud Server solution is a J2EE application that operates in a clustered configuration for resilience, performance and scalability, utilizing a relational database that may also be clustered.
The live system sits in the cloud and can be hosted in many environments including Amazon EC2. Typical installations include a reference (or pre-live) installation and a test installation to support system staging, acceptance and upgrades.
3.1 Standard Server Support
The REDUP Server is available to be installed on server platforms including the following:
REDUP Server—Supported systems
Application Server—JBoss/Tomcat
Relational Database—Oracle or MySQL
Operating System—Linux
REDUP Server is typically implemented on industry standard Web Server class servers—dual processor, 4 Gbytes RAM, local disk for OS and application installation and shared network storage or SAN for shared data access. The REDUP Server application scales horizontally according to the number of devices supported.
3.2 Physical Deployment—shown in
In some alternative embodiments, REDUP Vehicle Relationship Management (VRM) is a product designed to provide the capability to remotely manage and update vehicle software, and to collect vehicle telematic data for the purpose of predictive analytics. Vehicle Relationship Management is akin to customer relationship management except that the managed relationship is with the car itself. The overall objective is to maintain remote post-sales contact with the vehicle in order to understand the state of functioning of individual cars and, by extension, to understand the state of the product as a whole. The car as a connected device is used for these services.
Features may include:
Software and Asset Update Management
The product facilitates the remote management and update of software and other assets. A console allows the upload and configuration of packages of files targeted for OTA download into connected devices. Packages are managed via a flexible work-flow process appropriate to the type of update. Processes includes: Application Store (Appshop), Software Component Updates (SOTA) and Firmware over the air (FOTA).
The product manager is provided with a selection of tools for the processing of update modules as part of the package upload workflow. For example, the cloud server has a collection of delta algorithm tools, which can be applied to reduce the download size.
Notifications
A cloud based notification service allows the server to inform devices of the availability of software updates. This service can also be used by the OEM as a generalized device or device-user notification service.
The notification service is multimodal, meaning that the cloud service can deliver notifications via a consistent interface to multiple push interfaces supporting mobile devices, connected devices etc.
Analytics
A feature of REDUP is a powerful framework for device-centric predictive analytics. A Log Event Notification Client (LENC) can be integrated into devices to provide a managed data model similar to SNMP but in a Big Data graph format. This allows events to be configured that trigger devices to upload specific information into a big data repository. The system is thus capable of predictive analytics with a wide domain of intelligence, from small-scale questions around individual devices to large-scale questions at a product level.
Telematic Event Reporting
One service of the LEN client is to manage vehicle telematic data in a configurable manner. For example, location and vehicle status information can be managed and delivered back to the repository. Standard reports on vehicle status are available.
Standards Compliant Updates
The REDUP Client supports OMA-DM/IETF protocols for installable content synchronization and download. The system also supports REST and other protocols as a customization.
Secured Distribution
REDUP maintains confidentiality of software and data through a number of techniques. TLS and other protocols are used to secure transactions; Devices are identified and authorized to download software modules via parameters; The integrity of updates is maintained via checksums and certificates.
Vehicle Segmentation
Vehicles are grouped and handled using manager defined segments. A segment is linked to vehicle parameters. Packages of update can be assigned to segments. The result is that a vehicle will potentially download the files within the segments to which the vehicle belongs. The selection of actual files downloaded will be subject to rules.
Rules Engine
Rules Engine is a component of REDUP that facilitates software version and other dependency checking between the files in each segment.
Big Data
REDUP uses a Big Data repository to provide the scale needed to store and manage the volumes of data associated with large numbers of connected vehicles.
This repository is specifically designed to provide the flexibility needed to accommodate new data types as the complexity of the Connected Devices and the way in which they are used develops.
Workflow Enabled Platform
A workflow enabled cloud platform provides the flexibility to be able to customize the processes for software management and delivery. For example, the server can be integrated with an existing quality assurance (QA) process or be used to define a process specific to the solution. The workflow enables pluggable components such as delta algorithms or content handlers.
The product may be compatible with: REDUP Cloud Software Manager—Remote managed software delivery; REDUP Update Client—Vehicle client supporting software download, install and rollback; REDUP Event Notification Client; REDUP Big Data reporting and Analytics.
The Value of REDUP Vehicle Relationship Management
Benefits for the OEM may include: Over the air updates reducing the need to visit dealer; Single enterprise environment for remotely managing software updates to the vehicle; Update of vehicles applications, software components and ECU firmware; Remote upload of vehicle software manifest for targeted updates; Flexible models for user control of software downloads and installation; Backend software update management; Customizable software delta creation tools; Bearer aware cost efficient software download process; Secure cloud storage and delivery of software-supporting package integrity, authentication and authorization; Multiple module updates installed according to version and sequencing rules.
Benefits for Tier 1 may include: Provides managed update service; Reporting of tier 1 product updates; Product management makes informed decisions based on live vehicle data; Vehicle fault event notification forwarding for diagnostic and predictive analytics.
Benefits for the Vehicle Owner may include: Safe remote updates; Fewer trips to dealer; Software updating for new features and applications; Prognostic reporting prevents serious faults developing; Reduces cost of ownership.
2.1 REDUP VRM Overview
The REDUP VRM product is built using REDUP technology. This is a suite of client/server components supporting remote cloud software management server, client reporting and analytics. The product is highly customizable and can be readily integrated into various scenarios. See
Many OEMs produce vehicles today that provide the capability to work with mobile devices. The marriage of the mobile device with the vehicle provides a much-needed means of connectivity, which is an enabler for powerful in-vehicle applications and services. The present situation is, however, only the precursor to the vehicle as a connected device with its own SIM/WIFI access. The connected car heralds a revolution in VRM services. The is vehicle is able to report the configuration of installed software and how well the software is functioning
Product Managers and analysts are able to process the data collected and proactively plan and deploy software updates. This prognostic approach to software mean that faults can be corrected before they become a serious problem and potentially before the driver is aware of an issue arising. The REDUP VRM solution enables updates to be downloaded securely to the vehicle where either the driver or the dealer is able to apply the update.
2.2 REDUP In-Vehicle Client
2.2.1 Client Architecture
The REDUP VRM client comprises three main components: the Update Client, the Cloud Notification Client and the Log Event Notification Client. These can be separately deployed as appropriate in different scenarios.
The update client is responsible for coordinating with the cloud VRM server to download the latest updates. The REDUP cloud VRM server is described in section 2.3.
The notification client allows the VRM cloud to notify vehicles of software updates. In addition is can act as a general publish/subscribe service to the gateway.
The event notification client is responsible for logging events to the big data repository. Event notification is able to augment the logging event with additional supporting information extracted from the vehicle. For example a software installation event can trigger the event notification engine to collect the complete manifest of software components so that the complete software state of the vehicle can be updated to the sever after a software change is made.
2.2.2 REDUP Update Client
The REDUP Client is a client resident on the vehicle. It provides the capability for the vehicle software to be updated remotely and for the vehicle to report installation and software faults. The update client can be configured to run as part of the vehicle head unit or as a dedicated update ECU. See
The product provides the following client side features: OMA-DM compliant download; Secure download of update package; Rollback; Driver/System control of download and install; Connection control and resume download; Customizable installation client for firmware/component/application updates.
The Update Client
A typical update sequence is shown in
Types of updates supported include: In car applications; Software components; ECU Firmware.
2.2.3 Supported Platforms
The supported platform Operating Systems (OSs) include: Linux; Android.
2.2.4 Typical client size
The deployed size of the update client varies based on the complexity of updates.
2.2.5 Libraries
libdmclient, libxml2, libwbxml, libsoap, sqlite, libcurl
2.2.6 REDUP Cloud Notification Client
The REDUP Cloud Notification Client is a publish-and-subscribe-based notification service. It can be installed as part of the gateway. The gateway business logic is able to create subscriptions via an API to the subscription manager. See
Notifications from the cloud server are delivered to the client. A notification registration API allows notifiable components to register a class of notifications. A notification router component of the client is able to identify the subscribing component and deliver notifications via a callback.
2.2.7 REDUP Log Event Notification Client
The log event notification client (LEN) is a flexible component installed in the gateway that accepts log event and processes these for uploading into a cloud big data storage repository. The LEN provides logging in a graph format that facilitates very flexible and configurable logging without the need to tightly couple the gateway's data model into the back end system. See
Events are triggered within the gateway or within intelligent devices. In the gateway events may be triggered for any number of reasons. These include: Software and configuration updates events; System fault and performance events; System service usage notifications; Gateway Telematic data.
In addition intelligent devices that produce telematic data can deliver the data via the gateway and the LEN. Gateways will normally transcode intelligent device reported data into a homogeneous data model such as RDF before passing it onto the LEN.
The client records events according to rules and caches the records onto the solid state or flash storage device. The records are offloaded to the cloud server under the control of connectivity business logic. For example, on a project basis, the upload logic may be on a schedule basis, vehicle driver control or available connectivity.
2.3 The REDUP VRM Server—shown in
2.3.1 The VRM Server
The REDUP VRM Server solution is a J2EE application that operates in a clustered configuration for resilience, performance and scalability, utilizing a relational database that may also be clustered.
The live system sits in the cloud and can be hosted in many environments including Amazon EC2. Typical installations include a reference (or pre-live) installation and a test installation to support system staging, acceptance and upgrades.
2.3.2.1 Standard Server Support
The SurfKit Server is available to be installed on server platforms including the following:
SurfKit Server—Supported systems
Application Server—JBoss/Tomcat
Relational Database—Oracle 10i or MySQL
SurfKit Server is typically implemented on industry standard Web Server class servers—dual processor, 4 Gbytes RAM, local disk for O/S and application installation and shared network storage or SAN for shared data access. The SurfKitchen application scales horizontally according to the number of devices supported.
2.3.2.2 Physical Deployment—shown in
2.4 Hosting
There are options for hosting. For example, the system can be hosted on Amazon EC2 or in the customers own hosting.
2.4.1 The Solution
In one implementation, the solution involves two discrete environments called LIVE and REFERENCE. The description of these is given below.
Environment—Description
Additional environments may be used internally during development (DEV for development and TEST for internal testing).
2.4.2 SLA (Service Level Agreement)
The system will be managed. The Cloud infrastructure will have a standard monthly availability of 99.99% excluding scheduled downtime. Higher levels of availability are supported.
The Monthly Availability Service Level percentage will be calculated by dividing the total number of minutes in a month (“Monthly Minutes”), excluding Scheduled Maintenance, minus Downtime by Monthly Minutes (excluding Scheduled Maintenance) and multiplying the resulting amount by 100.
For example, in a month where there are thirty (30) days, the total Monthly Minutes are 43,200 minutes. If Downtime is 75 minutes and Scheduled Maintenance is 30 minutes, then the Monthly Availability Service Level is 99.9%, which is calculated as follows:
=(100−99.99)/100*30*24*60=4.23 minute per month
2.5 Managed Services and Operations
An Operations service proactively manages the system once it is live. Operating system and application server/database platform monitoring is performed.
2.5.1 Managed Services
Managed services include: Monitoring; Log file rotation; Internal Ticket management and resolution; Customer review meetings; Scaling reviews.
2.5.2 Monitoring
Service Monitoring is implemented using Icinga, which is a system and network monitoring application. Icinga watches hosts and services specified, alerting to alarms and when they are resolved.
Monitoring allows for a prompt detection of system, platform and service fault(s), reducing uncertainty around the health of the service via dashboards and similar
An Icinga setup is delivered with a set of predefined host and service checks, additional checks can be added as the service evolves. Monitoring will cover these elements of each host/instance:
The monitoring application also includes where applicable a mobile interface for a customer facing interface.
System Level Monitoring may include Hardware/Resources Monitoring (e.g., Ping, CPU Load, CPU Usage, Disk Free Space).
Network Monitoring may include monitoring levels of network traffic.
Platform Level Monitoring may include monitoring of software components.
2.5.3 Notification
All monitoring checks are defined by thresholds; Critical and Warning. Thresholds are thus used to determine the status of alarm(s): OK—Indicates everything is okay, within both thresholds; Warning—Indicates check has exceeded the warning threshold; Critical—Indicates check has exceeded the critical threshold.
Monitoring alarms are distributed via notification mail alerts to REDUP Support engineers at Warning, Critical and Recovery points. The distribution list can be updated to include additional users.
2.5.4 Dashboards
Monitoring (Icinga) dashboards indicate the health of the service in real time, some example dashboards are shown in
Each interactive dashboard can be controlled to expand monitoring status for the entire service, host(s) or an individual check/alarm. See
2.5.5 Reporting
Inbuilt reporting functionality is available allowing administrators and assigned users the rights to configure reports based upon predefined filters. Reporting is specific to the monitoring checks/alarms only, not to be confused with usage data. The example shown in
Historical data is also kept for reporting and trend analysis. See
2.5.6 Backup
Snapshots are used that allow the solution to have a very quick turn around on recovery—typically around 2 hours for a downed instance (This does not include re-integration with the application architecture). Snapshots are taken once a week as a default, and also taken before any system or application upgrades for roll back purposes.
2.5.7 Additional Managed Services
Additional services provided include: Applying new CSS; Accommodating upgrades to ensure continuing operation of the Managed Software, and assisting the REDUP Support
Services organization in the installation and configuration of the upgrades on a time available basis; Assisting with system capacity planning and forecasting for the current architecture of the production system running the Software, including interfacing with Motion Computing to understand potential loads on the system due to Motion computing-planned events, marketing campaigns; Managing the addition of necessary additional system resources, such as servers and storage, including for backup and recovery; Managing configuration of the system to accommodate changes by Motion Computing and required third-party software providers.
2.6 Support Services
Support services include the following: Active monitoring of system; Incident ticket management; Fault correction; Help desk services.
In some alternative embodiments, REDUP facilitates harnessing the potential of data in connected and interconnected devices, and addressing the associated growing markets that are transforming businesses. REDUP end-2-end tools and services help companies not only make great products but to make products which are not left behind in the fast pace of change. REDUP facilitates extracting data from connected devices, merging this data with other big data sets and driving this via business solutions into improving customer's product, device and end user relationships.
Tag Line: The Internet of Vehicles. Consumers expect a Smartphone like mobile services experience in their car. Car Manufacturers want to learn more about their products and how it is used. See
Auto Case. See
FOTA/SOTA Experience—Joint Solution Scope REDUP provides the integrated, cloud-based solution for remote vehicle software configuration management. Movimento Venturo provides the market leading vehicle software re-flash technology. Together we deliver secure and robust in-vehicle software updates with a proven end-to-end workflow for creating, verifying, packaging and installing software updates to any Electronic Control Unit (ECU) of a connected car. Supports all possible automotive communication technologies, including CAN, USB, Ethernet, FlexRay, LIN, MOST. See
FOTA/SOTA Experience—Principle Workflow. See
The REDUP Solution. See
Architecture Overview. See
REDUP Feature Summary. See
Target Customer.
Initial target segment is Automotive for REDUP VRM
Second target are players in other M2M Verticals
Third focus are Carriers and Infrastructure Vendors
Enablers for REDUP technology sales are Silicon Suppliers
Example: The Connected Car Market—Potential Customers and Value. See
Example of visualization of data. See
Business Value of REDUP
Customer Challenges
REDUP Business Value
REDUP addresses typical immediate customer requirements
REDUP is a solution that addresses the need to enable customers to maximise the monetization potential of their devices
Automotive Tagline: Enabling the Internet of Vehicles. With REDUP we have a platform that can respond with a clear value proposition to various types of expressed customer needs including:
Vehicle Relationship Management
Business challenges:
Solution:
Benefits:
Vehicle FOTA. See
Business challenges:
Solution:
Benefits:
Vehicle App Store. See
Business challenges:
Solution:
Benefits:
Vehicle Device Management
Business challenges:
Solution:
Benefits:
REDUP Technical Overview. See
Specifications:
Vehicle relationship management:
VRM Workflow drives main use cases:
Cloud Hosted SOTA Platform. See
Cloud Hosted Storefront Platform. See
Overview of Remote SW Management
Product: Manufactured System
Embedded System Parts: Separately manufactured units. E.g. Auto ECUs
SW/HW Components
ES Parts Management Model—Auto Case. See
REDUP SW Parts Management Concept. See
DOAP And Remote Parts management. See
What to update
SOTA: File-based updates within a partition file system
FOTA: Partition image update
AOTA: Catalogue-based selection and install
Product Management Model—Auto Case. See
How it works. See
Modules, Packages and Segments. See
Software Update Modules
Packages
Segments
Mix Mode—XOTA. See
Multi-Segment example. See
Segment Details
Role of the segment
Segments filter device members according to immutable product attributes, VIN, model etc.
Segments support complex device software management
Segments link managed components and managed parameters
Segments and Versions Example. See
Segments and Attributes
Attribute Model. See
Managing Parts and Attributes. See
Packages. See
SUM Attributes Flow—problem statement. See
Package Templates—the solution
Software Update Modules (SUM)
SUM Attributes for Rules. See
FOTA Module Preparation. See
Uploading FOTA SUM Modules. See
Uploading FOTA SUM Modules. See
FOTA and Venturo Interworking. See
Overall FOTA Module workflow. See
Security. See
The Value of Big Data. See
Benefits of Semantically tagged Data
REDUP Data Strategy. See
Big Data Architecture. See
Example of Graph Data & Ontologies. See
Federated Databases. See
Big Data and analytics. See
M2M
M2M Services. See
M2M Services and REDUP. See
REDUP Internal Strategy. See
Feature Overview. See
In some alternative embodiments, the following terminology may be used:
LENC allows events to be logged in two ways; via a long-running process, called a Daemon; or by an application directly invoking the Logger API using the shared C library.
3.1. RDF Database
The RDF database is used as a store for RDF triplets. The database exists in two forms;
3.2. Offloader
The Offloader is responsible for uploading RDF triplets extracted from DB to a remote web service. If Offloader was triggered by Reducer to reduce the amount of disk space taken by reduced triplets, it may delete the oldest files in order to free some space.
The Offloader will provide all headers and authentication to the HTTP endpoint.
3.3. Off-board Server
The Off-board server exposes a HTTP endpoint that allows log files to be uploaded when a network connection is available.
A HTTP interface that accepts HTTP POST requests to upload compressed (gzip'd) RDF data in Turtle format from devices Log will be uploaded as files in multipart/formdata encoding. The filename format will be: <Device ID><delimiter><timestamp>.ttl.gz
The REDUP server will ignore the format of the uploaded log files.
One file can be uploaded to the server at a time. Any additional files supplied in the multipart request will be ignored.
The endpoint should accept both content types of text/turtle and application/gzip. In the case of application/gzip the GZIP′d content is assumed to be text/turtle.
Where:
This interface should support HTTP re-directs.
The maximum length of time a request can take should be configurable.
3.3.1. Authentication
The Off-board server HTTP(S) endpoint used by the Offloader is secured by either one of the following mechanisms:
3.3.1.1. Basic Authentication
The device identity (or VIN for Connected Infotainment) will be used as the username.
The password will be the pre-configured shared secret.
3.3.1.2. HMAC Encryption
Authorization: REDUP <DeviceId>:<HMAC>
Where:
Examples:
Where:
Server code calculates hmacSHA1 of uploaded files using command:
openssl dgst −sha1 −hmac “% s” % s
where first % s stands for sha1(password) and second % s is a path to file
The same command can be used on the client side or for test purposes.
3.3.2. Example responses
The JSON body is optional and should contain.
The client should output the requestId to its own internal log output.
3.3.2.1. Successful response
The HTTP error code 200 should be used for a successful response.
3.3.2.2. Invalid request/failed response
The HTTP error code 4XX indicates an invalid request or failure.
3.3.2.3. Server fault
The HTTP error code 5XX indicates a server fault. In this case the HTTP response body is assumed to be untrustworthy.
3.4. Reducer
The Reducer is responsible for ensuring that the RDF database meets the storage requirements of the device by reducing the amount of RDF triplets held by the device.
3.5. Daemon
The Daemon is a long-running process that is customized to the platform. It is responsible for applying the business logic that determines when the Reducer and Offloader are invoked. The Reducer, Offloader and RDF Database are embedded within the Daemon process.
The Daemon uses the C library interface defined by the Logger, Offloader and Reducer.
The Daemon can expose a platform-specific IPC endpoint that can be used by applications to log events. If this is not present then the Daemon will only be responsible for invoking the Reducer or Offloader business logic.
The device requires contextual information about the system. At a minimum this is the identity of the device. If no single device identity can be derived it will need to be composed of multiple elements, E.g. MAC addresses of all network interfaces
3.6. Logger
3.7. Configuration
The Configuration component contains options and settings that change the behavior of LENC at runtime. The configuration is itself an in-memory RDF database, that is loaded from a file on start-up.
Configuration parameters are organized into groups based on the components they alter the behavior of.
3.7.1. Configuration Group: General
3.7.2. Configuration Group: Reducer
3.7.3. Configuration Group: Offloader
3.7.4. Configuration Group: Logger
3.7.5. Interfaces
3.8. Application #1
Application #1 in the component diagram represents an application using the Platform IPC mechanism to record a log event.
3.9. Application #2
Application #2 in the component diagram represents an application using the Shared C Library to record a log event.
4.1. SEQ-001: Application reports an event using the daemon—shown in
4.2. SEQ-002: Reduce triplets in memory database—shown in
Log events received by the Daemon are stored in the in-memory RDF database. If the Daemon runs for a long period, then the log events may be unnecessarily allocated memory space.
If the system loses power unexpectedly then all in-memory triplets will be lost. By periodically reducing the triplets in-memory by flushing to disk, it ensures that not all logging events are lost on power failure.
4.3. SEQ-003: Reduce triplets in filesystem database—shown in
If the free space in the filesytem becomes limited, then the Reducer should remove any extraneous log events that have been stored on disk. These should only be the log files that have not yet been uploaded to a remote server by the Offloader.
4.4. SEQ-004: Application reports logs on behalf of another application—shown in
4.5. SEQ-005: Upload log events to offboard server—shown in
4.6. SEQ-006: Network availability and timers management—shown in
Sometimes there may be a situation when pre-configured periodic timer had no time to complete between LENC startup/shutdown sequence and therefore the upload operation will not be performed. To prevent this case LENC stores the timestamp of the latest successful operation to use it to decide when then next upload should be started.
5. RDF Ontologies
Two ontologies are provided one is for logging and the other describes the components that are logged.
5.1. Logging Ontology
Log events are reported in an RDF format ontology. This is shown in
Notifications are raised by one component on another component. Notifications effectively report on the software status of connected infotainment, Reports can be one of four types:
A report can have multiple components. For example a software update report can have a LogReport giving more information on the status after update.
5.2. Embedded System Ontology
Components report according to an embedded systems ontology. The embedded system ontology is shown in
The embedded system ontology allows the specification of versioned components. The range of notification is something of type ESComponent. This includes components of CI and HTML5 applications. Components can be versioned so that the server can link individual classes and components to versions stored in the repository.
HTML5 applications may log RDF or just simple strings. It should be possible for the cloud server to search for logs relating to a specific applications or a version of an application and apply an application specific ontology to the data to give it meaning.
6.1. Device Identity
The device identity needs to be set via the DeviceId configuration value.
6.1.1. lenc_device_identity: Returns the current device identity.
Implemented by the proxy component or example application this API will return the current device identity. If the device identity cannot be found, or is empty, then NULL shall be returned.
6.2. LENC Iface API
This API should be used by applications wishing to report an error.
6.2.1. lenc_init: Initialize lenc-iface
This method opening a message queue for sending messages to lenc-daemon.
Parameters:
Returns: lenc_handle_t which is used for message queue descriptor if success and −1 if fails
6.2.1.1. Definition
extern lenc_handle_t lenc_init( )
6.2.1.2. Example Usage
lenc_init( )
6.22 lenc_report_event: Allow a component to report a log event on behalf of another component
This method sends a REPORT_MESSAGE message to lenc-daemon.
Parameters:
Returns: 0 if success and −1 if fails
6.2.2.1. Definition
extern int lenc_report_event(lenc_handle_t *handle, char* category, char* reported_by, time_t reported_at, char* component, time_t occurred_at, lenc_severity_e severity, char *message);
6.2.2.2. Example Usage
lenc_report_event(
handle,
“StatusReport”,
“comp:componentName”,
1373891691000,
<http://website.com/components/WebserverV1>,
1373891691000,
4,
“OMA-DM sync completed.”
);
6.2.2.3. RDF result
6.2.3. lenc_report_event_with_data: Allow a component to report a log event on behalf of another component with additional data associated with log
This method sends a REPORT_MESSAGE message to lenc-daemon.
Parameters:
Returns: 0 if success and −1 if fails
6.2.3.1. Definition
6.2.3.2. Example Usage
lenc_report_event_with_data(
&ds,
“SoftwareUpdateReport”,
“comp:LENC”, 1234567801,
“dlapps:Application1”,
1234567802,
4,
“Application Weather has been updated”,
“log:Offset \“−4\”̂̂xsd:integer; log:Other_integer 789;
log:subcategory \“_lifecycle\”̂̂xsd:string;
log:other_string \“_my_String\”̂̂xsd:string;
log:float_value \“−3.14\”̂̂xsd:double”
);
6.2.3.3. RDF result
not: DWAUZZZ8DZWA123456-2
esm:regarding dlapps:Application1;
log:Offset—4;
log:Other_integer 789;
log:Timestamp “1234567802”̂̂xsd:long;
log:float_value −3.14;
log:message “Application Weather has been updated”̂̂xsd:string;
log:other_string “_my_String”̂̂xsd:string;
log:reportedAt “1234567801”̂̂xsd:long;
log:reportedBy comp:LENC;
log:severity log:WARNING;
log:subcategory “_lifecycle”̂̂xsd:string;
a esm:SoftwareUpdateReport.
6.2.3.4. Example Usage
lenc_report_event_with_data(
&ds,
“SoftwareUpdateReport”,
“comp:LENC”,
1234567801,
“dlapps:Application1”,
1234567802,
4,
“Application Weather has been updated”,
“log:Offset \“−4\”̂̂xsd:int; log:Other_integer 789;
log:long_value \“1373891691000\”̂̂xsd:long; log:Other_long 1373891691000;
log:subcategory \“_lifecycle\”̂̂xsd:string; log:other_string \“my String\”;
log:float_value \“−3.14\”̂̂xsd:double; log:other_float −3.14”
);
6.2.3.5. RDF result
not: DWAUZZZ8DZWA123456-3
esm:regarding dlapps:Application1;
log:Offset “−4”̂̂xsd:int;
log:Other_integer 789;
log:Other_long 1373891691000;
log:Timestamp “1234567802”̂̂xsd:long;
log:float_value −3.14;
log:long_value “1373891691000”̂̂xsd:long;
log:message “Application Weather has been updated”̂̂xsd:string;
log:other_float −3.14;
log:other_string “my String”;
log:reportedAt “1234567801”̂̂xsd:long;
log:reportedBy comp:LENC;
log:severity log:WARNING;
log:subcategory “_lifecycle”̂̂xsd:string;
a esm:SoftwareUpdateReport.
6.2.4. lenc_suspend: Allow a component to suspend lenc-demon
This method sends a SUSPEND_MESSAGE message to lenc-daemon.
Parameters:
Returns: 0 if success and −1 if fails
6.2.4.1. Definition
extern int lenc_suspend(lenc_handle_t *handle);
6.2.5. lenc_resume: Allow a component to resume lenc-demon
This method sends a RESUME_MESSAGE message to lenc-daemon.
Parameters:
Returns: 0 if success and −1 if fails
6.2.5.1. Definition extern int lenc_resume(lenc_handle_t *handle);
6.2.6. lenc_shutdown: Allow a component to shutdown lenc-demon
This method sends a SHUTDOWN_MESSAGE message to lenc-daemon.
Parameters:
Returns: 0 if success and −1 if fails
6.2.6.1. Definition
extern int lenc_shutdown(lenc_handle_t *handle);
6.2.7. lenc_close: Close lenc-iface
This method closes a message queue which used for sending messages to lenc-daemon.
Parameters:
Returns: 0 if success and −1 if fails
6.2.7.1. Definition
extern int lenc_close(lenc_handle_t *handle);
6.3. LENC Daemon API
This API should be used by processes wishing to implement the LENC daemon.
6.3.1. DaemonInit: Initialize the daemon (was lenc_deamon_startup)
This API should be called when the LENC Daemon process starts.
Parameters:
6.3.1.1. Definition
6.3.2. DaemonShutdown: Shutdowns the daemon (was lenc_daemon_shutdown)
This API should be called before the LENC Daemon process is halted.
6.3.2.1. Definition
void DaemonShutdown( )
6.3.3. DaemonNetworkStatusChanged: Indicate network connectivity has changed
void DaemonNetworkStatusChanged(bool connected)
7. Connected Infotainment Components—See
Connected Infotainment requires a modification of the LENC architecture. The LENC Daemon is embedded within the REDUP product, which itself is embedded within an “Update Client Wrapper” component.
The “Update Client Wrapper” provides an interface to the REDUP client and importantly includes a CORBA IPC API.
The CORBA API for logging includes a mirror of the LENC Logger API, acting as the Daemon component in the LENC sequences.
8. Connected Infotainment FIS
Connected Infotainment describe the flows an interactions between components as Feature Interaction Scenarios (FIS). LENC satisfies, or has partial involvement in some of these flows. This section describes the related FIS, and the role required by LENC.
8.1. FIS_LG_001: Logging an issue—Application Execution Environment creates a log—shown in
8.2. FIS_LG_002: Logging an issue—Connected Infotainment application creates a log—shown in
8.3. FIS_LG_003: Logging an issue—Create log record
The scope of logging is any component of the application environment, CI application or the update module installation process. Logs are in a structured format that supports analysis of the log events. Logs can be associated with any area of software organization and operation. These include, software faults, reporting of installation success or general application function. Log levels can be used to classify logging data and which levels are persisted can control the verbosity of logging and it is expected that the focus of logging will change at different stages of production. Preconditions: • The system is booted sufficiently for components to potentially log. Postconditions: Log has been created and stored on the file system Actors CI Component.
8.4. FIS_LG_004: Log Use Cases::Logging an Issue UC::Update Module Installation Process Creates Log
8.5. FIS_LG_005: Log Use Cases::Logging an Issue UC::Upload Log
8.6. FIS_LG_006: Trigger Log Upload—Manage log preference—shown in
Reading global user settings for logging from Settings feature application.
8.7. FIS_LG_007: Log Use Cases::Trigger Log Upload UC::Trigger Log Update
Logs are collected by the log manager and stored temporarily in the file store until they can be uploaded to the server. The log manager will immediately try to send the logs if connectivity is present. Preconditions: Postconditions: Actors: logging server.
8.8. FIS\LG_008: Remove log files after upload
8.9. System shutdown
In some alternative embodiments, the following exemplary REDUP—Client Server Scenarios may be utilized.
1. Installation on new applications
This section covers scenarios when only new applications are installed, but no existing applications are updated.
1.1. Installation—sunny day scenario
1.1.1. Sync 1: Server informs client of App1 as {random1}
1.1.1.1. Server->Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
1.1.1.2. Client->Server: Client responds with empty local FUMO OMA-DM tree
[empty]
1.1.1.3. Server->Client: Server adds FUMO node representing App1
ADD ./Vendor/Website/Packages/{random1}
ADD ./Vendor/Website/Packages/{random1}/State: IDLE
ADD ./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
EXEC ./Vendor/Website/Packages/{random1}/DownloadAndUpdate
1.1.2. Client installs update successfully
./Vendor/Website/Packages/{random1}/State: UPDATE_SUCCESSFUL_HAVE_NO_DATA
./Vendor/Website/Packages/{random1}/Ext/State: POST_CUSTOM_INSTALL_OK
1.1.3. Sync 2: Client indicates installation is successful
1.1.3.1. Server->Client: Request list of Packages node
GET ./Vendor/Website/Packages
1.1.3.2. Client->Server: Client responds with a {random1} node that shows update successful
./Vendor/Website/Packages/{random1}/PkgName: App1
./Vendor/Website/Packages/{random1}/PkgVersion: 1
./Vendor/Website/Packages/{random1}/State: UPDATE_SUCCESSFUL_HAVE_NO_DATA
./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
By default the client will remove the downloaded file after installation the FUMO State value will be UPDATE_SUCCESSFUL_HAVE_NO_DATA. If the downloaded file remains on disk, then the State value will be UPDATE_SUCCESSFUL_HAVE_DATA.
1.2. Multiple attempts at installing the same application
1.2.1. Sync 1: Initial application of App1 as {random1}
1.2.1.1. Server->Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
1.2.1.2. Client->Server: Client responds with empty local FUMO OMA-DM tree
[empty]
1.2.1.3. Server->Client: Server adds FUMO node representing App1
ADD ./Vendor/Website/Packages/{random1}
ADD ./Vendor/Website/Packages/{random1}/State: IDLE
ADD ./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
EXEC ./Vendor/Website/Packages/{random1}/DownloadAndUpdate
1.2.2. Client applies the update but fails
As a result of the installation, the client will set the ./State and ./Ext/State nodes respectively.
./Vendor/Website/Packages/{random1}/State: UPDATE_FAILED_HAVE_NO_DATA
./Vendor/Website/Packages/{random1}/Ext/State: VERIFY_FAILED
1.2.3. Sync 2: Server discovers installation of {random1} has failed, and creates
{random2}
1.2.3.1. Server->Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
1.2.3.2. Client->Server: Report {random1} FUMO node has failed to install
The client responds with the updated FUMO ./Ext/State/ and ./State/ nodes indicating that the update has failed.
./Vendor/Website/Packages/{random1}/PkgName: App1
./Vendor/Website/Packages/{random1}/PkgVersion: 1
./Vendor/Website/Packages/{random1}/State: UPDATE_FAILED_HAVE_NO_DATA
./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
1.2.3.3. Server->Client: Delete {random1}, and ADD and EXEC {random2}
The server informs the client that it should remove the erroneous FUMO node in ./Vendor/Website/Packages/{random1}. It will also add a new FUMO node representing the App1 as {random2}
DEL ./Vendor/Website/Packages/{random1}
ADD ./Vendor/Website/Packages/{random2}
ADD ./Vendor/Website/Packages/{random2}/State: IDLE
ADD ./Vendor/Website/Packages/{random2}/EXT/FileVersionID: {uri: App1 v.1}
EXEC ./Vendor/Website/Packages/{random2}/DownloadAndUpdate
1.2.4. Client attempts to apply update, but encounters error and rollbacks
The client will remove the FUMO node for the {random1} FUMO node in its local OMA-DM tree.
If the ./DownloadAndUpdate URL for both {random1} and {random2} FUMO nodes is the same, then it is highly likely that the installation of App1 fails again. The client will update the {random2} FUMO node states.
./Vendor/Website/Packages/{random2}/State: UPDATE_FAILED_HAVE_NO_DATA
./Vendor/Website/Packages/{random2}/Ext/State: VERIFY_FAILED
These changes will not be apparent to the server until the next sync.
1.2.5. Sync 3: Server discovers installation of {random2} and {random1}
has failed, and creates {random3}
1.2.5.1. Server->Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
1:2.52 Client->Server: Client responds with {random1} and {random2}
./Vendor/Website/Packages/{random1}/PkgName: App1
./Vendor/Website/Packages/{random1}/PkgVersion: 1
./Vendor/Website/Packages/{random1}/State: UPDATE_FAILED_HAVE_NO_DATA
./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
./Vendor/Website/Packages/{random2}/PkgName: App1
./Vendor/Website/Packages/{random2}/PkgVersion: 1
./Vendor/Website/Packages/{random2}/State: UPDATE_FAILED_HAVE_NO_DATA
./Vendor/Website/Packages/{random2}/EXT/FileVersionID: {uri: App1 v.1}
1.2.5.3. Server->Client: Delete {random2} and {random1}. ADD and EXEC {random3}
DEL ./Vendor/Website/Packages/{random1}
DEL ./Vendor/Website/Packages/{random2}
ADD ./Vendor/Website/Packages/{random3}
ADD ./Vendor/Website/Packages/{random3}/State: IDLE
ADD ./Vendor/Website/Packages/{random3}/EXT/FileVersionID: {uri: App1 v.1}
EXEC ./Vendor/Website/Packages/{random3}/DownloadAndUpdate
1.2.6. Client deletes FUMO nodes for {random1} and {random2}
DEL ./Vendor/Website/Packages/{random1}: OK
DEL ./Vendor/Website/Packages/{random2}: OK
1.2.7. Client attempts to apply update, but encounters error and rollbacks
./Vendor/Website/Packages/{random3}/State: UPDATE_FAILED_HAVE_NO_DATA
./Vendor/Website/Packages/{random3}/Ext/State: VERIFY_FAILED
1.2.8. Sync 4: Server discovers installation of {random3}, {random2}, {random3} have failed, and creates {random4}
1.2.8.1. Server->Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
1.2.8.2. Client->Server: Client responds with {random1}, {random2} and {random3}
./Vendor/Website/Packages/{random1}/PkgName: App1
./Vendor/Website/Packages/{random1}/PkgVersion: 1
./Vendor/Website/Packages/{random1}/State: UPDATE_FAILED_HAVE_NO_DATA
./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
./Vendor/Website/Packages/{random2}/PkgName: App1
./Vendor/Website/Packages/{random2}/PkgVersion: 1
./Vendor/Website/Packages/{random2}/State: UPDATE_FAILED_HAVE_NO_DATA
./Vendor/Website/Packages/{random2}/EXT/FileVersionID: {uri: App1 v.1}
./Vendor/Website/Packages/{random3}/PkgName: App1
./Vendor/Website/Packages/{random3}/PkgVersion: 1
./Vendor/Website/Packages/{random3}/State: UPDATE_FAILED_HAVE_NO_DATA
./Vendor/Website/Packages/{random3}/EXT/FileVersionID: {uri: App1 v.1}
1.2.8.3. Server->Client: Delete {random1}, {random2}, {random3} and install {random4}
DEL ./Vendor/Website/Packages/{random1}
DEL ./Vendor/Website/Packages/{random2}
DEL ./Vendor/Website/Packages/{random3}
ADD ./Vendor/Website/Packages/{random4}
ADD ./Vendor/Website/Packages/{random4}/State: IDLE
ADD ./Vendor/Website/Packages/{random4}/EXT/FileVersionID: {uri: App1 v.1}
EXEC ./Vendor/Website/Packages/{random4}/DownloadAndUpdate
1.2.9. Client deletes FUMO nodes for {random1}, {random2} and {random3}
DEL ./Vendor/Website/Packages/{random1}: OK
DEL ./Vendor/Website/Packages/{random2}: OK
DEL ./Vendor/Website/Packages/{random3}: OK
1.2.10. Client successfully installs FUMO node {random4}
./Vendor/Website/Packages/{random4}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random4}/Ext/State: POST_CUSTOM_INSTALL_OK
1.2.11. Sync 5: Server discovers {random4} installed successfully
1.2.11.1. Server->Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
1.2.11.2. Client->Server: Report {random4} FUMO node has installed successfully
./Vendor/Website/Packages/{random4}/PkgName: App1
./Vendor/Website/Packages/{random4}/PkgVersion: 1
./Vendor/Website/Packages/{random4}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random4}/EXT/FileVersionID: {uri: App1 v.1}
1.3. An application in an update fails reverting all other applications in that update
1.3.1. Sync 1: Server sends three applications to the client
1.3.1.1. Server->Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
1.3.1.2. Client->Server: Client responds with empty local FUMO OMA-DM tree
[empty]
1.3.1.3. Server->Client: Server sends FUMO nodes representing three applications
ADD ./Vendor/Website/Packages/{random1}
ADD ./Vendor/Website/Packages/{random1}/State: IDLE
ADD ./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
EXEC ./Vendor/Website/Packages/{random1}/DownloadAndUpdate
ADD ./Vendor/Website/Packages/{random2}
ADD ./Vendor/Website/Packages/{random2}/State: IDLE
ADD ./Vendor/Website/Packages/{random2}/EXT/FileVersionID: {uri: App2 v.1}
EXEC ./Vendor/Website/Packages/{random2}/DownloadAndUpdate
ADD ./Vendor/Website/Packages/{random3}
ADD ./Vendor/Website/Packages/{random3}/State: IDLE
ADD ./Vendor/Website/Packages/{random3}/EXT/FileVersionID: {uri: App3 v.1}
EXEC ./Vendor/Website/Packages/{random3}/DownloadAndUpdate
1.3.2. Client installs two applications but fails on the third, so reverts all updates
./Vendor/Website/Packages/{random1}/State: UPDATE_FAILED_HAVE_DATA
./Vendor/Website/Packages/{random1}/Ext/State: VERIFY_OK
./Vendor/Website/Packages/{random2}/State: UPDATE_FAILED_HAVE_NO_DATA
./Vendor/Website/Packages/{random2}/Ext/State: VERIFY_FAILED
./Vendor/Website/Packages/{random3}/State: DOWNLOAD_COMPLETE
./Vendor/Website/Packages/{random3}/Ext/State: DOWNLOAD_COMPLETE
1.3.3. Sync 2: Server discovers installation of applications has failed and re-sends FUMO nodes
1.3.3.1. Server->Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
1.3.3.2. Client->Server: Client indicates in FUMO states that all updates have failed
./Vendor/Website/Packages/{random1}/PkgName: App1
./Vendor/Website/Packages/{random1}/PkgVersion: 1
./Vendor/Website/Packages/{random1}/State: UPDATE_FAILED_HAVE_DATA
./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
./Vendor/Website/Packages/{random2}/PkgName: App2
./Vendor/Website/Packages/{random2}/PkgVersion: 1
./Vendor/Website/Packages/{random2}/State: UPDATE_FAILED_HAVE_NO_DATA
./Vendor/Website/Packages/{random2}/EXT/FileVersionID: {uri: App2 v.1}
./Vendor/Website/Packages/{random3}/PkgName: App3
./Vendor/Website/Packages/{random3}/PkgVersion: 1
./Vendor/Website/Packages/{random3}/State: DOWNLOAD_COMPLETE
./Vendor/Website/Packages/{random3}/EXT/FileVersionID: {uri: App3 v.1}
1.3.3.3. Server->Client: Server deletes previous FUMO nodes and creates new ones
DEL ./Vendor/Website/Packages/{random1} (App1)
DEL ./Vendor/Website/Packages/{random2} (App2)
DEL ./Vendor/Website/Packages/{random3} (App3)
ADD ./Vendor/Website/Packages/{random4} (App1)
ADD ./Vendor/Website/Packages/{random5} (App2)
ADD ./Vendor/Website/Packages/{random6} (App3)
1.3.4. Client deletes FUMO nodes associated with failed updates
DEL ./Vendor/Website/Packages/{random1}: OK
DEL ./Vendor/Website/Packages/{random2}: OK
1.3.5. Client successfully installs new FUMO nodes
./Vendor/Website/Packages/{random4}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random4}/Ext/State: POST_CUSTOM_INSTALL_OK
./Vendor/Website/Packages/{random5}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random5}/Ext/State: POST_CUSTOM_INSTALL_OK
./Vendor/Website/Packages/{random6}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random6}/Ext/State: POST_CUSTOM_INSTALL_OK
1.3.6. Sync 3: Server discovers App1, App2 and App3 installed successfully
1.3.6.1. Server->Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
1.3.6.2. Client->Server: Report {random4}, {random5}, {random6} installed successfully
./Vendor/Website/Packages/{random4}/PkgName: App1
./Vendor/Website/Packages/{random4}/PkgVersion: 1
./Vendor/Website/Packages/{random4}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random4}/EXT/FileVersionID: {uri: App1 v.1}
./Vendor/Website/Packages/{random5}/PkgName: App2
./Vendor/Website/Packages/{random5}/PkgVersion: 1
./Vendor/Website/Packages/{random5}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random51/EXT/FileVersionID: {uri: App2 v.1}
./Vendor/Website/Packages/{random6}/PkgName: App3
./Vendor/Website/Packages/{random6}/PkgVersion: 1
./Vendor/Website/Packages/{random6}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random6}/EXT/FileVersionID: {uri: App3 v.1}
1.4. Client fails to download file
1.4.1. Sync 1: Initial application of App1 as {random1}
1.4.1.1. Server->Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
1.4.1.2. Client->Server: Client responds with empty local FUMO OMA-DM tree
[empty]
1.4.1.3. Server->Client: Server adds FUMO node representing App1
ADD ./Vendor/Website/Packages/{random1}
ADD ./Vendor/Website/Packages/{random1}/State: IDLE
ADD ./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
EXEC ./Vendor/Website/Packages/{random1}/DownloadAndUpdate
1.4.2. Client applies the update but fails
As a result of the installation, the client will set the ./State and ./Ext/State nodes respectively.
./Vendor/Website/Packages/{random1}/State: DOWNLOAD_FAILED
./Vendor/Website/Packages/{random1}/Ext/State: DOWNLOAD_FAILED
1.4.3. Sync 2: Server discovers installation of {random1} has failed, and creates {random2}
1.4.3.1. Server->Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
1.4.3.2. Client->Server: Report {random1} FUMO node has failed to install
The client responds with the updated FUMO ./Ext/State/ and ./State/ nodes indicating that the update has failed.
./Vendor/Website/Packages/{random1}/PkgName: App1
./Vendor/Website/Packages/{random1}/PkgVersion: 1
./Vendor/Website/Packages/{random1}/State: UPDATE_FAILED_HAVE_DATA
./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
1.4.3.3. Server->Client: Delete {random1}, and ADD and EXEC {random2}
The server informs the client that it should remove the erroneous FUMO node in ./Vendor/Website/Packages/{random1}. It will also add a new FUMO node representing the App1 as {random2}
DEL ./Vendor/Website/Packages/{random1}
ADD ./Vendor/Website/Packages/{random2}
ADD ./Vendor/Website/Packages/{random2}/State: IDLE
ADD ./Vendor/Website/Packages/{random2}/EXT/FileVersionID: {uri: App1 v.1}
EXEC ./Vendor/Website/Packages/{random2}/DownloadAndUpdate
1.4.4. Client successfully installs FUMO node {random2}
./Vendor/Website/Packages/{random2}/State: UPDATE_SUCCESSFUL_HAVE_NO_DATA
./Vendor/Website/Packages/{random2}/Ext/State: POST_CUSTOM_INSTALL_OK
1.4.5. Sync 5: Server discovers {random2} installed successfully
1.4.5.1. Server->Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
1.4.5.2. Client->Server: Report {random2} FUMO node has installed successfully
./Vendor/Website/Packages/{random2}/PkgName: App1
./Vendor/Website/Packages/{random2}/PkgVersion: 1
./Vendor/Website/Packages/{random2}/State: UPDATE_SUCCESSFUL_HAVE_NO_DATA
./Vendor/Website/Packages/{random2}/Ext/State: POST_CUSTOM_INSTALL_OK
./Vendor/Website/Packages/{random2}/EXT/FileVersionID: {uri: App1 v.1}
1.5. Client fails to update application paths
1.5.1. Sync 1: Initial application of App1 as {random1}
1.5.1.1. Server->Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
1.5.1.2. Client->Server: Client responds with empty local FUMO OMA-DM tree
[empty]
1.5.1.3. Server->Client: Server adds FUMO node representing App1
ADD ./Vendor/Website/Packages/{random1}
ADD ./Vendor/Website/Packages/{random1}/State: IDLE
ADD ./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
EXEC ./Vendor/Website/Packages/{random1}/DownloadAndUpdate
1.5.2. Client applies the update but fails
As a result of the installation, the client will set the ./State and ./Ext/State nodes respectively.
./Vendor/Website/Packages/{random1}/State: UPDATE_FAILED_HAVE_DATA
./Vendor/Website/Packages/{random1}/Ext/State: CUSTOM_INSTALL_OK
1.5.3. Sync 2: Server discovers installation of {random1} has failed, and creates {random2}
1.5.3.1. Server->Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
1.5.3.2. Client->Server: Report {random1} FUMO node has failed to install
The client responds with the updated FUMO ./Ext/State/ and ./State/ nodes indicating that the update has failed.
./Vendor/Website/Packages/{random1}/PkgName: App1
./Vendor/Website/Packages/{random1}/PkgVersion: 1
./Vendor/Website/Packages/{random1}/State: UPDATE_FAILED_HAVE_DATA
./Vendor/Website/Packages/{random1}/Ext/State: CUSTOM_INSTALL_OK
./Vendor/Website/Packages/{random1}/Ext/FileVersionID: {uri: App1 v.1}
1.5.3.3. Server->Client: Delete {random1}, and ADD and EXEC {random2}
The server informs the client that it should remove the erroneous FUMO node in ./Vendor/Website/Packages/{random1}. It will also add a new FUMO node representing the App1 as {random2}
DEL ./Vendor/Website/Packages/{random1}
ADD ./Vendor/Website/Packages/{random2}
ADD ./Vendor/Website/Packages/{random2}/State: IDLE
ADD ./Vendor/Website/Packages/{random2}/Ext/FileVersionID: {uri: App1 v.1}
EXEC ./Vendor/Website/Packages/{random2}/DownloadAndUpdate
1.5.4. Client successfully installs FUMO node {random2}
./Vendor/Website/Packages/{random2}/State: UPDATE_SUCCESSFUL_HAVE_NO_DATA
./Vendor/Website/Packages/{random2}/Ext/State: POST_CUSTOM_INSTALL_OK
1.5.5. Sync 5: Server discovers {random2} installed successfully
1.5.5.1. Server->Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
1.5.5.2. Client->Server: Report {random2} FUMO node has installed successfully
./Vendor/Website/Packages/{random2}/PkgName: App1
./Vendor/Website/Packages/{random2}/PkgVersion: 1
./Vendor/Website/Packages/{random2}/State: UPDATE_SUCCESSFUL_HAVE_NO_DATA
./Vendor/Website/Packages/{random2}/Ext/State: POST_CUSTOM_INSTALL_OK
./Vendor/Website/Packages/{random2}/Ext/FileVersionID: {uri: App1 v.1}
1.6. Client fails to verify downloaded file
./DownloadAndUpdate/PkgURL but the hash of the contents does not match the
./Ext/ApplicationHash.
1.6.1. Sync 1: Initial application of App1 as {random1}
1.6.1.1. Server->Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
1.6.1.2. Client->Server: Client responds with empty local FUMO OMA-DM tree
[empty]
1.6.1.3. Server->Client: Server adds FUMO node representing App1
ADD ./Vendor/Website/Packages/{random1}
ADD ./Vendor/Website/Packages/{random1}/State: IDLE
ADD ./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
EXEC ./Vendor/Website/Packages/{random1}/DownloadAndUpdate
1.6.2. Client applies the update but fails
./Vendor/Website/Packages/{random1}/State: UPDATE_FAILED_HAVE_NO_DATA
./Vendor/Website/Packages/{random1}/Ext/State: VERIFY_FAILED
1.6.3. Sync 2: Server discovers installation of {random1} has failed, and creates {random2}
1.6.3.1. Server->Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
1.6.3.2. Client->Server: Report {random1} FUMO node has failed to install
The client responds with the updated FUMO ./Ext/State/ and ./State/ nodes indicating that the update has failed.
./Vendor/Website/Packages/{random1}/PkgName: App1
./Vendor/Website/Packages/{random1}/PkgVersion: 1
./Vendor/Website/Packages/{random1}/State: UPDATE_FAILED_HAVE_NO_DATA
./Vendor/Website/Packages/{random1}/Ext/State: VERIFY_FAILED
./Vendor/Website/Packages/{random1}/Ext/FileVersionID: {uri: App1 v.1}
1.6.3.3. Server->Client: Delete {random1}, and ADD and EXEC {random2}
The server informs the client that it should remove the erroneous FUMO node in ./Vendor/Website/Packages/{random1}. It will also add a new FUMO node representing the App1 as {random2}
DEL ./Vendor/Website/Packages/{random1}
ADD ./Vendor/Website/Packages/{random2}
ADD ./Vendor/Website/Packages/{random2}/State: IDLE
ADD ./Vendor/Website/Packages/{random2}/Ext/FileVersionID: {uri: App1 v.1}
EXEC ./Vendor/Website/Packages/{random2}/DownloadAndUpdate
1.6.4. Client successfully installs FUMO node {random2}
./Vendor/Website/Packages/{random2}/State: UPDATE_SUCCESSFUL_HAVE_NO_DATA
./Vendor/Website/Packages/{random2}/Ext/State: POST_CUSTOM_INSTALL_OK
1.6.5. Sync 5: Server discovers {random2} installed successfully
1.6.5.1. Server->Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
1.6.5.2. Client->Server: Report {random2} FUMO node has installed successfully
./Vendor/Website/Packages/{random2}/PkgName: App1
./Vendor/Website/Packages/{random2}/PkgVersion: 1
./Vendor/Website/Packages/{random2}/State: UPDATE_SUCCESSFUL_HAVE_NO_DATA
./Vendor/Website/Packages/{random2}/Ext/State: POST_CUSTOM_INSTALL_OK
./Vendor/Website/Packages/{random2}/Ext/FileVersionID: {uri: App1 v.1}
1.7. Client fails abnormally
1.7.1. Sync 1: Initial application of App1 as {random1}
1.7.1.1. Server->Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
1.7.1.2. Client->Server: Client responds with empty local FUMO OMA-DM tree
[empty]
1.7.1.3. Server->Client: Server adds FUMO node representing App1
ADD ./Vendor/Website/Packages/{random1}
ADD ./Vendor/Website/Packages/{random1}/State: IDLE
ADD ./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
EXEC ./Vendor/Website/Packages/{random1}/DownloadAndUpdate
1.7.2. Client only partially installs App1
./Vendor/Website/Packages/{random1}/State: READY_TO_UPDATE
1.7.3. Sync 2: Server discovers installation of {random1} has failed, and creates {random2}
1.7.3.1. Server->Client: Request list of Packages node w [001268] The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
1.7.3.2. Client->Server: Report {random1} FUMO node has failed to install
The client responds with the updated FUMO ./Ext/State/ and ./State/ nodes indicating that the update has failed.
./Vendor/Website/Packages/{random1}/PkgName: App1
./Vendor/Website/Packages/{random1}/PkgVersion: 1
./Vendor/Website/Packages/{random1}/State: READY_TO_UPDATE
./Vendor/Website/Packages/{random1}/Ext/FileVersionID: {uri: App1 v.1}
1.7.3.3. Server->Client: Delete {random1}, and ADD and EXEC {random2}
The server informs the client that it should remove the erroneous FUMO node in ./Vendor/Website/Packages/{random1}. It will also add a new FUMO node representing the App1 as {random2}
DEL ./Vendor/Website/Packages/{random1}
ADD ./Vendor/Website/Packages/{random2}
ADD ./Vendor/Website/Packages/{random2}/State: IDLE
ADD ./Vendor/Website/Packages/{random2}/Ext/FileVersionID: {uri: App1 v.1}
EXEC ./Vendor/Website/Packages/{random2}/DownloadAndUpdate
1.7.4. Client successfully installs FUMO node {random2}
./Vendor/Website/Packages/{random2}/State: UPDATE_SUCCESSFUL_HAVE_NO_DATA
./Vendor/Website/Packages/{random2}/Ext/State: POST_CUSTOM_INSTALL_OK
1.7.5. Sync 5: Server discovers {random2} installed successfully
1.7.5.1. Server->Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
1.7.5.2. Client->Server: Report {random2} FUMO node has installed successfully
./Vendor/Website/Packages/{random2}/PkgName: App1
./Vendor/Website/Packages/{random2}/PkgVersion: 1
./Vendor/Website/Packages/{random2}/State: UPDATE_SUCCESSFUL_HAVE_NO_DATA
./Vendor/Website/Packages/{random2}/Ext/State: POST_CUSTOM_INSTALL_OK
./Vendor/Website/Packages/{random2}/Ext/FileVersionID: {uri: App1 v.1}
2. Update of existing applications
This section covers scenarios when existing application are updated
2.1. Update—sunny day scenario
2.1.1. Sync 1: Server informs client to delete App1 v.1 as {random1} and install App1 v.2 as {random2}
2.1.1.1. Server->Client: Request list of Packages node
GET ./Vendor/Website/Packages
2.1.1.2. Client->Server: Client responds with one FUMO node representing App1 in version 1
./Vendor/Website/Packages/{random1}/PkgName: App1
./Vendor/Website/Packages/{random1}/PkgVersion: 1
./Vendor/Website/Packages/{random1}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
2.1.1.3. Server->Client: Server asks client to delete {random1} and install App1 v.2 as {random2}
DEL ./Vendor/Website/Packages/{random1}
ADD ./Vendor/Website/Packages/{random2}
ADD ./Vendor/Website/Packages/{random2}/State: IDLE
ADD ./Vendor/Website/Packages/{random2}/EXT/FileVersionID: {uri: App1 v.2}
EXEC ./Vendor/Website/Packages/{random2}/DownloadAndUpdate
2.1.2. Client deletes FUMO node for {random1}
DEL ./Vendor/Website/Packages/{random1}: OK
2.1.3. Client: Successfully installs FUMO node {random2}
./Vendor/Website/Packages/{random2}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random2}/Ext/State: CUSTOM_INSTALL_OK
These changes will not be apparent to the server until the next sync.
2.1.4. Sync 2: Client indicates update was successful
2.1.4.1. Server->Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
2.1.4.2. Client->Server: Client responds with a {random2} node that shows update successful
./Vendor/Website/Packages/{random2}/PkgName: App1
./Vendor/Website/Packages/{random2}/PkgVersion: 1
./Vendor/Website/Packages/{random2}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random2}/EXT/FileVersionID: {uri: App1 v.2}
2.2. Multiple attempts at updating the same application
2.2.1. Sync 1: Initial attempt to update App1 from version 1 to version 2 by replacing {random1} with {random2}
2.2.1.1. Server->Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
2.2.1.2. Client->Server: Client responds with {random1} representing App1 v.1
./Vendor/Website/Packages/{random1}/PkgName: App1
./Vendor/Website/Packages/{random1}/PkgVersion: 1
./Vendor/Website/Packages/{random1}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
2.2.1.3. Server->Client: Servers asks for deleting {random1} representing App1 v.1 and adds FUMO node {random2} representing App1 v.2
The server informs the client that it should remove FUMO {random1} representing App1 v.1 and add new FUMO node {random2} representing App1 v.2
DEL ./Vendor/Website/Packages/{random1}
ADD ./Vendor/Website/Packages/{random2}
ADD ./Vendor/Website/Packages/{random2}/State: IDLE
ADD ./Vendor/Website/Packages/{random2}/EXT/FileVersionID: {uri: App1 v.2}
EXEC ./Vendor/Website/Packages/{random2}/DownloadAndUpdate
2.2.2. Client deletes FUMO node for {random1}
DEL ./Vendor/Website/Packages/{random1}: OK
2.2.3. Client: applies the update but fails
./Vendor/Website/Packages/{random2}/State: UPDATE_FAILED_HAVE_DATA
./Vendor/Website/Packages/{random2}/Ext/State: VERIFY_FAILED
These changes will not be apparent to the server until the next sync.
2.2.4. Sync 2: Server discovers update {random2} has failed and creates {random3}:
2.2.4.1. Server->Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
2.2.4.2. Client->Server: Client responds with {random1} and {random2}
./Vendor/Website/Packages/{random1}/PkgName: App1
./Vendor/Website/Packages/{random1}/PkgVersion: 1
./Vendor/Website/Packages/{random1}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
./Vendor/Website/Packages/{random2}/PkgName: App1
./Vendor/Website/Packages/{random2}/PkgVersion: 2
./Vendor/Website/Packages/{random2}/State: UPDATE_FAILED_HAVE_DATA
./Vendor/Website/Packages/{random2}/EXT/FileVersionID: {uri: App1 v.2}
2.2.4.3. Server->Client: Delete {random1}, {random2} and install {random3}
DEL ./Vendor/Website/Packages/{random1}
DEL ./Vendor/Website/Packages/{random2}
ADD ./Vendor/Website/Packages/{random3}
ADD ./Vendor/Website/Packages/{random3}/State: IDLE
ADD ./Vendor/Website/Packages/{random3}/EXT/FileVersionID: {uri: App1 v.2}
EXEC ./Vendor/Website/Packages/{random3}/DownloadAndUpdate
2.2.5. Client deletes FUMO nodes for {random1} and {random2}
DEL ./Vendor/Website/Packages/{random1}: OK
DEL ./Vendor/Website/Packages/{random2}: OK
2.2.6. Client attempts to apply update, but encounters error and rollbacks
./Vendor/Website/Packages/{random3}/State: UPDATE_FAILED_HAVE_DATA
./Vendor/Website/Packages/{random3}/Ext/State: VERIFY_FAILED
These changes will not be apparent to the server until the next sync.
2.2.7. Sync 3: Server discovers updates {random2}, {random3} have failed and creates {random4}
2.2.7.1. Server->Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
2.2.7.2. Client->Server: Client responds with random11, {random2} and {random3}
./Vendor/Website/Packages/{random1}/PkgName: App1
./Vendor/Website/Packages/{random1}/PkgVersion: 1
./Vendor/Website/Packages/{random1}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
./Vendor/Website/Packages/{random2}/PkgName: App1
./Vendor/Website/Packages/{random2}/PkgVersion: 2
./Vendor/Website/Packages/{random2}/State: STATE_UPDATE_FAILED_HAVE_DATA
./Vendor/Website/Packages/{random2}/EXT/FileVersionID: {uri: App1 v.2}
./Vendor/Website/Packages/{random3}/PkgName: App1
./Vendor/Website/Packages/{random3}/PkgVersion: 2
./Vendor/Website/Packages/{random3}/State: UPDATE_FAILED_HAVE_DATA
./Vendor/Website/Packages/{random3}/EXT/FileVersionID: {uri: App1 v.2}
2.2.7.3. Server->Client: Delete {random1}, {random2}, {random3} and install new version as {random4}
DEL ./Vendor/Website/Packages/{random1}
DEL ./Vendor/Website/Packages/{random2}
DEL ./Vendor/Website/Packages/{random3}
ADD ./Vendor/Website/Packages/{random4}
ADD ./Vendor/Website/Packages/{random4}/State: IDLE
ADD ./Vendor/Website/Packages/{random4}/EXT/FileVersionID: {uri: App1 v.2}
EXEC ./Vendor/Website/Packages/{random4}/DownloadAndUpdate
2.2.8. Client deletes FUMO nodes for {random1}, {random2} and {random3}
DEL ./Vendor/Website/Packages/{random1}: OK
DEL ./Vendor/Website/Packages/{random2}: OK
DEL ./Vendor/Website/Packages/{random3}: OK
2.2.9. Client attempts to apply update, but encounters error and rollbacks
./Vendor/Website/Packages/{random4}/State: UPDATE_FAILED_HAVE_DATA
./Vendor/Website/Packages/{random4}/Ext/State: VERIFY_FAILED
These changes will not be apparent to the server until the next sync.
2.2.10. Sync 4: Server discovers updates {random2}, {random3}, {random 4} have failed and creates {random5}:
2.2.10.1. Server->Client: Request list of Packages node:
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
2.2.10.2. Client->Server: Client responds with {random1}, {random2}, {random3} and {random4}
./Vendor/Website/Packages/{random1}/PkgName: App1
./Vendor/Website/Packages/{random1}/PkgVersion: 1
./Vendor/Website/Packages/{random1}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
./Vendor/Website/Packages/{random2}/PkgName: App1
./Vendor/Website/Packages/{random2}/PkgVersion: 2
./Vendor/Website/Packages/{random2}/State: UPDATE_FAILED_HAVE_DATA
./Vendor/Website/Packages/{random2}/EXT/FileVersionID: {uri: App1 v.2}
./Vendor/Website/Packages/{random3}/PkgName: App1
./Vendor/Website/Packages/{random3}/PkgVersion: 2
./Vendor/Website/Packages/{random3}/State: UPDATE_FAILED_HAVE_DATA
./Vendor/Website/Packages/{random3}/EXT/FileVersionID: {uri: App1 v.2}
./Vendor/Website/Packages/{random4}/PkgName: App1
./Vendor/Website/Packages/{random4}/PkgVersion: 2
./Vendor/Website/Packages/{random4}/State: UPDATE_FAILED_HAVE_DATA
./Vendor/Website/Packages/{random4}/EXT/FileVersionID: {uri: App1 v.2}
2.2.10.3. Server->Client: Delete {random1}, {random2}, {random3}, {random4} and install new version as {random5}
DEL ./Vendor/Website/Packages/{random1}
DEL ./Vendor/Website/Packages/{random2}
DEL ./Vendor/Website/Packages/{random4}
ADD ./Vendor/Website/Packages/{random5}
ADD ./Vendor/Website/Packages/{random5}/State: IDLE
ADD ./Vendor/Website/Packages/{random5}/EXT/FileVersionID: {uri: App1 v.2}
EXEC ./Vendor/Website/Packages/{random5}/DownloadAndUpdate
2.2.11. Client deletes FUMO nodes for {random1}, {random2}, {random3} and {random4}
DEL ./Vendor/Website/Packages/{random1}: OK
DEL ./Vendor/Website/Packages/{random2}: OK
DEL ./Vendor/Website/Packages/{random3}: OK
DEL ./Vendor/Website/Packages/{random4}: OK
2.2.12. Client: Successfully installs FUMO node {random5}
./Vendor/Website/Packages/{random5}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random5}/Ext/State: POST_CUSTOM_INSTALL_OK
These changes will not be apparent to the server until the next sync.
2.2.13. Sync 5: Server discovers {random5} installed successfully:
2.2.13.1. Server->Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
2.2.13.2. Client->Server: Reports {random5} FUMO node:
./Vendor/Website/Packages/{random5}/PkgName: App1
./Vendor/Website/Packages/{random5}/PkgVersion: 2
./Vendor/Website/Packages/{random5}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random5}/Ext/FileVersionID: {Lid: App1 v.2}
3 Mandatory/Critical updates
3.1. Critical update with empty local history
3.1.1. Sync 1: Server informs client of App1 as {random1}
3.1.1.1. Server->Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
3.1.1.2. Client->Server: Client responds with empty local FUMO OMA-DM tree
[empty]
3.1.1.3. Server->Client: Server adds FUMO node representing App1
ADD ./Vendor/Website/Session/Critical: true
ADD ./Vendor/Website/Packages/{random1}
ADD ./Vendor/Website/Packages/{random1}/State: IDLE
ADD ./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
EXEC ./Vendor/Website/Packages/{random1}/DownloadAndUpdate
3.1.2. Client installs update successfully
./Vendor/Website/Packages/{random1}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random1}/Ext/State: STATE_CUSTOM_INSTALL_OK
3.1.3. Sync 2: Client indicates installation is successful
3.1.3.1. Server->Client: Request list of Packages node
GET ./Vendor/Website/Packages
3.1.3.2. Client->Server: Client responds with a {random1} node that shows update successful
./Vendor/Website/Packages/{random1}/PkgName: App1
./Vendor/Website/Packages/{random1}/PkgVersion: 1
./Vendor/Website/Packages/{random1}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
3.2. Normal application update followed by a critical update
3.2.1. Sync 1: Server informs client of App1 as {random1}
3.2.1.1. Server->Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
3.2.1.2. Client->Server: Client responds with empty local FUMO OMA-DM tree
[empty]
3.2.1.3. Server->Client: Server adds FUMO node representing App1
ADD ./Vendor/Website/Session/Critical: false
ADD ./Vendor/Website/Packages/{random1}
ADD ./Vendor/Website/Packages/{random1}/State: IDLE
ADD ./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
EXEC ./Vendor/Website/Packages/{random1}/DownloadAndUpdate
3.2.2. Client installs update successfully
./Vendor/Website/Packages/{random1}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random1}/Ext/State: CUSTOM_INSTALL_OK
3.2.3. Sync 2: Client indicates installation is successful
3.2.3.1. Server->Client: Request list of Packages node
GET ./Vendor/Website/Packages
3.2.3.2. Client->Server: Client responds with a {random1} node that shows update successful
./Vendor/Website/Packages/{random1}/PkgName: App1
./Vendor/Website/Packages/{random1}/PkgVersion: 1
./Vendor/Website/Packages/{random1}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
3.2.3.3. Server->Client: Server responds with App2, which is a critical update
./Vendor/Website/Packages/{random2}remains unchanged.
ADD ./Vendor/Website/Session/Critical: true
ADD ./Vendor/Website/Packages/{random2}
ADD ./Vendor/Website/Packages/{random2}/State: IDLE
ADD ./Vendor/Website/Packages/{random2}/EXT/FileVersionID: {uri: App1 v.1}
EXEC ./Vendor/Website/Packages/{random2}/DownloadAndUpdate
3.2.4. Client successfully installs App2
./Vendor/Website/Packages/{random1}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random1}/Ext/State: CUSTOM_INSTALL_OK
3.3. Partial installation followed by critical update (initial FUMO preserved)
3.3.1. Sync 1: Server informs client of App1 as {random1}
3.3.1.1. Server->Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
3.3.1.2. Client->Server: Client responds with empty local FUMO OMA-DM tree
[empty]
3.3.1.3. Server->Client: Server adds FUMO node representing App1
ADD ./Vendor/Website/Session/Critical: false
ADD ./Vendor/Website/Packages/{random1}
ADD ./Vendor/Website/Packages/{random1}/State: IDLE
ADD ./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
EXEC ./Vendor/Website/Packages/{random1}/DownloadAndUpdate
3.3.2. Client is still progressing with download before next OMA-DM sync occurs
./Vendor/Website/Packages/{random1}/State: DOWNLOAD_IN_PROGRESS
3.3.3. Sync 2: Client indicates installation is in-progress
3.3.3.1. Server->Client: Request list of Packages node
GET ./Vendor/Website/Packages
3.3.3.2. Client->Server: Client responds with a {random1} node that shows download is in progress
./Vendor/Website/Packages/{random1}/PkgName: App1
./Vendor/Website/Packages/{random1}/PkgVersion: 1
./Vendor/Website/Packages/{random1}/State: DOWNLOAD_IN_PROGRESS
./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
3.3.3.3. Server->Client: Server responds with App2, which is a critical update
ADD ./Vendor/Website/Session/Critical: true
ADD ./Vendor/Website/Packages/{random2}
ADD ./Vendor/Website/Packages/{random2}/State: IDLE
ADD ./Vendor/Website/Packages/{random2}/EXT/FileVersionID: {uri: App2 v.1}
EXEC ./Vendor/Website/Packages/{random2}/DownloadAndUpdate
3.3.4. Client successfully installs App2
./Vendor/Website/Packages/{random2}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random2}/Ext/State: POST_CUSTOM_INSTALL_OK
3.3.5. Sync 3: Client reports critical update successful, server responds with non-critical update
3.3.5.1. Server->Client: Request list of Packages node
GET ./Vendor/Website/Packages
3.3.5.2. Client->Server: Client responds with a {random2} node that shows it has successfully installed
./Vendor/Website/Packages/{random1}/PkgName: App1
./Vendor/Website/Packages/{random1}/PkgVersion: 1
./Vendor/Website/Packages/{random1}/State: DOWNLOAD_FAILED
./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
./Vendor/Website/Packages/{random2}/PkgName: App2
./Vendor/Website/Packages/{random2}/PkgVersion: 1
./Vendor/Website/Packages/{random2}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random2}/EXT/FileVersionID: {uri: App2 v.1}
3.3.5.3. Server->Client: Server requests installation of App1, which is the non critical update
ADD ./Vendor/Website/Session/Critical: false
DEL ./Vendor/Website/Packages/{random1}
ADD ./Vendor/Website/Packages/{random3}
ADD ./Vendor/Website/Packages/{random3}/State: IDLE
ADD ./Vendor/Website/Packages/{random3}/EXT/FileVersionID: {uri: App1 v.1}
EXEC ./Vendor/Website/Packages/{random3}/DownloadAndUpdate
3.3.6. Client successfully installs App1
./Vendor/Website/Packages/{random3}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random3}/Ext/State: POST_CUSTOM_INSTALL_OK
3.3.7. Sync 4: Client reports that App1 installation is successful
3.3.7.1. Server->Client: Request list of Packages node
GET ./Vendor/Website/Packages
3.3.7.2. Client->Server: Client responds with a {random3} node that shows it has successfully installed
./Vendor/Website/Packages/{random3}/PkgName: App1
./Vendor/Website/Packages/{random3}/PkgVersion: 1
./Vendor/Website/Packages/{random3}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random3}/EXT/FileVersionID: {uri: App1 v.1}
./Vendor/Website/Packages/{random2}/PkgName: App2
./Vendor/Website/Packages/{random2}/PkgVersion: 1
./Vendor/Website/Packages/{random2}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random2}/EXT/FileVersionID: {uri: App2 v.1}
3.4. OMA-DM sync during partial download of critical update (initial FUMO preserved)
In this scenario App1 is a critical update, and the server provokes an OMA-DM sync because App2 is pending installation.
3.4.1. Sync 1: Server informs client of App1 as {random1}
3.4.1.1. Server Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
3.4.1.2. Server Client: Client responds with empty local FUMO OMA-DM tree
[empty]
3.4.1.3. Server Client: Server adds FUMO node representing App1
ADD ./Vendor/Website/Session/Critical: true
ADD ./Vendor/Website/Packages/{random1}
ADD ./Vendor/Website/Packages/{random1}/State: IDLE
ADD ./Vendor/Website/Packages/{random1}/Ext/FileVersionID: {uri: App1 v.1}
EXEC ./Vendor/Website/Packages/{random1}/DownloadAndUpdate
3.4.2. Client partially downloads App1, and is forced to perform an OMA-DM sync
./Vendor/Website/Packages/{random1}/State: DOWNLOAD_PROGRESSING
./Vendor/Website/Packages/{random1}/Ext/State: DOWNLOAD_PROGRESSING
3.4.3. Sync 2: Client indicates App1 download is in progress
During this sync, the server will prevent the publishing of a FUMO node for App2, because the installation of App1 is still in progress.
It is possible for the server to override the installation of App1 at this point by modifying the FUMO structure.
3.4.3.1. Server Client: Request list of Packages node
GET ./Vendor/Website/Packages
3.4.3.2. Client Server: Client responds with a {random1} node that shows download is in progress
./Vendor/Website/Packages/{random1}/PkgName: App1
./Vendor/Website/Packages/{random1}/PkgVersion: 1
./Vendor/Website/Packages/{random1}/State: DOWNLOAD_PROGRESSING
./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
3.4.3.3. Server Client: Server does not modify the tree and resumes update of App1
The server will reset the ./State to be IDLE and EXEC the ./DownloadAndUpdate.
ADD ./Vendor/Website/Session/Critical: true
UPDATE ./Vendor/Website/Packages/{random1}/State: IDLE
EXEC ./Vendor/Website/Packages/{random1}/DownloadAndUpdate
3.4.4. Client successfully resumes installation App1
./Vendor/Website/Packages/{random1}/State: UPDATE_SUCCESSFUL_HAVE_NO_DATA
./Vendor/Website/Packages/{random1}/Ext/State: POST_CUSTOM_INSTALL_OK
3.4.5. Sync 3: Client reports App1 installation is successful, Server sends App2
3.4.5.1. Server Client: Request list of Packages node
GET ./Vendor/Website/Packages
3.4.5.2. Client Server: Client responds with a {random1} node that shows it has successfully installed
./Vendor/Website/Packages/{random1}/PkgName: App1
./Vendor/Website/Packages/{random1}/PkgVersion: 1
./Vendor/Website/Packages/{random1}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
3.4.5.3. Client Server: Server indicates that App2 is available
ADD ./Vendor/Website/Session/Critical: false
ADD ./Vendor/Website/Packages/{random2}
ADD ./Vendor/Website/Packages/{random2}/PkgName: App2
ADD ./Vendor/Website/Packages/{random2}/State: IDLE
ADD ./Vendor/Website/Packages/{random2}/Ext/FileVersionID: {uri: App2 v.1}
EXEC ./Vendor/Website/Packages/{random2}/DownloadAndUpdate
3.5. OMA-DM sync during partial download of critical update (new FUMO created)
This scenario is similar to the one above, except that instead of re-using the same {random1} node for App1, it creates a new FUMO node App1, called {random2}
3.5.1. Sync 1: Server informs client of App1 as {random1}
3.5.1.1. Server Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
3.5.1.2. Server Client: Client responds with empty local FUMO OMA-DM tree
[empty]
3.5.1.3. Server Client: Server adds FUMO node representing App1
ADD ./Vendor/Website/Session/Critical: true
ADD ./Vendor/Website/Packages/{random1}
ADD ./Vendor/Website/Packages/{random1}/State: IDLE
ADD ./Vendor/Website/Packages/{random1}/Ext/FileVersionID: {uri: App1 v.1}
EXEC ./Vendor/Website/Packages/{random1}/DownloadAndUpdate
3.5.2. Client partially downloads App1, and is forced to perform an OMA-DM sync
./Vendor/Website/Packages/{random1}/State: DOWNLOAD_PROGRESSING
./Vendor/Website/Packages/{random1}/Ext/State: DOWNLOAD_PROGRESSING
3.5.3. Sync 2: Client indicates App1 download is in progress
3.5.3.1. Server Client: Request list of Packages node
GET ./Vendor/Website/Packages
3.5.3.2. Client Server: Client responds with a {random1} node that shows download is in progress
./Vendor/Website/Packages/{random1}/PkgName: App1
./Vendor/Website/Packages/{random1}/PkgVersion: 1
./Vendor/Website/Packages/{random1}/State: DOWNLOAD_PROGRESSING
./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
3.5.3.3. Server Client: Server creates a new FUMO node representing App1
ADD ./Vendor/Website/Session/Critical: true
DEL ./Vendor/Website/Packages/{random1}
ADD ./Vendor/Website/Packages/{random2}/State: IDLE
ADD ./Vendor/Website/Packages/{random2}/Ext/FileVersionID: {uri: App1 v.1}
EXEC ./Vendor/Website/Packages/{random2}/DownloadAndUpdate
3.5.4. Client successfully resumes installation App1
./Vendor/Website/Packages/{random2}/State: UPDATE_SUCCESSFUL_HAVE_NO_DATA
./Vendor/Website/Packages/{random2}/Ext/State: POST_CUSTOM_INSTALL_OK
3.5.5. Sync 3: Client reports App1 installation is successful, Server sends App2
3.5.5.1. Server Client: Request list of Packages node
GET ./Vendor/Website/Packages
3.5.5.2. Client Server: Client responds with a {random2} node that shows it has successfully installed
./Vendor/Website/Packages/{random2}/PkgName: App1
./Vendor/Website/Packages/{random2}/PkgVersion: 1
./Vendor/Website/Packages/{random2}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random2}/Ext/FileVersionID: {uri: App1 v.1}
3.5.5.3. Client Server: Server indicates that App2 is available
ADD ./Vendor/Website/Session/Critical: false
ADD ./Vendor/Website/Packages/{random3}
ADD ./Vendor/Website/Packages/{random3}/PkgName: App2
ADD ./Vendor/Website/Packages/{random3}/State: IDLE
ADD ./Vendor/Website/Packages/{random3}/Ext/FileVersionID: {uri: App2 v.1}
EXEC ./Vendor/Website/Packages/{random3}/DownloadAndUpdate
3.6. OMA-DM sync during partial download of critical update (new FUMO created after timeout has been reached)
This scenario is similar to the one above, except the creation of the new FUMO is postponed until the installation time exceeds a maximum allowable time.
The server can postpone sending new FUMO for a configurable amount of time or it can calculate estimated time to finish based on the application size etc.
This approach allows the client to finish current downloads without being interrupted by the server while on the other hand it allows the server to restart downloads on demand.
3.6.1. Sync 1: Server informs client of App1 as {random1}
3.6.1.1. Server Client: Request list of Packages node
The server requests the nodes within /Vendor/Website/Packages/.
GET ./Vendor/Website/Packages
3.6.1.2. Server Client: Client responds with empty local FUMO OMA-DM tree
[empty]
3.6.1.3. Server Client: Server adds FUMO node representing App1
ADD ./Vendor/Website/Session/Critical: true
ADD ./Vendor/Website/Packages/{random1}
ADD ./Vendor/Website/Packages/{random1}/State: IDLE
ADD ./Vendor/Website/Packages/{random1}/Ext/FileVersionID: {uri: App1 v.1}
EXEC ./Vendor/Website/Packages/{random1}/DownloadAndUpdate
3.6.2. Client partially downloads App1, and is forced to perform an OMA-DM sync
./Vendor/Website/Packages/{random1}/State: DOWNLOAD_PROGRESSING
./Vendor/Website/Packages/{random1}/Ext/State: DOWNLOAD_PROGRESSING
3.6.3. Sync 2: Client indicates App1 download is in progress
3.6.3.1. Server Client: Request list of Packages node
GET ./Vendor/Website/Packages
3.6.3.2. Client Server: Client responds with a {random1} node that shows download is in progress
./Vendor/Website/Packages/{random1}/PkgName: App1
./Vendor/Website/Packages/{random1}/PkgVersion: 1
./Vendor/Website/Packages/{random1}/State: DOWNLOAD_PROGRESSING
./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
3.6.3.3. Server Client: Installation is in progress, timeout not reached
The server calculates time difference between the EXEC command from the sync 1 and the current timestamp. For this sync the difference was below the maximum allowable value so server finishes sync without sending any command
[empty]
3.6.4. Sync 3: Client indicates App1 download is in progress, but installation reached the timeout
Client was forced to perform yet another OMA-DM sync while progressing download of App1.
3.6.4.1. Server Client: Request list of Packages node
GET ./Vendor/Website/Packages
3.6.4.2. Client Server: Client responds with a {random1} node that shows download is in progress
./Vendor/Website/Packages/{random1}/PkgName: App1
./Vendor/Website/Packages/{random1}/PkgVersion: 1
./Vendor/Website/Packages/{random1}/State: DOWNLOAD_PROGRESSING
./Vendor/Website/Packages/{random1}/EXT/FileVersionID: {uri: App1 v.1}
3.6.4.3. Server Client: Installation is in progress, timeout for the installation reached
The server found that installation already reached maximum allowable time and it is still in the DOWNLOAD_PROGRESSING state. The server decides to restart installation by either reusing {random1}FUMO and resets it's state to IDLE or replacing the {random1}FUMO with {random2}. Below the second option is considered.
ADD ./Vendor/Website/Session/Critical: true
DEL ./Vendor/Website/Packages/{random1}
ADD ./Vendor/Website/Packages/{random2}/State: IDLE
ADD ./Vendor/Website/Packages/{random2}/Ext/FileVersionID: {uri: App1 v.1}
EXEC ./Vendor/Website/Packages/{random2}/DownloadAndUpdate
3.6.5. Client successfully resumes installation App1
./Vendor/Website/Packages/{random2}/State: UPDATE_SUCCESSFUL_HAVE_NO_DATA
./Vendor/Website/Packages/{random2}/Ext/State: POST_CUSTOM_INSTALL_OK
3.6.6. Sync 3: Client reports App1 installation is successful, Server sends App2
3.6.6.1. Server Client: Request list of Packages node
GET ./Vendor/Website/Packages
3.6.6.2. Client Server: Client responds with a {random2} node that shows it has successfully installed
./Vendor/Website/Packages/{random2}/PkgName: App1
./Vendor/Website/Packages/{random2}/PkgVersion: 1
./Vendor/Website/Packages/{random2}/State: UPDATE_SUCCESSFUL_HAVE_DATA
./Vendor/Website/Packages/{random2}/Ext/FileVersionID: {uri: App1 v.1}
3.6.6.3. Client Server: Server indicates that App2 is available
ADD ./Vendor/Website/Session/Critical: false
ADD ./Vendor/Website/Packages/{random3}
ADD ./Vendor/Website/Packages/{random3}/PkgName: App2
ADD ./Vendor/Website/Packages/{random3}/State: IDLE
ADD ./Vendor/Website/Packages/{random3}/Ext/FileVersionID: {uri: App2 v.1}
EXEC ./Vendor/Website/Packages/{random3}/DownloadAndUpdate
4. Log Events
4.1. External Interfaces FR1.2.2.18
4.1.1. Software Update Report
4.2. QNX Demo #1
4.3. Web Server Demo
4.4. LENC Upload
4.4.1. Typical log events during installation of HTML5 application
4.4.2. Log events reported from Connected Infotainment's LoggerWrapper
Logs stored after API call for a Native component logging an event
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>.
@prefix dlapps: <http://website.com/dlapps/>.
@prefix not: <http://website.com/notifications/>.
@prefix comp: <http://website.com/components/>.
@prefix esm: <http://website.com/esm/1.0/>.
@prefix log: <http://website.com/log2rdf/0.1/>.
@prefix cars: <http://website.com/cars/>.
@prefix ciapps: <http://website.com/ciapps/>.
@prefix xsd: <http://www.w3.org/2001/XMLSchema#>.
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>.
cars:WAUZZZ8DZWA123456
esm:notifies not:WAUZZZ8DZWA123456-61.
not: WAUZZZ8DZWA123456-61
esm:regarding ciapps:CIAM;
log:Timestamp “1234567002”̂̂xsd:long;
log:message “_lifecycle application manager startup complete”̂̂xsd:string;
log:reportedAt “1234560000”̂̂xsd:long;
log:reportedBy ciapps:CILW;
log:severity log:INFO;
a esm:Status.
Logs stored after API call for an HTML5 App logging an event
4.4.3. EventsReduced
The EventReduced event is created when the LENC Reducer saves the current contents of the in-memory database to disk.
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>.
@prefix dlapps: <http://website.com/dlapps/>.
@prefix not: <http://website.com/notifications/>.
@prefix comp: <http://website.com/components/>.
@prefix esm: <http://website.com/esm/1.0/>.
@prefix log: <http://website.com/log2rdf/0.1/>.
@prefix cars: <http://website.com/cars/>.
@prefix ciapps: <http://website.com/ciapps/>.
@prefix xsd: <http://www.w3.org/2001/XMLSchema#>.
@prefix rdfs: <http://www.w3.org/2000/01/rdf-schema#>.
cars:WAUZZZ8DZWA123456
esm:notifies not:WAUZZZ8DZWA123456-59.
not: WAUZZZ8DZWA123456-59
esm:regarding comp:LENC;
log:ReduceReason log:ReducedToDisk;
log:Timestamp “1395941471”̂̂xsd:long;
log:reportedAt “1395941471”̂̂xsd:long;
log:reportedBy comp:LENC;
log:severity log:INFO;
a esm:EventsReduced.
In some alternative embodiments, REDUP includes the following activities and/or components.
IoT
Embedded Systems (ES) Ontology. See
Segment Management. See
System Supports Multiple Campaigns of Software Updates
Other alternative embodiments may include the following.
System Related
Notification Related (Covers e.g. Also Implementations Like MQTT)
Synchronization Protocol Related (e.g. Extensions/New Uses of OMA-DM)
Graph Data Related (Might Use e.g. Implementations Like RDF)
User Profiles Related
Applications Related
Data Related
Notes:
1 Methods to link products to reported instances of products—use of graph for matching
This idea relates to the capability within the platform to treat the car as a managed product where instances of the product are updated by virtue of their membership to segments derived from the Bill Of Materials for each model/variant/option. See
Vehicle relationship management provides tools for remotely managing cars. Managing large numbers of vehicles on the road is facilitated by understanding their state in order to make decisions about how software or hardware improvements can be made. Each vehicle reports small amounts of information about the real-time performance and usage of the car. Together, the information can be used to form a complete view of the state of the product. From this view decisions can be made about software or configuration changes that could be made.
Vehicle relationship management is not the same as customer relationship management. The relationship is strictly between the OEM and the vehicle in a similar way to that currently where the dealer maintains a vehicle in good working by physically connecting a diagnostics tool to read data and facilitate software updates. The difference is that the diagnostics is done remotely for the convenience and benefit of the vehicle owner.
REDUP handles the relationship between product and devices (vehicles).
1.1 Data
VRM is driven by data from the vehicle. As such, it is part of the Internet of Things Vehicle configuration information for the product is linked to telematic reports from the vehicle. This enables live information about the vehicle to be collected and matched against product.
1.2 Files
REDUP is a platform that facilitates managing files, delivering these to their target set of vehicles and installing them. In practice, this end-to-end process is complicated. Vehicles have changed from electro-mechanical devices to software-based electro-mechanical devices. The scope and variety of software within vehicles is immense and this creates a complex environment for software management. The aforementioned files are termed Software Update Modules. They can be
How each SUM is installed differs depending on the SUM type and which installer is employed.
1.3 Packages
SUMs can be managed in isolation but are often managed as sets. The sets could be the following:
Packages therefore conveniently group files so that they can be managed and published together.
1.4 Segments
Another requirement of software management is the ability to notify vehicles in a timely manner and as appropriate when updates are published. This targeted notification is a means of requesting vehicles to contact the server to ascertain whether there are updates available. It is a means of avoiding having every vehicle contact the server each day to check for updates. It is also a means of controlling from the server the priority, ordering and load spreading for updates.
Ideally, notifications would only go out to specific vehicles that require the update. However, with variations in vehicle product (model, trim levels, customizations), production and, subsequently, with changes to vehicles over their lifetime identifying exactly which vehicles to notify is a matter of smart vehicle group management.
This grouping of vehicles is done though a process of Segmentation. Segments group vehicles together via combinations of attributes of the vehicle. It is possible to create segment groups by listing Vehicle Identification Numbers but it is also useful to group vehicles by attributes such as base model, trim level, etc.
A vehicle can belong to multi segments. This is illustrated in
In this way each vehicle can be defined by the collection of segments it belongs to. When a package of updates is published, it is published to a segment. There are two types of segments that allow us to target packages of updates in two ways.
1.4.1 Product Segments
For product (a.k.a. Model Range) segments the vehicle product is defined by the collection of ECUs that are used in its construction. Software management targets changes to the software components of ECUs. The objective of product segments is to divide up the software management task into groups for base model, variants/trim levels and features etc. For example a base model involves a collection of ECUs may be the same across all variants. A segment would be defined for this. A second segment could be defined for each trim level where the ECU configurations are different. Other segments could manage applications for the IVI for each trim. Segmentation therefore divides up the task of software management and, importantly, simplifies the process of vehicle notification and update load handling.
Within each segment it is possible to explicitly manage the ECUs to which the software updates are targeted. Software update modules can be configured to define dependencies. One type of dependency is between the versions of a software component of the target ECU with the software version of another ECU. By grouping ECUs by segment it is possible for the rules checker to warn the product manager if a dependent ECU is not present with a segment.
1.4.2 Device Segments
Another type of segment is the device segment. Whereas product segments are defined to describe the vehicle product as a way of managing the software level of vehicles according to product, device segments work differently. Device segments are a means of identifying specific lists of vehicles to which to target updates. The segments are most often based on VIN number but could be based on any vehicle attribute including parameters identifying test vehicles.
One example use of a device segment is during production where a small batch of vehicles may have been manufactured using an older part number and may require a custom software fix. A device segment could be created identifying the target vehicles for the update.
Because device segments are not focused on products but specific vehicles there is no explicit grouping of ECUs within these types of segments. Any ECU dependencies will be resolved when each vehicle connects to the server.
If a vehicle is a member of a device segment then it may be removed from product segments. The reason is to avoid the situation where Device Segments come into conflict with Product Segments.
1.4.3 Segment Examples
In the first example a vehicle starts in a specific software state. This means that the reported versions of components are as indicated in
The vehicle starts with versions 1, 2′, 3, 4 and 5. The (′) character denotes an updated version of the previous version of software. E.g. 2′ is the next version of component 2.
The vehicle belongs to segment A by virtue of the parameters that the vehicle communicates via OMA-DM to the server. A package is added to the segment and activated. The vehicle is notified and the rule defines 2 modules that will be delivered to the vehicle and installed.
This results in the vehicle being told to download two new version of software—1′ and 3′. Note that 2′ was not downloaded even though it was part of the update package because it was already installed.
In a second example a new version of the package is created which is intended to provide updates to the application set. See
In this case an upgrade package of SUMs is added to a segment. Previously version 1 of the package was present on the segment and now some SUMs are upgraded. The result is that vehicles that belong to the segment are notified and will receive the updated SUMs.
In a third example the vehicle belongs to two segments by virtue of the parameter is reported to the server. New versions of each package are uploaded to the server and activated. The vehicle is given updates from both packages. See
This results in a new set of software component versions in the vehicle. The components could be delivered and installed in the vehicle via multiple installers.
2 Methods for the management of packages for software updates modules so that they can be assigned to segments
Packages are collections of update files that are targeted to vehicles via segments. Package are targeted indirectly to vehicles through the product description. The packages are created using an administrator console function.
2.1.1 The Package View
The package view shows the table of packages. Packages contain collections of files. A package can be assigned to one or more segments.
When creating packages you can either set up a new package or a new version of a package. When creating new versions you have the option to clone the set of files in the previous version or start with an empty package.
When a new version package is added to a segment which has an older version, the old package is replaced with the new package version.
As shown in
2.1.2 Creating a package
Creating a package starts with the package name and canonical version string. Any version label can be added. See
The next stage allows the user to add files to the package. See
A summary of the selected files is shown in
The user has the option to create a not to go with the package. This note could, for example, inform QA about the target vehicle models. See
The package is then passed onto QA. See
The QA role can then accept the package and perform tests on the entire package of files.
The workflow for QA is extendable. It allows QA to engage in additional steps in testing. For example QA could run smoke tests on the package or download it and test it using external checking tools or a vehicle.
At the end of the process QA is able to accept or reject the package. If rejected a message is written to provide information on why the package was rejected. See
The package is passed back to the submitter it and is not able to progress.
Note, this is a similar process to the case of file testing except the test are performed on a group of files that are managed together.
At the end of the package process the package may be presented. See
3 Method for dynamically calculating which files to download during synchronization
In one implementation, rules for which files to download are attached to files directly. This means that the collection of files that are downloaded are done so at the point of synchronization with the vehicle.
The administration console has function for handling rules as part of file ingestion.
3.1.1 Files Management—see
3.1.2 AOTA SUM handling
The file upload workflow for a new file version is shown in
3.1.2.1 Uploading New Version example
The following example flow is for uploading a new file version. In this case a previous version of the software update module has been uploaded and this new version is intended as a replacement under certain rules.
The first stage is to select the previous file version. See
Details may be edited and a file may be selected for uploading. See
After file upload the generated hash key may be presented. See
Additional metadata is added and a version number is created based on the previous version. See
The version label is used to tag the version. Note that for rules the version label is not used to order the versions.
The version label that is added is referred to as the Canonical Version, a natural unique representation of a version, or a preferred notation for the version. It is a string that can be read from the file metadata or added manually
Separately there is a Cardinal version number, which is the ordering number for the version. In the case of a new file version, the cardinal version places the file in a sequence after the old version that is selected and before its original successor.
The order of the version is presented as shown in
Hash and file size metadata may be shown and/or reviewed. See
The next stage in the workflow is to manage the dependencies of the file. See
Dependencies may be set on:
1. Other files
2. Vehicle attributes
3. Attributes of ECUs
The dependencies on components may be managed by selecting the component. See
Summary of dependencies is shown in
After selecting a dependency a box to write notes about the file may be presented. The notes can be used to collect and coordinate update files. See
The summary page shows attributes of the uploaded file. See
The file that was uploaded submitted is in a SUBMITTED state. The next stage is under the control of QA.
Logging in as a member of QA an additional task is added to the available tasks. The available tasks allows any member of QA to perform the tests. See
If the task is accepted the files is made available. See
This task allows QA to manage the uploaded file to provide initial application testing.
The workflow for QA is extendable. It allows QA to engage in additional steps in testing. For example QA could run smoke tests on the file or download it and test it using external checking tools.
At the end of the process QA is able to accept or reject the file. If rejected a message may be written to provide information on why the file was rejected. See
Note, in the case above there are two dependent files.
If rejected, the file is passed back to the submitter and is not able to progress.
If accepted, the file is passed back in the ACCEPTED state and can progress onto the package phase.
Similar workflows may handle the following additional cases:
4 Methods for determining “should be” status, based on what will happen to a vehicle after the next synchronization, using last reported data
In some implementations, the REDUP may include the capability to pre-search vehicles based on the attributes that will be used in the download rules plus the ability after package assignment to identify for each vehicle while files will be downloaded.
4.1.1 Searching devices—see
5 Representation of an Vehicle state via OMA-DM tree in a graph format
In some implementations, the OMA-DM tree can model the current state of ECUs.
OMA-DM and the Attribute model is shown in
OMA-DM is used to synchronize information between the server and vehicles. OMA-DM supports two main functions. The first is to share data. The vehicle passes attributes back to the server to formally report the device state. This means that the installers should be capable of reporting ECU attributes back to the server via the OMA-DM business logic installer API.
Segments manage specific ECUs. This means that a SUM can make use of the report attributes to resolve dependencies on the target ECU and any dependent ECUs.
Component software versions are managed via SW lifecycle management process on the backend. This is usually done in third party organizations. Software update modules (SUM) are created that change the version of a component from one to another. These SUMs can be created on the third party site and possibly signed or, in some cases, they can be created on REDUP via a workflow. For example a workflow exists for creating a BSDIFF delta SFOTA SUM.
SUMS when uploaded to the server or created may have dependencies. Dependencies link the SUM to the ECU components or to other SUMs or to any parameter on the OMA-DM tree including VIN.
SUMs are organized in packages. Packages provide a convenient bag for SUMs managed and published at the same time.
Packages are published onto segments. The segment manages the ECUs for the SUMS in a package. Packages are linked to update campaigns. This means that the campaign for a software update is passed to the vehicle and subsequently reported back to the cloud.
Publishing a package sends out notifications for vehicles that are members of the segment. Vehicles when contacted will request installers to update the attributes in the tree and then request the server to download any SUMs. SUMs are routed to the correct installers and executed.
An installation report is delivered back to the cloud indicating success of failure of the update session. It also enables the cloud to measure the effectiveness of the campaign in general.
Methods for decomposition of products into collections of segments where segments are groups whose members match specific parameters communicated by devices or by externally defined and linked data
In some implementations, the REDUP may include the ability to add vehicle attributes into the OMA-DM tree that can be used in file rules.
6.1 ECU Model
ECUs are vehicle parts comprising hardware and software components. The REDUP VRM manages software component versions. Software components can be embedded system, binary applications, middleware and user applications or content. Updating software components involves changing the component software from one version to another in a planned manner and as part of campaigns.
REDUP models ECUs, components and attributes as shown in
An ECU, also referred to as an Embedded System, is modeled as a part consisting of multiple SW and HW components. A set of attributes of the part is also modeled. The attributes are values formally reported by an ECU. In the case of CAN bus modules the values might be reported via Data Identifiers (DID). Alternatively, if the system is a Tizen IVI the updatable components data items are can be managed via the RPM database or via an HTML5 execution environment.
The attributes are collected in the OMA-DM tree and communicated to the server during sync. The attributes can then be used to define dependencies between each SUMs and the state of the vehicle.
Each vehicle reports the state of its components as a collection of DIDs grouped by ECUs, while on the server side we want to model state of clients using graph structure similar to one described by the ESM ontology. This approach creates a data model mismatch and a need for a solution which will provide bidirectional mapping between two different domains See
DID-Component mapping addresses the following problems and/or specifications:
Solution Overview:
Solution for the described problem was created as an implementation of the below rule:
{DIDs}+{DID_mapping}+{component_definitions}={device_components}
Where:
Mappings
Mappings are provided as a list of triplets where each triplet has structure as shown in the below examples:
{ES_ID} {MAPS_DID_TO} {attribute}
or
{COMPONENT_ID} {MAPS_DID_TO} {attribute}
Where:
Mappings are also used to indicate that ECU contains (reports) particular component. Mapping for such relation can be expressed by providing the below triplet: {ES_ID} {MAPS_DID_TO} {COMPONENT_ID}
Where:
Knowing that attributes of embedded systems (or components) are strictly related to (ECU_ID, DID_ID) pair allows creating a bidirectional mapping between client and server domain models. With such mapping, it is possible to implement rules and restrictions that are created in the server domain (components & attributes) but being stored as a client model (ECUs and DIDs). This approach works properly with mappings that are versioned and updated. It also allows creation of rules for which mapping is not defined yet. The server applies mappings while reading data so each time device details are accessed it uses the most recent version of the mapping to convert DIDs into components and attributes. In case of missing mappings, server represents reported data as a set of unknown attributes.
Assumptions
The following may be assumed:
Specifications
DID-Component mapping facilitates implementation of the following specifications:
In some implementations it may be assumed that DIDs reported by a device are already in context of ECU (grouped by ECU).
DID-component mapping allows to map DIDs to any combination of components within context of a ECU.
The server allows to create SUMs restrictions (dependencies) on components and their attributes (server data model), and definitions of those restrictions are saved using did paths ({ECU}.{DID}), using the client data model. Thus, it is possible to provide support for restrictions based on unknown attributes and seamless updates of mapping rules.
It's possible to map multiple DIDs into the same component or attribute:
vrm:ABSHardwareComponent vrm:mapsF188to esm:productionYear.
vrm:ABSHardwareComponent vrm:mapsF181to esm:productionYear
However such mapping configuration may result with random values assigned to attributes if a device reports both DIDs.
Sources of Data
Device Component Reports
System accepts device component reports from various sources such as:
Each report upload refreshes last known state of the device. Device component reports from different sources are treated evenly, however data from some sources may be used to overwrite data from others etc.
Scenarios of DID-Component Mapping
Example Ontology and Individuals
Individuals
Scenarios are based on the below set of individuals:
vrm:ABS a esm:EmbeddedSystem;
vrm:ABSSoftwareComponent a esm:SWComponent;
vrm:ABSHardwareComponent a esm:HWComponent;
vrm:GPS a esm:EmbeddedSystem;
vrm:GPSSoftwareComponent a esm:SWComponent;
vrm:GPSHardwareComponent a esm:HWComponent;
Graphical representation of the above triplets is shown in
Attributes
List of Example Attributes Used:
esm:productionYear rdf:type esm:Attribute;
esm:description rdf:type esm:Attribute;
esm:manufacturer rdf:type esm:Attribute;
esm:name rdf:type esm:Attribute;
esm:partNumber rdf:type esm:Attribute;
Definitions of Mapping Rules:
vrm:mapsF181to a esm:DidMapping;
vrm:mapsF182to a esm:DidMapping;
vrm:mapsF183to a esm:DidMapping;
vrm:mapsF184to a esm:DidMapping;
vrm:mapsF185to a esm:DidMapping;
vrm:mapsF186to a esm:DidMapping;
vrm:mapsF187to a esm:DidMapping;
Mappings
Examples assume that server uses the below set of mapping rules:
vrm:ABS vrm:mapsF111to vrm:ABSHardwareComponent.
vrm:ABS vrm:mapsF180to vrm:ABSSoftwareComponent.
vrm:ABS vrm:mapsF186to esm:manufacturer.
vrm:ABS vrm:mapsF110to esm:name.
vrm:ABSHardwareComponent vrm:mapsF181to esm:productionYear.
vrm:ABSHardwareComponent vrm:mapsF183to esm:description.
vrm:ABSHardwareComponent vrm:mapsF184to esm:manufacturer.
vrm:ABSHardwareComponent vrm:mapsF185to esm:name.
vrm:ABSHardwareComponent vrm:mapsF187to esm:partNumber.
vrm:ABSSoftwareComponent vrm:mapsF112to esm:name.
Mapping rules used by the server can be changed or updated if that would be required by the scenario.
The above set of mapping rules uses DIDs: F111 and F180 to find if a device reports components like vrm:ABSHardwareComponent or vrm:ABSSoftwareComponent. It means that value associated with those DIDs is ignored. It's possible to use a single DID to provide both:
but that means adding a pair of rules like:
vrm:ABS vrm:mapsF111to vrm:ABSHardwareComponent
vrm:ABSHardwareComponent vrm:mapsF111to esm:revision
Scenarios
Device Reported Complete Set of Components and Attributes:
The device sends complete set of components and attributes, so the values in the mapping result originate from the device, however some of values provided by the device are not used. Values for paths like: /Vendor/Website/Components/Nodes/746/DID/F111/Value or /Vendor/Website/Components/Nodes/746/DID/F180/Value are ignored because of mapping rules configuration.
Data reported by the device is shown in
Result after applying component mappings is shown in
Device Reported Only Part of Components and Attributes:
The device sends only part of data describing its state, so the mapping result contains data that originates from the ontology along with data uploaded within the components report.
Data reported by the device is shown in
Result after applying component mappings is shown in
The mapping result contains one component because the DID that represents the other component was not reported by the device. Attributes of the reported component have been merged with values found in the component definition.
Device Reported Unknown Components and Attributes:
This scenario illustrates server behavior when client reports ECUs and DIDs that are not described by any available mapping. In such case server should accept data that was uploaded by the client and treat it as a collection of unknown attributes. After updating new version of mapping rules those unknown attributes should be correctly represented as EmbeddedSystems with components and attributes.
Data reported by the device is shown in
Device Reports Two ECUs:
Result after applying component mappings is shown in
Applying current version of mappings results in one ECU being properly mapped to an EmbeddedSystem and the other represented as a group of unknown (unmapped) attributes.
Additional Mappings are Added to the Server
Mapping rules can be updated or extend during runtime. In this scenario new set of mappings is added to the existing set.
vrm:GPS vrm:mapsF111to vrm:GPSHardwareComponent.
vrm:GPS vrm:mapsF180to vrm:GPSSoftwareComponent.
vrm:GPS vrm:mapsF186to esm:manufacturer.
vrm:GPS vrm:mapsF110to esm:name.
vrm:GPSHardwareComponent vrm:mapsF181to esm:productionYear.
vrm:GPSHardwareComponent vrm:mapsF183to esm:description.
vrm:GPSHardwareComponent vrm:mapsF184to esm:manufacturer.
vrm:GPSHardwareComponent vrm:mapsF185to esm:name.
vrm:GPSHardwareComponent vrm:mapsF187to esm:partNumber.
vrm:GPSSoftwareComponent vrm:mapsF112to esm:name.
Unknown DIDS are Now Components and Attributes
Adding new set of mapping rules allows server to properly map both ECU to EmbeddedSystems. See
DID Import Conflict:
The device sends a complete set of components and attributes, so the values in the mapping result originate from the device, however one of the DIDs (F181) has a value that conflicts with the attributes ontology.
Data reported by the device is shown in
Result after applying component mappings is shown in
Values that conflict with attribute definitions are displayed despite the incorrect value. This situation may be improved by uploading a new version of the ESM ontology or mapping rules (depends on type of data mismatch).
Mappings are Updated
Mapping rules can be updated or extended during runtime. This scenario assumes updating rules that are related to data that causes conflicts.
vrm:ABSHardwareComponent vrm:mapsF181to esm:serviceCode. vrm:ABSHardwareComponent vrm:mapsF188to esm:productionYear.
Conflicting DIDS are now mapped to proper attributes—see
7 Graph-Based Telematic Reporting Client
8 Methods to dynamically configure structure, frequency and type of telemetry data reporting from the remote managed devices and use of a graph database to report notifications from the vehicles
9 Methods to identify and report malfunction or abnormal behavior of remote devices and notification of remote device management system operator
Typically, users, which may be people and/or other systems, may engage information technology systems (e.g., computers) to facilitate information processing. In turn, computers employ processors to process information; such processors 3503 may be referred to as central processing units (CPU). One form of processor is referred to as a microprocessor. CPUs use communicative circuits to pass binary encoded signals acting as instructions to enable various operations. These instructions may be operational and/or data instructions containing and/or referencing other instructions and data in various processor accessible and operable areas of memory 3529 (e.g., registers, cache memory, random access memory, etc.). Such communicative instructions may be stored and/or transmitted in batches (e.g., batches of instructions) as programs and/or data components to facilitate desired operations. These stored instruction codes, e.g., programs, may engage the CPU circuit components and other motherboard and/or system components to perform desired operations. One type of program is a computer operating system, which, may be executed by CPU on a computer; the operating system enables and facilitates users to access and operate computer information technology and resources. Some resources that may be employed in information technology systems include: input and output mechanisms through which data may pass into and out of a computer; memory storage into which data may be saved; and processors by which information may be processed. These information technology systems may be used to collect data for later retrieval, analysis, and manipulation, which may be facilitated through a database program. These information technology systems provide interfaces that allow users to access and operate various system components.
In one embodiment, the REDUP controller 3501 may be connected to and/or communicate with entities such as, but not limited to: one or more users from peripheral devices 3512 (e.g., user input devices 3511); an optional cryptographic processor device 3528; and/or a communications network 3513.
Networks are commonly thought to comprise the interconnection and interoperation of clients, servers, and intermediary nodes in a graph topology. It should be noted that the term “server” as used throughout this application refers generally to a computer, other device, program, or combination thereof that processes and responds to the requests of remote users across a communications network. Servers serve their information to requesting “clients.” The term “client” as used herein refers generally to a computer, program, other device, user and/or combination thereof that is capable of processing and making requests and obtaining and processing any responses from servers across a communications network. A computer, other device, program, or combination thereof that facilitates, processes information and requests, and/or furthers the passage of information from a source user to a destination user is commonly referred to as a “node.” Networks are generally thought to facilitate the transfer of information from source points to destinations. A node specifically tasked with furthering the passage of information from a source to a destination is commonly called a “router.” There are many forms of networks such as Local Area Networks (LANs), Pico networks, Wide Area Networks (WANs), Wireless Networks (WLANs), etc. For example, the Internet is generally accepted as being an interconnection of a multitude of networks whereby remote clients and servers may access and interoperate with one another.
The REDUP controller 3501 may be based on computer systems that may comprise, but are not limited to, components such as: a computer systemization 3502 connected to memory 3529.
A computer systemization 3502 may comprise a clock 3530, central processing unit (“CPU(s)” and/or “processor(s)” (these terms are used interchangeable throughout the disclosure unless noted to the contrary)) 3503, a memory 3529 (e.g., a read only memory (ROM) 3506, a random access memory (RAM) 3505, etc.), and/or an interface bus 3507, and most frequently, although not necessarily, are all interconnected and/or communicating through a system bus 3504 on one or more (mother)board(s) 3502 having conductive and/or otherwise transportive circuit pathways through which instructions (e.g., binary encoded signals) may travel to effectuate communications, operations, storage, etc. The computer systemization may be connected to a power source 3586; e.g., optionally the power source may be internal. Optionally, a cryptographic processor 3526 may be connected to the system bus. In another embodiment, the cryptographic processor, transceivers (e.g., ICs) 3574, and/or sensor array (e.g., accelerometer, altimeter, ambient light, barometer, global positioning system (GPS) (thereby allowing REDUP controller to determine its location), gyroscope, magnetometer, pedometer, proximity, ultra-violet sensor, etc.) 3573 may be connected as either internal and/or external peripheral devices 3512 via the interface bus I/O 3508 (not pictured) and/or directly via the interface bus 3507. In turn, the transceivers may be connected to antenna(s) 3575, thereby effectuating wireless transmission and reception of various communication and/or sensor protocols; for example the antenna(s) may connect to various transceiver chipsets (depending on deployment needs), including: Broadcom BCM4329FKUBG transceiver chip (e.g., providing 802.11n, Bluetooth 2.1+EDR, FM, etc.); a Broadcom BCM4752 GPS receiver with accelerometer, altimeter, GPS, gyroscope, magnetometer; a Broadcom BCM4335 transceiver chip (e.g., providing 2G, 3G, and 4G long-term evolution (LTE) cellular communications; 802.11ac, Bluetooth 4.0 low energy (LE) (e.g., beacon features)); a Broadcom BCM43341 transceiver chip (e.g., providing 2G, 3G and 4G LTE cellular communications; 802.11 g/, Bluetooth 4.0, near field communication (NFC), FM radio); an Infineon Technologies X-Gold 618-PMB9800 transceiver chip (e.g., providing 2G/3G HSDPA/HSUPA communications); a MediaTek MT6620 transceiver chip (e.g., providing 802.11a/ac/b/g/n, Bluetooth 4.0 LE, FM, GPS; a Lapis Semiconductor ML8511 UV sensor; a maxim integrated MAX44000 ambient light and infrared proximity sensor; a Texas Instruments WiLink WL1283 transceiver chip (e.g., providing 802.11n, Bluetooth 3.0, FM, GPS); and/or the like. The system clock typically has a crystal oscillator and generates a base signal through the computer systemization's circuit pathways. The clock is typically coupled to the system bus and various clock multipliers that is will increase or decrease the base operating frequency for other components interconnected in the computer systemization. The clock and various components in a computer systemization drive signals embodying information throughout the system. Such transmission and reception of instructions embodying information throughout a computer systemization may be commonly referred to as communications. These communicative instructions may further be transmitted, received, and the cause of return and/or reply communications beyond the instant computer systemization to: communications networks, input devices, other computer systemizations, peripheral devices, and/or the like. It should be understood that in alternative embodiments, any of the above components may be connected directly to one another, connected to the CPU, and/or organized in numerous variations employed as exemplified by various computer systems.
The CPU comprises at least one high-speed data processor adequate to execute program components for executing user and/or system-generated requests. The CPU is often packaged in a number of formats varying from large supercomputer(s) and mainframe(s) computers, down to mini computers, servers, desktop computers, laptops, thin clients (e.g., Chromebooks), netbooks, tablets (e.g., Android, iPads, and Windows tablets, etc.), mobile smartphones (e.g., Android, iPhones, Nokia, Palm and Windows phones, etc.), wearable device(s) (e.g., watches, glasses, goggles (e.g., Google Glass), etc.), and/or the like. Often, the processors themselves will incorporate various specialized processing units, such as, but not limited to: integrated system (bus) controllers, memory management control units, floating point units, and even specialized processing sub-units like graphics processing units, digital signal processing units, and/or the like. Additionally, processors may include internal fast access addressable memory, and be capable of mapping and addressing memory 3529 beyond the processor itself; internal memory may include, but is not limited to: fast registers, various levels of cache memory (e.g., level 1, 2, 3, etc.), RAM, etc. The processor may access this memory through the use of a memory address space that is accessible via instruction address, which the processor can construct and decode allowing it to access a circuit path to a specific memory address space having a memory state. The CPU may be a microprocessor such as: AMD's Athlon, Duron and/or Opteron; Apple's A series of processors (e.g., A5, A6, A7, A8, etc.); ARM's application, embedded and secure processors; IBM and/or Motorola's DragonBall and PowerPC; IBM's and Sony's Cell processor; Intel's 80X86 series (e.g., 80386, 80486), Pentium, Celeron, Core (2) Duo, i series (e.g., i3, i5, i7, etc.), Itanium, Xeon, and/or XScale; Motorola's 680X0 series (e.g., 68020, 68030, 68040, etc.); and/or the like processor(s). The CPU interacts with memory through instruction passing through conductive and/or transportive conduits (e.g., (printed) electronic and/or optic circuits) to execute stored instructions (i.e., program code) according to conventional data processing techniques. Such instruction passing facilitates communication within the REDUP controller and beyond through various interfaces. Should processing requirements dictate a greater amount speed and/or capacity, distributed processors (e.g., see Distributed REDUP below), mainframe, multi-core, parallel, and/or super-computer architectures may similarly be employed. Alternatively, should deployment requirements dictate greater portability, smaller mobile devices (e.g., Personal Digital Assistants (PDAs)) may be employed.
Depending on the particular implementation, features of the REDUP may be achieved by implementing a microcontroller such as CAST's R8051XC2 microcontroller; Intel's MCS 51 (i.e., 8051 microcontroller); and/or the like. Also, to implement certain features of the REDUP, some feature implementations may rely on embedded components, such as: Application-Specific Integrated Circuit (“ASIC”), Digital Signal Processing (“DSP”), Field Programmable Gate Array (“FPGA”), and/or the like embedded technology. For example, any of the REDUP component collection (distributed or otherwise) and/or features may be implemented via the microprocessor and/or via embedded components; e.g., via ASIC, coprocessor, DSP, FPGA, and/or the like. Alternately, some implementations of the REDUP may be implemented with embedded components that are configured and used to achieve a variety of features or signal processing.
Depending on the particular implementation, the embedded components may include software solutions, hardware solutions, and/or some combination of both hardware/software solutions. For example, REDUP features discussed herein may be achieved through implementing FPGAs, which are a semiconductor devices containing programmable logic components called “logic blocks”, and programmable interconnects, such as the high performance FPGA Virtex series and/or the low cost Spartan series manufactured by Xilinx. Logic blocks and interconnects can be programmed by the customer or designer, after the FPGA is manufactured, to implement any of the REDUP features. A hierarchy of programmable interconnects allow logic blocks to be interconnected as needed by the REDUP system designer/administrator, somewhat like a one-chip programmable breadboard. An FPGA's logic blocks can be programmed to perform the operation of basic logic gates such as AND, and XOR, or more complex combinational operators such as decoders or mathematical operations. In most FPGAs, the logic blocks also include memory elements, which may be circuit flip-flops or more complete blocks of memory. In some circumstances, the REDUP may be developed on regular FPGAs and then migrated into a fixed version that more resembles ASIC implementations. Alternate or coordinating implementations may migrate REDUP controller features to a final ASIC instead of or in addition to FPGAs. Depending on the implementation all of the aforementioned embedded components and microprocessors may be considered the “CPU” and/or “processor” for the REDUP.
The power source 3586 may be of any standard form for powering small electronic circuit board devices such as the following power cells-alkaline, lithium hydride, lithium ion, lithium polymer, nickel cadmium, solar cells, and/or the like. Other types of AC or DC power sources may be used as well. In the case of solar cells, in one embodiment, the case provides an aperture through which the solar cell may capture photonic energy. The power cell 3586 is connected to at least one of the interconnected subsequent components of the REDUP thereby providing an electric current to all subsequent components. In one example, the power source 3586 is connected to the system bus component 3504. In an alternative embodiment, an outside power source 3586 is provided through a connection across the I/O 3508 interface. For example, a USB and/or IEEE 1394 connection carries both data and power across the connection and is therefore a suitable source of power.
Interface bus(ses) 3507 may accept, connect, and/or communicate to a number of interface adapters, conventionally although not necessarily in the form of adapter cards, such as but not limited to: input output interfaces (I/O) 3508, storage interfaces 3509, network interfaces 3510, and/or the like. Optionally, cryptographic processor interfaces 3527 similarly may be connected to the interface bus. The interface bus provides for the communications of interface adapters with one another as well as with other components of the computer systemization. Interface adapters are adapted for a compatible interface bus. Interface adapters conventionally connect to the interface bus via a slot architecture. Conventional slot architectures may be employed, such as, but not limited to: Accelerated Graphics Port (AGP), Card Bus, (Extended) Industry Standard Architecture ((E)ISA), Micro Channel Architecture (MCA), NuBus, Peripheral Component Interconnect (Extended) (PCI(X), PCI Express, Personal Computer Memory Card International Association (PCMCIA), and/or the like.
Storage interfaces 3509 may accept, communicate, and/or connect to a number of storage devices such as, but not limited to: storage devices 3514, removable disc devices, and/or the like. Storage interfaces may employ connection protocols such as, but not limited to: (Ultra) (Serial) Advanced Technology Attachment (Packet Interface) ((Ultra) (Serial) ATA(PI)), (Enhanced) Integrated Drive Electronics ((E)IDE), Institute of Electrical and Electronics Engineers (IEEE) 1394, fiber channel, Small Computer Systems Interface (SCSI), Universal Serial Bus (USB), and/or the like.
Network interfaces 3510 may accept, communicate, and/or connect to a communications network 3513. Through a communications network 3513, the REDUP controller is accessible through remote clients 3533b (e.g., computers with web browsers) by users 3533a. Network interfaces may employ connection protocols such as, but not limited to: direct connect, Ethernet (thick, thin, twisted pair 10/100/1000/10000 Base T, and/or the like), Token Ring, wireless connection such as IEEE 802.11a-x, and/or the like. Should processing requirements dictate a greater amount speed and/or capacity, distributed network controllers (e.g., see Distributed REDUP below), architectures may similarly be employed to pool, load balance, and/or otherwise decrease/increase the communicative bandwidth required by the REDUP controller. A communications network may be any one and/or the combination of the following: a direct interconnection; the Internet; Interplanetary Internet (e.g., Coherent File Distribution Protocol (CFDP), Space Communications Protocol Specifications (SCPS), etc.); a Local Area Network (LAN); a Metropolitan Area Network (MAN); an Operating Missions as Nodes on the Internet (OMNI); a secured custom connection; a Wide Area Network (WAN); a wireless network (e.g., employing protocols such as, but not limited to a cellular, WiFi, Wireless Application Protocol (WAP), I-mode, and/or the like); and/or the like. A network interface may be regarded as a specialized form of an input output interface. Further, multiple network interfaces 3510 may be used to engage with various communications network types 3513. For example, multiple network interfaces may be employed to allow for the communication over broadcast, multicast, and/or unicast networks.
Input Output interfaces (I/O) 3508 may accept, communicate, and/or connect to user, peripheral devices 3512 (e.g., input devices 3511), cryptographic processor devices 3528, and/or the like. I/O may employ connection protocols such as, but not limited to: audio: analog, digital, monaural, RCA, stereo, and/or the like; data: Apple Desktop Bus (ADB), IEEE 1394a-b, serial, universal serial bus (USB); infrared; joystick; keyboard; midi; optical; PC AT; PS/2; parallel; radio; touch interfaces: capacitive, optical, resistive, etc. displays; video interface: Apple Desktop Connector (ADC), BNC, coaxial, component, composite, digital, Digital Visual Interface (DVI), (mini) displayport, high-definition multimedia interface (HDMI), RCA, RF antennae, S-Video, VGA, and/or the like; wireless transceivers: 802.11a/ac/b/g/n/x; Bluetooth; cellular (e.g., code division multiple access (CDMA), high speed packet access (HSPA(+)), high-speed downlink packet access (HSDPA), global system for mobile communications (GSM), long term evolution (LTE), WiMax, etc.); and/or the like. One typical output device may include a video display, which typically comprises a Cathode Ray Tube (CRT) or Liquid Crystal Display (LCD) based monitor with an interface (e.g., DVI circuitry and cable) that accepts signals from a video interface, may be used. The video interface composites information generated by a computer systemization and generates video signals based on the composited information in a video memory frame. Another output device is a television set, which accepts signals from a video interface. Typically, the video interface provides the composited video information through a video connection interface that accepts a video display interface (e.g., an RCA composite video connector accepting an RCA composite video cable; a DVI connector accepting a DVI display cable, etc.).
Peripheral devices 3512 may be connected and/or communicate to I/O and/or other facilities of the like such as network interfaces, storage interfaces, directly to the interface bus, system bus, the CPU, and/or the like. Peripheral devices may be external, internal and/or part of the REDUP controller. Peripheral devices may include: antenna, audio devices (e.g., line-in, line-out, microphone input, speakers, etc.), cameras (e.g., gesture (e.g., Microsoft Kinect) detection, motion detection, still, video, webcam, etc.), dongles (e.g., for copy protection, ensuring secure transactions with a digital signature, and/or the like), external processors (for added capabilities; e.g., crypto devices 528), force-feedback devices (e.g., vibrating motors), infrared (IR) transceiver, network interfaces, printers, scanners, sensors/sensor arrays and peripheral extensions (e.g., ambient light, GPS, gyroscopes, proximity, temperature, etc.), storage devices, transceivers (e.g., cellular, GPS, etc.), video devices (e.g., goggles, monitors, etc.), video sources, visors, and/or the like. Peripheral devices often include types of input devices (e.g., cameras).
User input devices 3511 often are a type of peripheral device 512 (see above) and may include: card readers, dongles, finger print readers, gloves, graphics tablets, joysticks, keyboards, microphones, mouse (mice), remote controls, security/biometric devices (e.g., fingerprint reader, iris reader, retina reader, etc.), touch screens (e.g., capacitive, resistive, etc.), trackballs, trackpads, styluses, and/or the like.
It should be noted that although user input devices and peripheral devices may be employed, the REDUP controller may be embodied as an embedded, dedicated, and/or monitor-less (i.e., headless) device, wherein access would be provided over a network interface connection.
Cryptographic units such as, but not limited to, microcontrollers, processors 3526, interfaces 3527, and/or devices 3528 may be attached, and/or communicate with the REDUP controller. A MC68HC16 microcontroller, manufactured by Motorola Inc., may be used for and/or within cryptographic units. The MC68HC16 microcontroller utilizes a 16-bit multiply-and-accumulate instruction in the 16 MHz configuration and requires less than one second to perform a 512-bit RSA private key operation. Cryptographic units support the authentication of communications from interacting agents, as well as allowing for anonymous transactions. Cryptographic units may also be configured as part of the CPU. Equivalent microcontrollers and/or processors may also be used. Other commercially available specialized cryptographic processors include: Broadcom's CryptoNetX and other Security Processors; nCipher's nShield; SafeNet's Luna PCI (e.g., 7100) series; Semaphore Communications' 40 MHz Roadrunner 184; Sun's Cryptographic Accelerators (e.g., Accelerator 6000 PCIe Board, Accelerator 500 Daughtercard); Via Nano Processor (e.g., L2100, L2200, U2400) line, which is capable of performing 500+MB/s of cryptographic instructions; VLSI Technology's 33 MHz 6868; and/or the like.
Generally, any mechanization and/or embodiment allowing a processor to affect the storage and/or retrieval of information is regarded as memory 3529. However, memory is a fungible technology and resource, thus, any number of memory embodiments may be employed in lieu of or in concert with one another. It is to be understood that the REDUP controller and/or a computer systemization may employ various forms of memory 3529. For example, a computer systemization may be configured wherein the operation of on-chip CPU memory (e.g., registers), RAM, ROM, and any other storage devices are provided by a paper punch tape or paper punch card mechanism; however, such an embodiment would result in an extremely slow rate of operation. In a typical configuration, memory 3529 will include ROM 3506, RAM 3505, and a storage device 3514. A storage device 3514 may be any conventional computer system storage. Storage devices may include: an array of devices (e.g., Redundant Array of Independent Disks (RAID)); a drum; a (fixed and/or removable) magnetic disk drive; a magneto-optical drive; an optical drive (i.e., Blueray, CD ROM/RAM/Recordable (R)/ReWritable (RW), DVD R/RW, HD DVD R/RW etc.); RAM drives; solid state memory devices (USB memory, solid state drives (SSD), etc.); other processor-readable storage mediums; and/or other devices of the like. Thus, a computer systemization generally requires and makes use of memory.
The memory 3529 may contain a collection of program and/or database components and/or data such as, but not limited to: operating system component(s) 3515 (operating system); information server component(s) 3516 (information server); user interface component(s) 3517 (user interface); Web browser component(s) 3518 (Web browser); database(s) 3519; mail server component(s) 3521; mail client component(s) 3522; cryptographic server component(s) 3520 (cryptographic server); the REDUP component(s) 3535; and/or the like (i.e., collectively a component collection). These components may be stored and accessed from the storage devices and/or from storage devices accessible through an interface bus. Although non-conventional program components such as those in the component collection, typically, are stored in a local storage device 3514, they may also be loaded and/or stored in memory such as: peripheral devices, RAM, remote storage facilities through a communications network, ROM, various forms of memory, and/or the like.
The operating system component 3515 is an executable program component facilitating the operation of the REDUP controller. Typically, the operating system facilitates access of I/O, network interfaces, peripheral devices, storage devices, and/or the like. The operating system may be a highly fault tolerant, scalable, and secure system such as: Apple's Macintosh OS X (Server); AT&T Plan 9; Be OS; Google's Chrome; Microsoft's Windows 7/8; Unix and Unix-like system distributions (such as AT&T's UNIX; Berkley Software Distribution (BSD) variations such as FreeBSD, NetBSD, OpenBSD, and/or the like; Linux distributions such as Red Hat, Ubuntu, and/or the like); and/or the like operating systems. However, more limited and/or less secure operating systems also may be employed such as Apple Macintosh OS, IBM OS/2, Microsoft DOS, Microsoft Windows 2000/2003/3.1/95/98/CE/Millenium/Mobile/NT/Vista/XP (Server), Palm OS, and/or the like. Additionally, for robust mobile deployment applications, mobile operating systems may be used, such as: Apple's iOS; China Operating System COS; Google's Android; Microsoft Windows RT/Phone; Palm's WebOS; Samsung/Intel's Tizen; and/or the like. An operating system may communicate to and/or with other components in a component collection, including itself, and/or the like. Most frequently, the operating system communicates with other program components, user interfaces, and/or the like. For example, the operating system may contain, communicate, generate, obtain, and/or provide program component, system, user, and/or data communications, requests, and/or responses. The operating system, once executed by the CPU, may enable the interaction with communications networks, data, I/O, peripheral devices, program components, memory, user input devices, and/or the like. The operating system may provide communications protocols that allow the REDUP controller to communicate with other entities through a communications network 3513. Various communication protocols may be used by the REDUP controller as a subcarrier transport mechanism for interaction, such as, but not limited to: multicast, TCP/IP, UDP, unicast, and/or the like.
An information server component 3516 is a stored program component that is executed by a CPU. The information server may be a conventional Internet information server such as, but not limited to Apache Software Foundation's Apache, Microsoft's Internet Information Server, and/or the like. The information server may allow for the execution of program components through facilities such as Active Server Page (ASP), ActiveX, (ANSI) (Objective-) C (++), C# and/or .NET, Common Gateway Interface (CGI) scripts, dynamic (D) hypertext markup language (HTML), FLASH, Java, JavaScript, Practical Extraction Report Language (PERL), Hypertext Pre-Processor (PHP), pipes, Python, wireless application protocol (WAP), WebObjects, and/or the like. The information server may support secure communications protocols such as, but not limited to, File Transfer Protocol (FTP); HyperText Transfer Protocol (HTTP); Secure Hypertext Transfer Protocol (HTTPS), Secure Socket Layer (SSL), messaging protocols (e.g., America Online (AOL) Instant Messenger (AIM), Application Exchange (APEX), ICQ, Internet Relay Chat (IRC), Microsoft Network (MSN) Messenger Service, Presence and Instant Messaging Protocol (PRIM), Internet Engineering Task Force's (IETF's) Session Initiation Protocol (SIP), SIP for Instant Messaging and Presence Leveraging Extensions (SIMPLE), open XML-based Extensible Messaging and Presence Protocol (XMPP) (i.e., Jabber or Open Mobile Alliance's (OMA's) Instant Messaging and Presence Service (IMPS)), Yahoo! Instant Messenger Service, and/or the like. The information server provides results in the form of Web pages to Web browsers, and allows for the manipulated generation of the Web pages through interaction with other program components. After a Domain Name System (DNS) resolution portion of an HTTP request is resolved to a particular information server, the information server resolves requests for information at specified locations on the REDUP controller based on the remainder of the HTTP request. For example, a request such as http://123.124.125.126/myInformation html might have the IP portion of the request “123.124.125.126” resolved by a DNS server to an information server at that IP address; that information server might in turn further parse the http request for the “/myInformation html” portion of the request and resolve it to a location in memory containing the information “myInformation.html” Additionally, other information serving protocols may be employed across various ports, e.g., FTP communications across port 21, and/or the like. An information server may communicate to and/or with other components in a component collection, including itself, and/or facilities of the like. Most frequently, the information server communicates with the REDUP database 3519, operating systems, other program components, user interfaces, Web browsers, and/or the like.
Access to the REDUP database may be achieved through a number of database bridge mechanisms such as through scripting languages as enumerated below (e.g., CGI) and through inter-application communication channels as enumerated below (e.g., CORBA, WebObjects, etc.). Any data requests through a Web browser are parsed through the bridge mechanism into appropriate grammars as required by the REDUP. In one embodiment, the information server would provide a Web form accessible by a Web browser. Entries made into supplied fields in the Web form are tagged as having been entered into the particular fields, and parsed as such. The entered terms are then passed along with the field tags, which act to instruct the parser to generate queries directed to appropriate tables and/or fields. In one embodiment, the parser may generate queries in standard SQL by instantiating a search string with the proper join/select commands based on the tagged text entries, wherein the resulting command is provided over the bridge mechanism to the REDUP as a query. Upon generating query results from the query, the results are passed over the bridge mechanism, and may be parsed for formatting and generation of a new results Web page by the bridge mechanism. Such a new results Web page is then provided to the information server, which may supply it to the requesting Web browser.
Also, an information server may contain, communicate, generate, obtain, and/or provide program component, system, user, and/or data communications, requests, and/or responses.
Computer interfaces in some respects are similar to automobile operation interfaces. Automobile operation interface elements such as steering wheels, gearshifts, and speedometers facilitate the access, operation, and display of automobile resources, and status. Computer interaction interface elements such as check boxes, cursors, menus, scrollers, and windows (collectively and commonly referred to as widgets) similarly facilitate the access, capabilities, operation, and display of data and computer hardware and operating system resources, and status. Operation interfaces are commonly called user interfaces. Graphical user interfaces (GUIs) such as the Apple's iOS, Macintosh Operating System's Aqua; IBM's OS/2; Google's Chrome (e.g., and other webbrowser/cloud based client OSs); Microsoft's Windows varied UIs 2000/2003/3.1/95/98/CE/Millenium/Mobile/NT/Vista/XP (Server) (i.e., Aero, Surface, etc.); Unix's X-Windows (e.g., which may include additional Unix graphic interface libraries and layers such as K Desktop Environment (KDE), mythTV and GNU Network Object Model Environment (GNOME)), web interface libraries (e.g., ActiveX, AJAX, (D)HTML, FLASH, Java, JavaScript, etc. interface libraries such as, but not limited to, Dojo, jQuery(UI), MooTools, Prototype, script.aculo.us, SWFObject, Yahoo! User Interface, any of which may be used and) provide a baseline and means of accessing and displaying information graphically to users.
A user interface component 3517 is a stored program component that is executed by a CPU. The user interface may be a conventional graphic user interface as provided by, with, and/or atop operating systems and/or operating environments such as already discussed. The user interface may allow for the display, execution, interaction, manipulation, and/or operation of program components and/or system facilities through textual and/or graphical facilities. The user interface provides a facility through which users may affect, interact, and/or operate a computer system. A user interface may communicate to and/or with other components in a component collection, including itself, and/or facilities of the like. Most frequently, the user interface communicates with operating systems, other program components, and/or the like. The user interface may contain, communicate, generate, obtain, and/or provide program component, system, user, and/or data communications, requests, and/or responses.
A Web browser component 3518 is a stored program component that is executed by a CPU. The Web browser may be a conventional hypertext viewing application such as Apple's (mobile) Safari, Google's Chrome, Microsoft Internet Explorer, Mozilla's Firefox, Netscape Navigator, and/or the like. Secure Web browsing may be supplied with 128 bit (or greater) encryption by way of HTTPS, SSL, and/or the like. Web browsers allowing for the execution of program components through facilities such as ActiveX, AJAX, (D)HTML, FLASH, Java, JavaScript, web browser plug-in APIs (e.g., FireFox, Safari Plug-in, and/or the like APIs), and/or the like. Web browsers and like information access tools may be integrated into PDAs, cellular telephones, and/or other mobile devices. A Web browser may communicate to and/or with other components in a component collection, including itself, and/or facilities of the like. Most frequently, the Web browser communicates with information servers, operating systems, integrated program components (e.g., plug-ins), and/or the like; e.g., it may contain, communicate, generate, obtain, and/or provide program component, system, user, and/or data communications, requests, and/or responses. Also, in place of a Web browser and information server, a combined application may be developed to perform similar operations of both. The combined application would similarly affect the obtaining and the provision of information to users, user agents, and/or the like from the REDUP enabled nodes. The combined application may be nugatory on systems employing standard Web browsers.
A mail server component 3521 is a stored program component that is executed by a CPU 3503. The mail server may be a conventional Internet mail server such as, but not limited to: dovecot, Courier IMAP, Cyrus IMAP, Maildir, Microsoft Exchange, sendmail, and/or the like. The mail server may allow for the execution of program components through facilities such as ASP, ActiveX, (ANSI) (Objective-) C (++), C# and/or .NET, CGI scripts, Java, JavaScript, PERL, PHP, pipes, Python, WebObjects, and/or the like. The mail server may support communications protocols such as, but not limited to: Internet message access protocol (IMAP), Messaging Application Programming Interface (MAPI)/Microsoft Exchange, post office protocol (POP3), simple mail transfer protocol (SMTP), and/or the like. The mail server can route, forward, and process incoming and outgoing mail messages that have been sent, relayed and/or otherwise traversing through and/or to the REDUP. Alternatively, the mail server component may be distributed out to mail service providing entities such as Google's cloud services (e.g., Gmail and notifications may alternatively be provided via messenger services such as AOL's Instant Messenger, Apple's iMessage, Google Messenger, SnapChat, etc.).
Access to the REDUP mail may be achieved through a number of APIs offered by the individual Web server components and/or the operating system.
Also, a mail server may contain, communicate, generate, obtain, and/or provide program component, system, user, and/or data communications, requests, information, and/or responses.
A mail client component 3522 is a stored program component that is executed by a CPU 3503. The mail client may be a conventional mail viewing application such as Apple Mail, Microsoft Entourage, Microsoft Outlook, Microsoft Outlook Express, Mozilla, Thunderbird, and/or the like. Mail clients may support a number of transfer protocols, such as: IMAP, Microsoft Exchange, POP3, SMTP, and/or the like. A mail client may communicate to and/or with other components in a component collection, including itself, and/or facilities of the like. Most frequently, the mail client communicates with mail servers, operating systems, other mail clients, and/or the like; e.g., it may contain, communicate, generate, obtain, and/or provide program component, system, user, and/or data communications, requests, information, and/or responses. Generally, the mail client provides a facility to compose and transmit electronic mail messages.
A cryptographic server component 3520 is a stored program component that is executed by a CPU 3503, cryptographic processor 3526, cryptographic processor interface 3527, cryptographic processor device 3528, and/or the like. Cryptographic processor interfaces will allow for expedition of encryption and/or decryption requests by the cryptographic component; however, the cryptographic component, alternatively, may run on a conventional CPU. The cryptographic component allows for the encryption and/or decryption of provided data. The cryptographic component allows for both symmetric and asymmetric (e.g., Pretty Good Protection (PGP)) encryption and/or decryption. The cryptographic component may employ cryptographic techniques such as, but not limited to: digital certificates (e.g., X.509 authentication framework), digital signatures, dual signatures, enveloping, password access protection, public key management, and/or the like. The cryptographic component will facilitate numerous (encryption and/or decryption) security protocols such as, but not limited to: checksum, Data Encryption Standard (DES), Elliptical Curve Encryption (ECC), International Data Encryption Algorithm (IDEA), Message Digest 5 (MD5, which is a one way hash operation), passwords, Rivest Cipher (RC5), Rijndael, RSA (which is an Internet encryption and authentication system that uses an algorithm developed in 1977 by Ron Rivest, Adi Shamir, and Leonard Adleman), Secure Hash Algorithm (SHA), Secure Socket Layer (SSL), Secure Hypertext Transfer Protocol (HTTPS), Transport Layer Security (TLS), and/or the like. Employing such encryption security protocols, the REDUP may encrypt all incoming and/or outgoing communications and may serve as node within a virtual private network (VPN) with a wider communications network. The cryptographic component facilitates the process of “security authorization” whereby access to a resource is inhibited by a security protocol wherein the cryptographic component effects authorized access to the secured resource. In addition, the cryptographic component may provide unique identifiers of content, e.g., employing and MD5 hash to obtain a unique signature for an digital audio file. A cryptographic component may communicate to and/or with other components in a component collection, including itself, and/or facilities of the like. The cryptographic component supports encryption schemes allowing for the secure transmission of information across a communications network to enable the REDUP component to engage in secure transactions if so desired. The cryptographic component facilitates the secure accessing of resources on the REDUP and facilitates the access of secured resources on remote systems; i.e., it may act as a client and/or server of secured resources. Most frequently, the cryptographic component communicates with information servers, operating systems, other program components, and/or the like. The cryptographic component may contain, communicate, generate, obtain, and/or provide program component, system, user, and/or data communications, requests, and/or responses.
The REDUP database component 3519 may be embodied in a database and its stored data. The database is a stored program component, which is executed by the CPU; the stored program component portion configuring the CPU to process the stored data. The database may be a conventional, fault tolerant, relational, scalable, secure database such as MySQL, Oracle, Sybase, etc. may be used. Additionally, optimized fast memory and distributed databases such as IBM's Netezza, MongoDB's MongoDB, opensource Hadoop, opensource VoltDB, SAP's Hana, etc. Relational databases are an extension of a flat file. Relational databases consist of a series of related tables. The tables are interconnected via a key field. Use of the key field allows the combination of the tables by indexing against the key field; i.e., the key fields act as dimensional pivot points for combining information from various tables. Relationships generally identify links maintained between tables by matching primary keys. Primary keys represent fields that uniquely identify the rows of a table in a relational database. Alternative key fields may be used from any of the fields having unique value sets, and in some alternatives, even non-unique values in combinations with other fields. More precisely, they uniquely identify rows of a table on the “one” side of a one-to-many relationship.
Alternatively, the REDUP database may be implemented using various standard data-structures, such as an array, hash, (linked) list, struct, structured text file (e.g., XML), table, and/or the like. Such data-structures may be stored in memory and/or in (structured) files. In another alternative, an object-oriented database may be used, such as Frontier, ObjectStore, Poet, Zope, and/or the like. Object databases can include a number of object collections that are grouped and/or linked together by common attributes; they may be related to other object collections by some common attributes. Object-oriented databases perform similarly to relational databases with the exception that objects are not just pieces of data but may have other types of capabilities encapsulated within a given object. If the REDUP database is implemented as a data-structure, the use of the REDUP database 3519 may be integrated into another component such as the REDUP component 3535. Also, the database may be implemented as a mix of data structures, objects, and relational structures. Databases may be consolidated and/or distributed in countless variations (e.g., see Distributed REDUP below). Portions of databases, e.g., tables, may be exported and/or imported and thus decentralized and/or integrated.
In one embodiment, the database component 3519 includes several tables 3519a-1:
An accounts table 3519a includes fields such as, but not limited to: an accountID, accountOwnerID, accountContactID, assetIDs, deviceIDs, paymentIDs, transactionIDs, userIDs, accountType (e.g., agent, entity (e.g., corporate, non-profit, partnership, etc.), individual, etc.), accountCreationDate, accountUpdateDate, accountName, accountNumber, routingNumber, linkWalletsID, accountPrioritAccaountRatio, accountAddress, accountState, accountZIPcode, accountCountry, accountEmail, accountPhone, accountAuthKey, accountIPaddress, accountURLAccessCode, accountPortNo, accountAuthorizationCode, accountAccessPrivileges, accountPreferences, accountRestrictions, and/or the like;
A users table 3519b includes fields such as, but not limited to: a userID, userSSN, taxID, userContactID, accountID, assetIDs, deviceIDs, paymentIDs, transactionIDs, userType (e.g., agent, entity (e.g., corporate, non-profit, partnership, etc.), individual, etc.), namePrefix, firstName, middleName, lastName, nameSuffix, DateOfBirth, userAge, userName, userEmail, userSocialAccountID, contactType, contactRelationship, userPhone, userAddress, userCity, userState, userZIPCode, userCountry, userAuthorizationCode, userAccessPrivilges, userPreferences, userRestrictions, and/or the like (the user table may support and/or track multiple entity accounts on a REDUP);
An devices table 3519c includes fields such as, but not limited to: deviceID, sensorIDs, accountID, assetIDs, paymentIDs, deviceType, deviceName, deviceManufacturer, deviceModel, deviceVersion, deviceSerialNo, deviceIPaddress, deviceMACaddress, device_ECID, deviceUUID, deviceLocation, deviceCertificate, deviceOS, appIDs, deviceResources, deviceSession, authKey, deviceSecureKey, walletAppInstalledFlag, deviceAccessPrivileges, devicePreferences, deviceRestrictions, hardware_config, software_config, storagelocation, sensor_value, pin_reading, data_length, channel_requirement, sensor_name, sensor_model_no, sensor_manufacturer, sensor_type, sensor_serial_number, sensor_power_requirement, device_power_requirement, location, sensor_associated_tool, sensor_dimensions, device_dimensions, sensor_communications_type, device_communications_type, power_percentage, power_condition, temperature_setting, speed_adjust, hold_duration, part_actuation, segmentIDs, and/or the like. Device table may, in some embodiments, include fields corresponding to one or more Bluetooth profiles, such as those published at https://www.bluetooth.org/en-us/specification/adopted-specifications, and/or other device specifications, and/or the like;
An apps table 3519d includes fields such as, but not limited to: appID, appName, appType, appDependencies, accountID, deviceIDs, transactionID, userID, appStoreAuthKey, appStoreAccountID, appStoreIPaddress, appStoreURLaccessCode, appStorePortNo, appAccessPrivileges, appPreferences, appRestrictions, portNum, access_API_call, linked_wallets_list, and/or the like;
An assets table 3519e includes fields such as, but not limited to: assetID, accountID, userID, distributorAccountID, distributorPaymentID, distributorOnwerID, assetOwnerID, assetType, assetSourceDeviceID, assetSourceDeviceType, assetSourceDeviceName, assetSourceDistributionChannelID, assetSourceDistributionChannelType, assetSourceDistributionChannelName, assetTargetChannelID, assetTargetChannelType, assetTargetChannelName, assetName, assetSeriesName, assetSeriesSeason, assetSeriesEpisode, assetCode, assetQuantity, assetCost, assetPrice, assetValue, assetManufactuer, assetModelNo, assetSerialNo, assetLocation, assetAddress, assetState, assetZIPcode, assetState, assetCountry, assetEmail, assetIPaddress, assetURLaccessCode, assetOwnerAccountID, subscriptionIDs, assetAuthroizationCode, assetAccessPrivileges, assetPreferences, assetRestrictions, assetAPI, assetAPIconnectionAddress, and/or the like;
A payments table 3519f includes fields such as, but not limited to: paymentID, accountID, userID, paymentType, paymentAccountNo, paymentAccountName, paymentAccountAuthorizationCodes, paymentExpirationDate, paymentCCV, paymentRoutingNo, paymentRoutingType, paymentAddress, paymentState, paymentZIPcode, paymentCountry, paymentEmail, paymentAuthKey, paymentIPaddress, paymentURLaccessCode, paymentPortNo, paymentAccessPrivileges, paymentPreferences, payementRestrictions, and/or the like;
An transactions table 3519g includes fields such as, but not limited to: transactionID, accountID, assetIDs, deviceIDs, paymentIDs, transactionIDs, userID, merchantID, transactionType, transactionDate, transactionTime, transactionAmount, transactionQuantity, transactionDetails, productsList, productType, productTitle, productsSummary, productParamsList, transactionNo, transactionAccessPrivileges, transactionPreferences, transactionRestrictions, merchantAuthKey, merchantAuthCode, and/or the like;
An merchants table 3519h includes fields such as, but not limited to: merchantID, merchantTaxID, merchanteName, merchantContactUserID, accountID, issuerID, acquirerID, merchantEmail, merchantAddress, merchantState, merchantZIPcode, merchantCountry, merchantAuthKey, merchantIPaddress, portNum, merchantURLaccessCode, merchantPortNo, merchantAccessPrivileges, merchantPreferences, merchantRestrictions, and/or the like;
An ads table 3519i includes fields such as, but not limited to: adID, advertiserID, adMerchantID, adNetworkID, adName, adTags, advertiserName, adSponsor, adTime, adGeo, adAttributes, adFormat, adProduct, adText, adMedia, adMediaID, adChannelID, adTagTime, adAudioSignature, adHash, adTemplateID, adTemplateData, adSourceID, adSourceName, adSourceServerlP, adSourceURL, adSourceSecurityProtocol, adSourceFTP, adAuthKey, adAccessPrivileges, adPreferences, adRestrictions, adNetworkXchangeID, adNetworkXchangeName, adNetworkXchangeCost, adNetworkXchangeMetricType (e.g., CPA, CPC, CPM, CTR, etc.), adNetworkXchangeMetricValue, adNetworkXchangeServer, adNetworkXchangePortNumber, publisherID, publisherAddress, publisherURL, publisherTag, publisherIndustry, publisherName, publisherDescription, siteDomain, siteURL, siteContent, siteTag, siteContext, sitelmpression, siteVisits, siteHeadline, sitePage, siteAdPrice, sitePlacement, sitePosition, bidID, bidExchange, bidOS, bidTarget, bidTimestamp, bidPrice, bidlmpressionID, bidType, bidScore, adType (e.g., mobile, desktop, wearable, largescreen, interstitial, etc.), assetID, merchantID, deviceID, userID, accountID, impressionID, impressionOS, impressionTimeStamp, impressionGeo, impressionAction, impressionType, impressionPublisherID, impressionPublisherURL, and/or the like;
A segments table 3519j includes fields such as, but not limited to: segmentID, segmentName, segmentParameters, segmentDevicesList, componentList, and/or the like;
An updates table 3519k includes fields such as, but not limited to: updateID, updateDescription, updatePackageID, updatePackageVersion, updatePackagePriority, updatePackageSUMsData, and/or the like;
A logs table 35191 includes fields such as, but not limited to: logID, logData, logTimestamp, logOntology, and/or the like.
In one embodiment, the REDUP database may interact with other database systems. For example, employing a distributed database system, queries and data access by search REDUP component may treat the combination of the REDUP database, an integrated data security layer database as a single database entity (e.g., see Distributed REDUP below).
In one embodiment, user programs may contain various user interface primitives, which may serve to update the REDUP. Also, various accounts may require custom database tables depending upon the environments and the types of clients the REDUP may need to serve. It should be noted that any unique fields may be designated as a key field throughout. In an alternative embodiment, these tables have been decentralized into their own databases and their respective database controllers (i.e., individual database controllers for each of the above tables). Employing standard data processing techniques, one may further distribute the databases over several computer systemizations and/or storage devices. Similarly, configurations of the decentralized database controllers may be varied by consolidating and/or distributing the various database components 3519a-1. The REDUP may be configured to keep track of various settings, inputs, and parameters via database controllers.
The REDUP database may communicate to and/or with other components in a component collection, including itself, and/or facilities of the like. Most frequently, the REDUP database communicates with the REDUP component, other program components, and/or the like. The database may contain, retain, and provide information regarding other nodes and data.
The REDUP component 3535 is a stored program component that is executed by a CPU. In one embodiment, the REDUP component incorporates any and/or all combinations of the aspects of the REDUP that was discussed in the previous figures. As such, the REDUP affects accessing, obtaining and the provision of information, services, transactions, and/or the like across various communications networks. The features and embodiments of the REDUP discussed herein increase network efficiency by reducing data transfer requirements the use of more efficient data structures and mechanisms for their transfer and storage. As a consequence, more data may be transferred in less time, and latencies with regard to transactions, are also reduced. In many cases, such reduction in storage, transfer time, bandwidth requirements, latencies, etc., will reduce the capacity and structural infrastructure requirements to support the REDUP's features and facilities, and in many cases reduce the costs, energy consumption/requirements, and extend the life of REDUP's underlying infrastructure; this has the added benefit of making the REDUP more reliable. Similarly, many of the features and mechanisms are designed to be easier for users to use and access, thereby broadening the audience that may enjoy/employ and exploit the feature sets of the REDUP; such ease of use also helps to increase the reliability of the REDUP. In addition, the feature sets include heightened security as noted via the Cryptographic components 3520, 3526, 3528 and throughout, making access to the features and data more reliable and secure.
The REDUP transforms telemetry inputs, via REDUP components (e.g., DSD, UDA, PDA, UTA, PSC, UPC, ELA, AC), into remote embedded updates outputs.
The REDUP component enabling access of information between nodes may be developed by employing standard development tools and languages such as, but not limited to: Apache components, Assembly, ActiveX, binary executables, (ANSI) (Objective-) C (++), C# and/or .NET, database adapters, CGI scripts, Java, JavaScript, mapping tools, procedural and object oriented development tools, PERL, PHP, Python, shell scripts, SQL commands, web application server extensions, web development environments and libraries (e.g., Microsoft's ActiveX; Adobe AIR, FLEX & FLASH; AJAX; (D)HTML; Dojo, Java; JavaScript; jQuery(UI); MooTools; Prototype; script.aculo.us; Simple Object Access Protocol (SOAP); SWFObject; Yahoo! User Interface; and/or the like), WebObjects, and/or the like. In one embodiment, the REDUP server employs a cryptographic server to encrypt and decrypt communications. The REDUP component may communicate to and/or with other components in a component collection, including itself, and/or facilities of the like. Most frequently, the REDUP component communicates with the REDUP database, operating systems, other program components, and/or the like. The REDUP may contain, communicate, generate, obtain, and/or provide program component, system, user, and/or data communications, requests, and/or responses.
The structure and/or operation of any of the REDUP node controller components may be combined, consolidated, and/or distributed in any number of ways to facilitate development and/or deployment. Similarly, the component collection may be combined in any number of ways to facilitate deployment and/or development. To accomplish this, one may integrate the components into a common code base or in a facility that can dynamically load the components on demand in an integrated fashion. As such a combination of hardware may be distributed within a location, within a region and/or globally where logical access to a controller may be abstracted as a singular node, yet where a multitude of private, semiprivate and publically accessible node controllers (e.g., via dispersed data centers) are coordinated to serve requests (e.g., providing private cloud, semi-private cloud, and public cloud computing resources) and allowing for the serving of such requests in discrete regions (e.g., isolated, local, regional, national, global cloud access).
The component collection may be consolidated and/or distributed in countless variations through standard data processing and/or development techniques. Multiple instances of any one of the program components in the program component collection may be instantiated on a single node, and/or across numerous nodes to improve performance through load-balancing and/or data-processing techniques. Furthermore, single instances may also be distributed across multiple controllers and/or storage devices; e.g., databases. All program component instances and controllers working in concert may do so through standard data processing communication techniques.
The configuration of the REDUP controller will depend on the context of system deployment. Factors such as, but not limited to, the budget, capacity, location, and/or use of the underlying hardware resources may affect deployment requirements and configuration. Regardless of if the configuration results in more consolidated and/or integrated program components, results in a more distributed series of program components, and/or results in some combination between a consolidated and distributed configuration, data may be communicated, obtained, and/or provided. Instances of components consolidated into a common code base from the program component collection may communicate, obtain, and/or provide data. This may be accomplished through intra-application data processing communication techniques such as, but not limited to: data referencing (e.g., pointers), internal messaging, object instance variable communication, shared memory space, variable passing, and/or the like. For example, cloud services such as Amazon Data Services, Microsoft Azure, Hewlett Packard Helion, IBM Cloud services allow for REDUP controller and/or REDUP component collections to be hosted in full or partially for varying degrees of scale.
If component collection components are discrete, separate, and/or external to one another, then communicating, obtaining, and/or providing data with and/or to other component components may be accomplished through inter-application data processing communication techniques such as, but not limited to: Application Program Interfaces (API) information passage; (distributed) Component Object Model ((D)COM), (Distributed) Object Linking and Embedding ((D)OLE), and/or the like), Common Object Request Broker Architecture (CORBA), Jini local and remote application program interfaces, JavaScript Object Notation (JSON), Remote Method Invocation (RMI), SOAP, process pipes, shared files, and/or the like. Messages sent between discrete component components for inter-application communication or within memory spaces of a singular component for intra-application communication may be facilitated through the creation and parsing of a grammar. A grammar may be developed by using development tools such as lex, yacc, XML, and/or the like, which allow for grammar generation and parsing capabilities, which in turn may form the basis of communication messages within and between components.
For example, a grammar may be arranged to recognize the tokens of an HTTP post command, e.g.:
where Value1 is discerned as being a parameter because “http://” is part of the grammar syntax, and what follows is considered part of the post value. Similarly, with such a grammar, a variable “Value1” may be inserted into an “http://” post command and then sent. The grammar syntax itself may be presented as structured data that is interpreted and/or otherwise used to generate the parsing mechanism (e.g., a syntax description text file as processed by lex, yacc, etc.). Also, once the parsing mechanism is generated and/or instantiated, it itself may process and/or parse structured data such as, but not limited to: character (e.g., tab) delineated text, HTML, structured text streams, XML, and/or the like structured data. In another embodiment, inter-application data processing protocols themselves may have integrated and/or readily available parsers (e.g., JSON, SOAP, and/or like parsers) that may be employed to parse (e.g., communications) data. Further, the parsing grammar may be used beyond message parsing, but may also be used to parse: databases, data collections, data stores, structured data, and/or the like. Again, the desired configuration will depend upon the context, environment, and requirements of system deployment.
For example, in some implementations, the REDUP controller may be executing a PHP script implementing a Secure Sockets Layer (“SSL”) socket server via the information server, which listens to incoming communications on a server port to which a client may send data, e.g., data encoded in JSON format. Upon identifying an incoming communication, the PHP script may read the incoming message from the client device, parse the received JSON-encoded text data to extract information from the JSON-encoded text data into PHP script variables, and store the data (e.g., client identifying information, etc.) and/or extracted information in a relational database accessible using the Structured Query Language (“SQL”). An exemplary listing, written substantially in the form of PHP/SQL commands, to accept JSON-encoded input data from a client device via a SSL connection, parse the data to extract variables, and store the data to a database, is provided below:
Also, the following resources may be used to provide example embodiments regarding SOAP parser implementation:
Additional embodiments may include:
In order to address various issues and advance the art, the entirety of this application for Remote Embedded Device Update Platform Apparatuses, Methods and Systems (including the Cover Page, Title, Headings, Field, Background, Summary, Brief Description of the Drawings, Detailed Description, Claims, Abstract, Figures, Appendices, and otherwise) shows, by way of illustration, various embodiments in which the claimed innovations may be practiced. The advantages and features of the application are of a representative sample of embodiments only, and are not exhaustive and/or exclusive. They are presented only to assist in understanding and teach the claimed principles. It should be understood that they are not representative of all claimed innovations. As such, certain aspects of the disclosure have not been discussed herein. That alternate embodiments may not have been presented for a specific portion of the innovations or that further undescribed alternate embodiments may be available for a portion is not to be considered a disclaimer of those alternate embodiments. It will be appreciated that many of those undescribed embodiments incorporate the same principles of the innovations and others are equivalent. Thus, it is to be understood that other embodiments may be utilized and functional, logical, operational, organizational, structural and/or topological modifications may be made without departing from the scope and/or spirit of the disclosure. As such, all examples and/or embodiments are deemed to be non-limiting throughout this disclosure. Also, no inference should be drawn regarding those embodiments discussed herein relative to those not discussed herein other than it is as such for purposes of reducing space and repetition. For instance, it is to be understood that the logical and/or topological structure of any combination of any program components (a component collection), other components, data flow order, logic flow order, and/or any present feature sets as described in the FIGS. and/or throughout are not limited to a fixed operating order and/or arrangement, but rather, any disclosed order is exemplary and all equivalents, regardless of order, are contemplated by the disclosure. Similarly, descriptions of embodiments disclosed throughout this disclosure, any reference to direction or orientation is merely intended for convenience of description and is not intended in any way to limit the scope of described embodiments. Relative terms such as “lower,” “upper,” “horizontal,” “vertical,” “above,” “below,” “up,” “down,” “top” and “bottom” as well as derivative thereof (e.g., “horizontally,” “downwardly,” “upwardly,” etc.) should not be construed to limit embodiments, and instead, again, are offered for convenience of description of orientation. These relative descriptors are for convenience of description only and do not require that any embodiments be constructed or operated in a particular orientation unless explicitly indicated as such. Terms such as “attached,” “affixed,” “connected,” “coupled,” “interconnected,” and similar may refer to a relationship wherein structures are secured or attached to one another either directly or indirectly through intervening structures, as well as both movable or rigid attachments or relationships, unless expressly described otherwise. Furthermore, it is to be understood that such features are not limited to serial execution, but rather, any number of threads, processes, services, servers, and/or the like that may execute asynchronously, concurrently, in parallel, simultaneously, synchronously, and/or the like are contemplated by the disclosure. As such, some of these features may be mutually contradictory, in that they cannot be simultaneously present in a single embodiment. Similarly, some features are applicable to one aspect of the innovations, and inapplicable to others. In addition, the disclosure includes other innovations not presently claimed. Applicant reserves all rights in those presently unclaimed innovations including the right to claim such innovations, file additional applications, continuations, continuations in part, divisions, and/or the like thereof. As such, it should be understood that advantages, embodiments, examples, functional, features, logical, operational, organizational, structural, topological, and/or other aspects of the disclosure are not to be considered limitations on the disclosure as defined by the claims or limitations on equivalents to the claims. It is to be understood that, depending on the particular needs and/or characteristics of a REDUP individual and/or enterprise user, database configuration and/or relational model, data type, data transmission and/or network framework, syntax structure, and/or the like, various embodiments of the REDUP, may be implemented that enable a great deal of flexibility and customization. For example, aspects of the REDUP may be adapted for appliances, avionics, environmental control systems, etc. While various embodiments and discussions of the REDUP have included embedded software, however, it is to be understood that the embodiments described herein may be readily configured and/or customized for a wide variety of other applications and/or implementations.
Number | Date | Country | Kind |
---|---|---|---|
PCT/US15/39457 | Jul 2015 | US | national |
Number | Date | Country | |
---|---|---|---|
62021672 | Jul 2014 | US |
Number | Date | Country | |
---|---|---|---|
Parent | 14793679 | Jul 2015 | US |
Child | 14989717 | US |