SYSTEMS AND METHODS FOR SECURED AND INTEGRATED ANALYTICS DEPLOYMENT ACCELERATOR

Disclosed are methods and systems for securely deploying obfuscated modules in an external system. For instance, a method may include selecting one or more modules from a module repository, the one or more modules associated with completing a task, receiving a custom base image, the custom base image including one or more environment modules configured to provide a specific execution environment for the one or more modules, transforming based on the custom base image, the one or more modules into a container image, the transforming including performing at least one obfuscation action on the one or more modules, and publishing the container image and a container image identifier to the external system, the external system configured to execute a cluster instance corresponding to the task, the cluster instance comprising at least one of: the container image identifier, one or more environmental parameters, and one or more entry point parameters.

TECHNICAL FIELD

Various embodiments of the present disclosure relate generally to securely deploying obfuscated executable modules and, more particularly, to systems and methods for securely deploying obfuscated modules in an external system.

BACKGROUND

Demand has grown for pipelines that may securely host an internal system's executables and resources inside of a private network, run scanning and security tools on the executables, and then deploy the executables as obfuscated executables on an external system. Such pipelines may provide, among other things, secure executables, as well as a more user-friendly external system process.

More generally, under current approaches, external systems may manually initiate, via a user, executables to run in order to complete jobs for the system. Additionally, the contents of the executables may be accessible by the external system. Additionally, the external system may need to perform testing on the executables, which may be inefficient, time consuming, and overwhelming for the external user.

This disclosure is directed to addressing above-referenced challenges. The background description provided herein is for the purpose of generally presenting the context of the disclosure. Unless otherwise indicated herein, the materials described in this section are not prior art to the claims in this application and are not admitted to be prior art, or suggestions of the prior art, by inclusion in this section.

SUMMARY OF THE DISCLOSURE

According to certain aspects of the disclosure, systems and methods are disclosed for securely deploying obfuscated executable modules in an external system.

In one aspect, an exemplary embodiment of a method for securely deploying obfuscated modules in an external system is disclosed. The method may include selecting, by one or more processors, one or more modules from a module repository, the one or more modules associated with completing a task. The method may further include receiving, by the one or more processors, a custom base image, the custom base image including one or more environment modules configured to provide a specific execution environment for the one or more modules. The method may further include transforming, by the one or more processors, based on the custom base image, the one or more modules into a container image, the transforming including performing at least one obfuscation action on the one or more modules. The method may further include publishing, by the one or more processors, the container image and a container image identifier to the external system, the external system configured to execute a cluster instance corresponding to the task, the cluster instance comprising at least one of: the container image identifier, one or more environmental parameters indicative of an environment to execute the container image, and one or more entry point parameters indicative of an initial configuration for executing the container image.

In one aspect, a computer system for securely deploying obfuscated modules in an external system is disclosed. The computer system may include a memory having processor-readable instructions stored therein, and one or more processors configured to access the memory and execute the processor-readable instructions, which when executed by the one or more processors configures the one or more processors to perform a plurality of functions. The functions may include selecting one or more modules from a module repository, the one or more modules associated with completing a task. The functions may further include receiving a custom base image, the custom base image including one or more environment modules configured to provide a specific execution environment for the one or more modules. The functions may further include transforming based on the custom base image, the one or more modules into a container image, the transforming including performing at least one obfuscation action on the one or more modules. The functions may further include publishing the container image and a container image identifier to the external system, the external system configured to execute a cluster instance corresponding to the task, the cluster instance comprising at least one of: the container image identifier, one or more environmental parameters indicative of an environment to execute the container image, and one or more entry point parameters indicative of an initial configuration for executing the container image.

In one aspect, a non-transitory computer-readable medium containing instructions for securely deploying obfuscated modules in an external system is disclosed. The instructions may include selecting one or more modules from a module repository, the one or more modules associated with completing a task. The instructions may further include receiving a custom base image, the custom base image including one or more environment modules configured to provide a specific execution environment for the one or more modules. The instructions may further include transforming based on the custom base image, the one or more modules into a container image, the transforming including performing at least one obfuscation action on the one or more modules. The instructions may further include publishing the container image and a container image identifier to the external system, the external system configured to execute a cluster instance corresponding to the task, the cluster instance comprising at least one of: the container image identifier, one or more environmental parameters indicative of an environment to execute the container image, and one or more entry point parameters indicative of an initial configuration for executing the container image.

DETAILED DESCRIPTION OF EMBODIMENTS

According to certain aspects of the disclosure, methods and systems are disclosed for securely deploying obfuscated executable modules in an external system. Conventional techniques may not be suitable because conventional techniques do not allow for executables to be obfuscated before deployment to external systems. Additionally, conventional techniques may not allow for the customization of the build environment of the executables. Accordingly, improvements in technology relating to securely deploying obfuscated modules in an external system.

Demand has grown for pipelines that may securely host an internal system's executables and resources inside of a private network, run scanning and security tools on the executables, and then deploy the executables as obfuscated executables on an external system. The pipeline may provide the ability to create, build, test, obfuscate, and deploy executable modules in an internal system, and then provide the obfuscated executable module to an external system. Moreover, there is also a demand for the ability to obfuscate the executable modules so that the executable modules may be deployed in any external system, without the need for the external system to include specific tools and/or applications to support the executable module. Such pipelines may provide, among other things, secure executables, as well as a more user-friendly external system process. Additionally, a need has also grown for the executables to be stored in an on-demand manner, where the executables may be deployed whenever a job should be completed. For example, the pipeline may utilize an executable module repository, perform build packages, protect the executable modules, perform testing, and then deploy packages (e.g., container images) into a container registry of an external (or internal) system.

Advantages of such a pipeline may include protecting and encapsulating the executables and entire execution environment into a single deployable unit built on a standard image, a pipeline that may be agnostic regarding the system for deploying the executables, and/or a customizable pipeline that may accommodate new applications or specific application versions to pass industry standard security guidelines and avoid compatibility issues. Additional advantages may include reducing the build time to deploy executable modules into external systems, such as a private cloud, with a high level security process, and/or protecting the details of the executables.

Additional advantages include a pipeline that is highly productive and reusable. Such a reusable pipeline provides for a vulnerable-free docker based obfuscated analytical models into any databricks environment for both internal and external customers. Such a pipeline may securely host code/resources inside a private network, run the scanning and security tools, and then deploy the same on any external service's premise with the code obfuscated. An orchestration service may ensure that the latest executable is deployed on-demand. In addition to the benefits mentioned above, the advantages may also include the ability to add any custom layers, such as executables that run particular tests in the build agents or to build any package.

The systems and methods disclosed herein relate to securely deploying obfuscated (executable) modules in an external system. The systems and methods may include selecting one or more modules from a module repository, the one or more modules associated with completing a task. The systems and methods may further include receiving a custom base image, the custom base image including one or more environment modules configured to provide a specific execution environment for the one or more modules. The systems and methods may further include transforming based on the custom base image, the one or more modules into a container image, the transforming including performing at least one obfuscation action on the one or more modules. The systems and methods may further include publishing the container image and a container image identifier to the external system, the external system configured to execute a cluster instance corresponding to the task, the cluster instance comprising at least one of: the container image identifier, one or more environmental parameters indicative of an environment to execute the container image, and one or more entry point parameters indicative of an initial configuration for executing the container image.

As used herein, the terms “comprises,” “comprising,” “having,” including,” or other variations thereof, are intended to cover a non-exclusive inclusion such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements, but may include other elements not expressly listed or inherent to such a process, method, article, or apparatus. In this disclosure, relative terms, such as, for example, “about,” “substantially,” “generally,” and “approximately” are used to indicate a possible variation of ±10% in a stated value. The term “exemplary” is used in the sense of “example” rather than “ideal.” As used herein, the singular forms “a,” “an,” and “the” include plural reference unless the context dictates otherwise.

While this disclosure describes the systems and methods with reference to securely deploying obfuscated modules in an external system, it should be appreciated that the present systems and methods are applicable to securely deploying obfuscated modules in an internal system or any other system.

Exemplary Environment

FIG.1depicts an exemplary environment100that may be utilized with techniques presented herein. One or more user device(s)105, one or more external system(s)110, and one or more server system(s)115may communicate across a network101. As will be discussed in further detail below, one or more server system(s)115may communicate with one or more of the other components of the environment100across network101. The one or more user device(s)105may be associated with a user, e.g., a user associated with securely deploying obfuscated modules in an external system.

In some embodiments, the components of the environment100are associated with a common entity, e.g., a corporation, an institution, a network, or the like. In some embodiments, one or more of the components of the environment is associated with a different entity than another. The systems and devices of the environment100may communicate in any arrangement. As will be discussed herein, systems and/or devices of the environment100may communicate in order to securely deploy obfuscated modules in an external system, among other activities.

The user device105may be configured to enable the user to access and/or interact with other systems in the environment100. For example, the user device105may be a computer system such as, for example, a desktop computer, a mobile device, a tablet, etc. In some embodiments, the user device105may include one or more electronic application(s), e.g., a program, plugin, browser extension, etc., installed on a memory of the user device105.

The user device105may include a display/user interface (UI)105A, a processor1058, a memory105C, and/or a network interface105D. The user device105may execute, by the processor1058, an operating system (O/S) and at least one electronic application (each stored in memory105C). The electronic application may be a desktop program, a browser program, a web client, or a mobile application program (which may also be a browser program in a mobile O/S), an applicant specific program, system control software, system monitoring software, software development tools, or the like. For example, environment100may extend information on a web client that may be accessed through a web browser. In some embodiments, the electronic application(s) may be associated with one or more of the other components in the environment100. The application may manage the memory105C, such as a database, to transmit streaming data to network101. The display/UI105A may be a touch screen or a display with other input systems (e.g., mouse, keyboard, headset, etc.) so that the user(s) may interact with the application and/or the O/S. The network interface105D may be a TCP/IP network interface for, e.g., Ethernet or wireless communications with the network101. The processor1058, while executing the application, may generate data and/or receive user inputs from the display/UI105A and/or receive/transmit messages to the server system115, and may further perform one or more operations prior to providing an output to the network101.

External systems110may be, for example, one or more third party and/or auxiliary systems that integrate and/or communicate with the server system115in performing various system tasks. For example, external systems110may be a part of a cloud system. External systems110may be in communication with other device(s) or system(s) in the environment100over the one or more networks101. For example, external systems110may communicate with the server system115via API (application programming interface) access over the one or more networks101, and also communicate with the user device(s)105via web browser access over the one or more networks101.

In various embodiments, the network101may be a wide area network (“WAN”), a local area network (“LAN”), a personal area network (“PAN”), or the like. In some embodiments, network101includes the Internet, and information and data provided between various systems occurs online. “Online” may mean connecting to or accessing source data or information from a location remote from other devices or networks coupled to the Internet. Alternatively, “online” may refer to connecting or accessing a network (wired or wireless) via a mobile communications network or device. The Internet is a worldwide system of computer networks—a network of networks in which a party at one computer or other device connected to the network can obtain information from any other computer and communicate with parties of other computers or devices. The most widely used part of the Internet is the World Wide Web (often-abbreviated “WWW” or called “the Web”). A “website page” generally encompasses a location, data store, or the like that is, for example, hosted and/or operated by a computer system so as to be accessible online, and that may include data configured to cause a program such as a web browser to perform operations such as send, receive, or process data, generate a visual display and/or an interactive interface, or the like.

The server system115may include an electronic data system, e.g., a computer-readable memory such as a hard drive, flash drive, disk, etc. In some embodiments, the server system115includes and/or interacts with an application programming interface for exchanging data to other systems, e.g., one or more of the other components of the environment.

The server system115may include a database115A and at least one server1158. The server system115may be a computer, system of computers (e.g., rack server(s)), and/or or a cloud service computer system. The server system may store or have access to database115A (e.g., hosted on a third party server or in memory115E). The server(s) may include a display/UI115C, a processor115D, a memory115E, and/or a network interface115F. The display/UI115C may be a touch screen or a display with other input systems (e.g., mouse, keyboard, headset, etc.) for an operator of the server1158to control the functions of the server1158. The server system115may execute, by the processor115D, an operating system (O/S) and at least one instance of a servlet program (each stored in memory115E).

Although depicted as separate components inFIG.1, it should be understood that a component or portion of a component in the environment100may, in some embodiments, be integrated with or incorporated into one or more other components. For example, a portion of the display115C may be integrated into the user device105or the like. In some embodiments, operations or aspects of one or more of the components discussed above may be distributed amongst one or more other components. Any suitable arrangement and/or integration of the various systems and devices of the environment100may be used.

Further aspects of securely deploying obfuscated modules in an external system are discussed in further detail in the methods below. In the following methods, various acts may be described as performed or executed by a component fromFIG.1, such as the server system115, the user device105, or components thereof. However, it should be understood that in various embodiments, various components of the environment100discussed below may execute instructions or perform acts including the acts discussed below. An act performed by a device may be considered to be performed by a processor, actuator, or the like associated with that device. Further, it should be understood that in various embodiments, various steps may be added, omitted, and/or rearranged in any suitable manner.

A computer system, such as a system or device implementing a process or operation in the examples above, may include one or more computing devices, such as one or more of the systems or devices inFIG.1. One or more processors of a computer system may be included in a single computing device or distributed among a plurality of computing devices. A memory of the computer system may include the respective memory of each computing device of the plurality of computing devices.

Exemplary System Flow for Creating and Utilizing a Container Image

FIG.2illustrates an exemplary process200for creating and utilizing a container image, according to one or more embodiments. Notably, process200may be performed by one or more processors of a server that is in communication with one or more user devices and other external system(s) via a network. However, it should be noted that process200may be performed by any one or more of the server, one or more user devices, or other external systems.

The exemplary process may include sending one or more modules from a module repository202to a deployment agent204. The one or more modules may include at least one of: a command file (e.g., a DockerFile), one or more notebooks (e.g., Databricks Notebooks), third party libraries, resources (e.g., configuration files), and/or executables. The deployment agent204may include one or more transforming modules, such as a publish container image to container registry module, a build container image module, an executable obfuscation module, a packing module, and/or a user acceptance testing (UAT) module.

The exemplary process may also include sending a custom base image for a deployment build206to the deployment agent204. The custom base image206may be associated with the one or more modules that were sent to the deployment agent204. The custom base image206may include one or more custom environment modules. For example, the one or more environment modules may include one or more user level variables (e.g., variables configured at user level), one or more custom testing variables (e.g., configure spark), one or more custom environment modules (e.g., Python 3.X environment), or one or more custom security modules (e.g., SonarQube, Coverity, or BlackDuck). The custom base image206may include a set of default environment modules that may be overridden and/or modified by the one or more custom environment modules.

The exemplary process may also include the deployment agent2040transforming the one or more modules, based on the custom base image206, into a container image. For example, the deployment agent204may perform a build, where the one or more modules are transformed based on the environment specified by the custom base image206into a container image. The deployment agent204may utilize the one or more transforming modules during the transforming process.

The exemplary process may also include publishing the container image into a container registry208of an external system. The container registry208may store the container image. The container registry208may also store a job and/or task identifier that corresponds to the container image, where the container image may accomplish the job and/or task when executed. The container registry208may also store the container image with a corresponding label and/or tag that indicates whether the container image is the latest version. Additionally, the external system may not be able to access the module repository202, the deployment agent204, and/or the custom base image206for the deployment build.

The exemplary process may also include a Directed Acyclic Graphs (DAG)210utilizing the container image from the container registry208. The DAG210may include one or more tasks that should be executed by the external (or internal) system. The task manager service may run the DAG210to initiate one or more jobs and/or tasks. Running the DAG210may trigger the DAG210to configure one or more cluster parameters. The DAG210may also configure one or more entry point (e.g., notebook) parameters. The DAG210may then run the job and/or task, by running one or more container images. Upon completing the job and/or task, the DAG210may destroy the particular cluster instance, which may include the configured one or more cluster parameters, and/or the one or more notebook parameters. Upon completion of the job, the exemplary process may also include utilizing an analytics service214, which may include the latest deployment agent and/or databricks container services.

The exemplary process may also include utilizing registry credentials, a key vault212, and/or a personal access token to provide additional security in the external system.

AlthoughFIG.2shows example blocks of exemplary process200, in some implementations, the exemplary process200may include additional blocks, fewer blocks, different blocks, or differently arranged blocks than those depicted inFIG.2. Additionally, or alternatively, two or more of the blocks of the exemplary process200may be performed in parallel.

Exemplary Process for Executing a Pipeline

FIG.3illustrates an exemplary process300for executing a pipeline, according to one or more embodiments. Notably, process300may be performed by one or more processors of a server that is in communication with one or more user devices and other external system(s) via a network. However, it should be noted that process300may be performed by any one or more of the server, one or more user devices, or other external systems.

The exemplary process may include a user selecting and loading a proposed pipeline302. However, a system may automatically select and load the proposed pipeline. The pipeline may include one or more modules, where the modules may contain one or more executables. The proposed template may then perform open source (OSS), quality, and security scans on the loaded pipeline304. The proposed template may then perform wheel packaging on the loaded pipeline306. The proposed template may then perform module obfuscation on the loaded pipeline308. The proposed template may then repackage the pipeline into build artifacts310. The proposed template may then build a container image using a database (DB) standard image and may also copy required artifacts312. The proposed template may then publish the container image to a container registry314.

The exemplary process may include a user (or the system) loading Directed Acyclic Graphs (DAG) into the task manager316. For example, the DAG may include one or more tasks that should be executed by an external (or internal) system, such as a cloud system. The proposed template may then notify the task manager of the loaded DAGs318. The task manager may run the DAG, which may result in loading one or more clusters and one or more entry point (e.g., notebook) configurations320. The task manager may check the container registry for the latest version of the container image322. The container registry may then send a latest tag, which may correspond to the latest version of the container image, to the task manager324. The task manager may then trigger one or more jobs, where each of the jobs may include one or more tasks326.

The exemplary process may also include the build environment creating a cluster using container services and then running the job328. The container registry may then check the job status to see if the job has been completed, or if there are any outstanding tasks to run330. Once all of the tasks has been completed, the build environment may then destroy the cluster332. The build environment may then notify the task manager of the completion of the job334.

AlthoughFIG.3shows example blocks of exemplary process300, in some implementations, the exemplary process300may include additional blocks, fewer blocks, different blocks, or differently arranged blocks than those depicted inFIG.3. Additionally, or alternatively, two or more of the blocks of the exemplary process300may be performed in parallel.

Exemplary Method for Securely Deploying Obfuscated Modules

FIG.4illustrates an exemplary method400for securely deploying obfuscated executable modules in an external system, according to one or more embodiments. Notably, method400may be performed by one or more processors of a server that is in communication with one or more user devices and other external system(s) via a network. However, it should be noted that method400may be performed by any one or more of the server, one or more user devices, or other external systems.

The method may include selecting, by one or more processors, one or more modules from a module repository, the one or more modules associated with completing a task (Step402). The one or more modules may be selected from a module repository in order to complete a task. In some embodiments, the selecting may be automated, where each task is mapped to the one or more modules that will complete the task. In some embodiments, the selecting may be manual, where a user may manually select the one or more modules to complete the task. The module repository may store some or all of the one or more modules. In some embodiments, the module repository may communicate with one or more other repositories that store some or all of the one or more modules.

The one or more modules may include one or more resource modules, one or more third party library modules, one or more command modules, one or more interface modules, or one or more execution modules. The one or more resource modules may include parameters, options, settings, and/or preferences applied to the system environment. The one or more third party library modules may include components created by a third party. The one or more command modules may include commands used to complete the task. For example, the one or more command modules may include instructions regarding how to complete the task. The one or more interface modules may include one or more interfaces that contain executables, visualizations, and/or narrative text. The one or more execution modules may include executables that interact with different components of the computing system to complete the task.

The method may further include receiving, by the one or more processors, a custom base image, the custom base image including one or more environment modules configured to provide a specific execution environment for the one or more modules (Step404). The custom base image may configure one or more default environment modules to address any potential compatibility issues. The custom base image may correspond to an environment that includes customized modules, such as the one or more environment modules, to execute the one or more modules. In some embodiments, the custom base image may correspond to the task, where the custom base image may be received in response to sending a notification identifying the task. In some embodiments, the custom base image may be associated with at least one of the one or more modules, where the custom base image may be automatically received in response to the selection of the modules. The one or more environment modules may include one or more user level variables, one or more custom testing variables, one or more custom environment modules, or one or more custom security modules.

The method may further include transforming, by the one or more processors, based on the custom base image, the one or more modules into a container image, the transforming including performing at least one obfuscation action on the one or more modules (Step406). The transforming may include a build process that converts the one or more modules into a container image that includes executable modules. Additionally, the one or more modules may be transformed based on the custom base image, where the one or more environment modules may be utilized during the transforming. For example, the system may have default one or more environment modules that are a part of the execution environment. The custom base image may allow for the customization of the execution environment, where the one or more environment modules may override (or modify) the default one or more environment modules. Additionally, for example, the transforming may include executing at least one user acceptance test on the one or more modules, where the testing may occur before the container image is accessible by the external system. In some embodiments, the transforming may result in the creation of a container image identifier that may be associated with the container image. Additionally, the container image identifier may be a unique identifier that may be used to invoke the container image. In some embodiments, the at least one obfuscation action may utilize at least one unique key.

In some embodiments, performing the at least one obfuscation action may further include determining, by the one or more processors, at least one environment module requirement of the one or more modules, and analyzing, by the one or more processors, the one or more environment modules to determine that at least one of the one or more environment modules include the at least one environment module requirement. The at least one environment module requirement may indicate environment module values that may need to be included in the execution environment to support the one or more modules. Additionally, the at least one environment module requirement may correspond to a particular version, parameter values, artifacts, and the like of the one or more modules.

In some embodiments, the transforming may include associating, by the one or more processors, the container image with a task identifier, wherein the task identifier is associated with the task. For example, each task may have one or more associated task identifiers. The container image may be associated with the task identifier, where the container image may be invoked (e.g., via a container repository) by using a task identifier.

In some embodiments, the transforming may include utilizing, by the one or more processors, one or more encrypted variables. For example, the encrypted variables may be utilized before the container image is accessible by an external system. Additionally, for example, an external system may be unable to access the one or more encrypted variables.

The method may further include publishing, by the one or more processors, the container image and a container image identifier to the external system, the external system configured to execute a cluster instance corresponding to the task, the cluster instance comprising at least one of: the container image identifier, one or more environmental parameters indicative of an environment to execute the container image, and one or more entry point parameters indicative of an initial configuration for executing the container image (Step408). The one or more entry point parameters may include, for example, a user name and a password. In some embodiments, the cluster instance may be mapped to the one or more entry point parameters. Additionally, for example, executing the cluster instance may include retrieving and executing the container image corresponding to the container image identifier from the container registry. In some embodiments, the external system may be further configured to destroy the cluster instance so that the cluster instance is removed from the external system.

The publishing the container image and a container image identifier may include storing the container image and/or the container image identifier in the container registry. In some embodiments, the method may include sending a request to the container registry with the container image identifier. In response to receiving the request, the container registry may make the container image available. For example, a component of the external system may send a request to the container registry, where the request may include the container image identifier. The container registry may then select the container image that corresponds to the container image identifier, and then send the container image to the requesting component of the external system.

The external system may correspond to one or more systems that are external to the system that performed the transforming of the one or more modules into a container image. In some embodiments, the external system may be the same system that performed the transforming. In other embodiments, the external system may be internal to the system that performed the transforming.

The external system may be configured to execute a cluster instance corresponding to the task. The cluster instance may be a particular instance of a cluster. For example, a cluster instance may include one or more custom parameters, where each cluster instance may correspond to the same cluster, but may include different custom parameters. The external system may want to complete one or more tasks. Additionally, each task may have a corresponding cluster instance, which, when executed, completes the corresponding task. For example, the cluster instance may include the container image identifier, one or more environmental parameters, and one or more entry point parameters. In some embodiments, there may be multiple cluster instances that may complete a job (e.g., multiple tasks). The cluster instance may include the container image and parameters for the environment to execute the container image to complete the particular task. In some embodiments, the one or more environmental parameters may override default environmental parameters of the existing system. For example, an environmental parameter may correspond to a different version of an application that already exists as a default environmental parameter.

The external system may also be configured to destroy the cluster instance so that the cluster instance is removed from the external system. For example, after the cluster instance has been executed, and the task has been completed, the external system may destroy the cluster instance. Additionally, destroying the cluster instance may result in the removal of the cluster instance, but not the removal of the cluster. Destroying the cluster instance may increase the external system's efficiency because the external system may act in a dynamic manner, where the external system executes the cluster instances for the tasks that may be executed at a particular time. As a result, the external system may avoid supporting the load of a cluster instance that is no longer needed.

AlthoughFIG.4shows example blocks of exemplary method400, in some implementations, the exemplary method400may include additional blocks, fewer blocks, different blocks, or differently arranged blocks than those depicted inFIG.4. Additionally, or alternatively, two or more of the blocks of the exemplary method400may be performed in parallel.

Exemplary Device

FIG.5is a simplified functional block diagram of a computer500that may be configured as a device for executing the methods ofFIGS.2-4, according to exemplary embodiments of the present disclosure. For example, device500may include a central processing unit (CPU)520. CPU520may be any type of processor device including, for example, any type of special purpose or a general-purpose microprocessor device. As will be appreciated by persons skilled in the relevant art, CPU520also may be a single processor in a multi-core/multiprocessor system, such system operating alone, or in a cluster of computing devices operating in a cluster or server farm. CPU520may be connected to a data communication infrastructure510, for example, a bus, message queue, network, or multi-core message-passing scheme.

Device500also may include a main memory540, for example, random access memory (RAM), and also may include a secondary memory530. Secondary memory530, e.g., a read-only memory (ROM), may be, for example, a hard disk drive or a removable storage drive. Such a removable storage drive may comprise, for example, a floppy disk drive, a magnetic tape drive, an optical disk drive, a flash memory, or the like. The removable storage drive in this example reads from and/or writes to a removable storage unit in a well-known manner. The removable storage unit may comprise a floppy disk, magnetic tape, optical disk, etc., which is read by and written to by the removable storage drive. As will be appreciated by persons skilled in the relevant art, such a removable storage unit generally includes a computer usable storage medium having stored therein computer software and/or data.

In alternative implementations, secondary memory530may include other similar means for allowing computer programs or other instructions to be loaded into device500. Examples of such means may include a program cartridge and cartridge interface (such as that found in video game devices), a removable memory chip (such as an EPROM, or PROM) and associated socket, and other removable storage units and interfaces, which allow software and data to be transferred from a removable storage unit to device500.

Device500also may include a communications interface (“COM”)560. Communications interface560allows software and data to be transferred between device500and external devices. Communications interface560may include a modem, a network interface (such as an Ethernet card), a communications port, a PCMCIA slot and card, or the like. Software and data transferred via communications interface560may be in the form of signals, which may be electronic, electromagnetic, optical, or other signals capable of being received by communications interface560. These signals may be provided to communications interface560via a communications path of device500, which may be implemented using, for example, wire or cable, fiber optics, a phone line, a cellular phone link, an RF link or other communications channels.

The hardware elements, operating systems and programming languages of such equipment are conventional in nature, and it is presumed that those skilled in the art are adequately familiar therewith. Device500also may include input and output ports550to connect with input and output devices such as keyboards, mice, touchscreens, monitors, displays, etc. Of course, the various server functions may be implemented in a distributed fashion on a number of similar platforms, to distribute the processing load. Alternatively, the servers may be implemented by appropriate programming of one computer hardware platform.

Reference to any particular activity is provided in this disclosure only for convenience and not intended to limit the disclosure. A person of ordinary skill in the art would recognize that the concepts underlying the disclosed devices and methods may be utilized in any suitable activity. The disclosure may be understood with reference to the following description and the appended drawings, wherein like elements are referred to with the same reference numerals.