Method and apparatus for generating and packaging integration workflow activities

A tool that outputs workflows for target computing devices receives user input selecting one or more Application Programming Interfaces (APIs), a plurality of workflow activities, each of which define actions that are to be performed by the target computing device, and an application framework. Based on these selections, the tool compiles the workflow activities for execution on the target computing device based on the first application framework selected by the user, and generates a workflow activity package to comprise the compiled plurality of workflow activities. If the selected application framework is not compatible with the execution environment at the target device, the tool allows the user to select a different application framework to replace the initially selected application framework, and to re-compile the workflow activities based on the newly selected application framework.

BACKGROUND

The present disclosure relates to Information Technology (IT) computing tools, and more particularly, to computing devices and methods for generating workflow automation packages.

Workflow automation is an orchestrated, repeatable pattern of computer-executable actions facilitated by organizing the needed functions and resources into a process or “workflow.” Generally, workflows are embodied as a series of tasks or operations that are executed on the target device, and control the target computing device perform a variety of functions including, but not limited to, transforming data, providing services, and processing information. Workflows are typically constructed from a plurality of building blocks, each building block comprising code and/or data that the target device executes to perform the functions of the workflow. For example, consider a software installation process that, when executed by the target device, installs or updates the software already executing on the target device. The building blocks for such workflows may comprise, for example, code and/or data that allows the target device to perform Create, Read, Update, and Delete (CRUD) operations, and/or other operations.

Conventionally, there is a fairly high degree of knowledge and specific skill required for creating workflows. Particularly, computer programmers who create workflows should be well-versed in the various technologies related to the target device, such as the many different Application Programming Interfaces (APIs) and application frameworks in which such workflows are expected to operate.

BRIEF SUMMARY

The present disclosure provides a computer-implemented method, apparatus, and corresponding computer readable storage medium for generating workflow activity packages that are executed on target computing devices. In one embodiment, a computer-implemented method for generating such a package comprises selecting, responsive to receiving user input at a Graphical User Interface (GUI), an Application Programming Interface (API), a first application framework from among a plurality of application frameworks displayed to the user, and a plurality of workflow activities that are compliant with the API. Each workflow activity comprises code defining one or more actions to be performed by a target computing device in concert with the selected API, and the first application framework comprises a reusable set of software components on top of which the workflow activities will execute on the target computing device.

The method further comprises compiling the workflow activities for execution on the target computing device based on the first application framework selected by the user. Once compiled, the method calls for generating the workflow activity package to comprise the compiled plurality of workflow activities.

In another embodiment, the present disclosure also provides a computing device comprising a display and a processing circuit. The display is configured to display a graphical user interface (GUI) for a tool to a user. The tool is configured to generate a workflow activity package for execution on a target computing device based on user input received by the GUI. The processing circuit is, responsive to receiving the user input at GUI, configured to select an Application Programming Interface (API), select a first application framework for building the plurality of workflow activities into the workflow activity package, and select a plurality of workflow activities that are compliant with the API.

The first application framework comprises a reusable set of software components and is selected by the user from among a plurality of application frameworks displayed by the GUI. Further, each workflow activity comprises code that defines one or more actions to be performed by the target computing device, and is compliant with the selected API. The tool compiles the workflow activities for execution on the target computing device based on the first application framework selected by the user, and generates the workflow activity package to comprise the compiled plurality of workflow activities.

Additionally, the present disclosure also provides, in one embodiment, a computer-readable storage medium comprising computer-readable code. The code, when executed by a processing circuit on a computing device, configures the processing circuit to display a graphical user interface (GUI) for a tool to a user, wherein the tool is configured to generate a workflow activity package for execution on a target computing device, and select, responsive to receiving user input at the GUI, an Application Programming Interface (API), a first application framework for building the plurality of workflow activities into a workflow activity package, and a plurality of workflow activities that are compliant with the API.

Each workflow activity comprises source code defining one or more actions to be performed by a target computing device. The first application framework comprises a reusable set of software components and is selected by the user from a plurality of application frameworks displayed by the GUI. The code further controls a processing circuit on a computing device to compile the workflow activities for execution on the target computing device based on the first application framework selected by the user, and generate the workflow activity package to comprise the compiled plurality of workflow activities.

Of course, those skilled in the art will appreciate that the present embodiments are not limited to the above contexts or examples, and will recognize additional features and advantages upon reading the following detailed description and upon viewing the accompanying drawings.

DETAILED DESCRIPTION

Accordingly, the present disclosure provides a device, a computer-readable storage medium, and corresponding computer-implemented method for compiling a workflow activity package for execution on a target computing device. The workflow activity package comprises a workflow made up of a plurality of various building blocks or “workflow activities.” Each workflow activity in the workflow comprises code and/or data defining one or more actions that are to be executed on the target computing device. In operation, a user is presented with a Graphical User Interface (GUI) by a Rapid Development Kit (RDK) tool executing as a standard web application on a computing device. The GUI displays elements, such as the workflow activities, from which the user can select to include in the workflow and build into the workflow activity package.

In more detail, the GUI displays a plurality of Application Programming Interfaces (APIs) and a plurality of application frameworks in addition to the plurality of workflow activities. Each API is different and defines functions that the workflow activities may invoke when they are executed on the target device. The application frameworks define the various different framework components on top of which the workflow activities are expected to operate. Based on information regarding the functions to be performed by the workflow, the execution environment at the target computing device, and the like, the user selects one or more desired APIs and a desired application framework. The user also selects, via the GUI, a plurality of workflow activities, each of which is compliant with at least one of the selected APIs. Once the workflow activities, APIs, and the framework are selected, the RDK tool generates corresponding source code, compiles the source code, and places the compiled source code defining the workflow activities into a workflow activity package. The package is then deployed to, or installed on, the target computing device for execution on the target computing device.

The tool of the present disclosure enables ‘sysadmin’ type personnel, who are typically subject matter experts for a particular technology and very often have either scripting or Web services skills (or both), to rapidly create new workflow activities without requiring a specific coding skill set or deep knowledge of the underlying framework on which the tool operates. Additionally, the tool allows users-at-large to create new or modified custom workflow activities for use with the tool. Some users may create such customized workflow activities for use in their own workflows without having to endure a lengthy and complicated training and code review process. Other users, such as those that are part of a development community, for example, may create or modify workflow activities, and then contribute those custom work activities to a library for use and/or sale to other users. In addition, the tool of the present disclosure accelerates the creation and delivery of workflow activities for use on a target device. Particularly, the tool of the present disclosure performs the more complicated and mundane tasks associated with generating workflow activities that are used in the creation of workflow processes that users typically perform on conventional systems, while helping to ensure quality of the workflow activities. This leaves users free to concentrate on specific aspects of extending the functionality of the code that comprises the workflow activities.

Turning now to the drawings,FIG. 1is a block diagram illustrating some components of a communications network10configured according to one embodiment of the present disclosure. In this embodiment, network10comprises a packet-based data network12, such as the Internet and/or one or more private or public packet-based networks, for example, communicatively connecting an application server14and a target computing device16with a local client computing device20. Each of the application server14and the target computing device16may further connect to external memory devices, such as one or more databases (DBs), for example, that store data and programs used by those devices.

In one embodiment, the RDK tool (i.e., a software application program) executes on the application server14, or locally on client computing device20. As previously described, the RDK tool is a development tool that provides the GUI to client computing device20. The GUI displays the available APIs, the available application frameworks, and the available workflow activities to the user. As previously described, the user selects one or more desired APIs, frameworks, and workflow activities from those displayed by the GUI to build the workflow activity package for execution on the target device16. Once built, the workflow activity package is delivered to the target device16and executed thereon to perform the workflow functions and activities that comprise the package.

FIG. 2is a block diagram illustrating a possible architecture of a Rapid Development Kit (RDK) tool40configured according to one embodiment of the present disclosure. The RDK tool40provides the GUI that allows the user to select the APIs, the frameworks, and the workflow activities as previously described, as well as the logic and instructions that generate the workflow activity package based on the user selections. This embodiment of the RDK tool40comprises a three-tiered architecture; however, this is for illustrative purposes only. As those of ordinary skill in the art will appreciate, other architectures for such tools40are also possible.

The RDK tool40ofFIG. 2is, as stated above, may be designed as a standard web application having multiple tiers. In this embodiment, RDK tool40comprises a client tier50, a server tier60, and a persistence tier (or local file system)80. The client tier50is hosted locally in the user's browser environment, which provides native support for code written in languages such as HTML5, JAVASCRIPT, and CSS. In one embodiment, client tier50is constructed as a single page Angular application and is configured to access server tier60via a RESTful interface, for example. In this embodiment, client tier50has no direct access to persistence tier80, but may access the persistence tier80indirectly by invoking one or more functions in the server tier60.

The GUI described above is contained within the client tier50, and comprises a plurality of functions that allow the user to interact with the RDK tool40. By way of example only, client tier50comprises a framework, such as AngularJS, that facilitates client-side construction of the workflow activities, modularization, service management, and data binding. In addition, client tier50may comprise support for certain other components including, but not limited to, BOOTSTRAP and UI BOOTSTRAP, which provides a set of AngularJS directives that implement some common, “out-of-the-box” BOOTSTRAP compatible components, and Less CSS, which assists users in building HTML stylesheets.

The server tier60communicates with both the client tier50and the persistence tier80using any means known in the art, and provides the standard web application services to the client tier50to serve static content. While the static content may comprise any content needed or desired, such content may include, but is not limited to, images, html files, and scripts. In addition to these functions, the server tier60is configured to provide a RESTful API to support the RDK tool40business logic.

In one embodiment, the server tier60also comprises an ORACLE JAVA runtime environment under which the RDK tool40executes. An APACHE TOMCAT server module provides the static content and a JEE Servlet container to implement the RDK tool40business logic, while a Java Development Kit may be employed to provide a Java compiler used to compile the workflow activity packages into Java class files. APACHE CXF/JAX-RS provides support for using annotations for Rest XML, Rest JSON, and SOAP, and in at least one embodiment, utilizes a WOODSTOX STAX parser. An APACHE VELOCITY component facilitates the user's ability to generate the workflow activities using templates, and ensures a separation between the logic of a code generator that generates the code for the workflow activities, and the generated code. Further, the server tier60may also comprise an APACHE ANT module used for running a back end automated build on the workflow activity package.

This persistence tier80comprises the native file system of the operating system (OS) of the target computing device16. In addition to other functions, the persistence tier80is configured to provide storage resources for all of the workflow activity packages, as well as any associated metadata.

FIG. 3is a block diagram illustrating a business proxy pattern90according to one embodiment of the present disclosure. As seen inFIG. 3, the client tier50consumes restful services provided by the server tier60by accessing those services via a stateless JAVASCRIPT business proxy. More particularly, the business proxy pattern90in this embodiment exposes a stateless, asynchronous promise-based interface92that hides the details of transport and protocol of messages and data communicated between the client tier50and the server tier60. This stateless asynchronous interface92comprises public methods. Further, the semantics of these public methods match the business logic of the service API and are agnostic of other technical details.

The business proxy pattern90in this embodiment also comprises a stateful and event oriented interface94that communicates with the stateless asynchronous interface92. The functions that comprise the stateful and event-oriented interface94are provided by the client tier50and comprise the Client UI code96and a Stateful Service Model98. The functions that comprise the stateless asynchronous interface92comprise a Stateless Service Proxy100and a Logical Service Instance102, which in this embodiment, are distributed across both the client tier50and the server tier60.

The Client UI code96comprises presentation logic for the GUI. In one embodiment, the Client UI code96comprises components including Bootstrap based Angular Directive components, Service components, Markup and Controller components, Filter components, and the like. These components are configured to convert the business logic of the server tier60into a rich user experience via the GUI.

The Stateful Service Model98is configured to encapsulate the logic of the Stateless Service Proxy100. Not all services will require stateful processing, however. Some other functions provided by this component include, but are not limited to, caching and singleton behaviors such as session and authentication management.

The Stateless Service Proxy100comprises a javascript proxy that executes within the user's browser environment. In this embodiment, these functions are stateless, like the Logical Service Instance102instances they proxy, but will recast the synchronous restful business interfaces into their asynchronous, object oriented, promise-based equivalents. The services provided by the Stateless Service Proxy100are registered Angular services, and therefore, Angular may be utilized to manage these services throughout their lifecycles. As stateless services, each consumer may have its own instance.

The Logical Service Instance102comprises code and logic configured to provide the business logic required to use the service. They will expose this logic in a RESTful interface. If there are other consumers of the RDK tool40, it will be these interfaces that are consumed. The Logical Service Instance102, which may be written in Java, for example, may be hosted by the Tomcat Servlet Container and adhere to the JAX-RS standard. This allows the Logical Service Instance102to leverage the Apache CXF framework to simplify and standardize the writing of RESTful interfaces.

FIG. 4is a block diagram illustrating a build pipeline110for generating and compiling a workflow activity package according to one embodiment of the present disclosure. As seen inFIG. 4, the pipeline of this embodiment comprises four different, sequential stages. A User Interaction (UI) stage112, a Persistence stage114, a Code Generation stage116, and a Build stage118.

The UI stage12comprises the logic and data that facilitates the interaction between the user, the client tier50, and the server tier60. Particularly, in the UI stage112, the user interacts with the RDK tool40via a RDK client module (i.e., the GUI) (box52) to create, edit (e.g., update), and manage the workflow activities and the workflow activity packages. By way of example, the RDK client module is configured to communicate with a workflow activity services module (box62) in the server tier60to select, responsive to user input, various APIs, provide input parameters, define an execution payload, define one or more output parameters along with optional filters, define error conditions, and the like. Once defined, users are able to test, via the RDK client, execution payloads in the context of the input parameters, and inspect the output of any defined API calls. If the user has defined any filters, the RDK client may filter the outputs, and assign the filtered output values to the defined output parameters. Advantageously, testing the execution payload also helps to validate any optional error conditions that are defined by the user. The user may also store the workflow activities in a memory along with the selected and defined parameters using the RDK client module.

In the Persistence stage114, the application server14stores the updated workflow activities and/or metadata associated with those activities to storage, such as in a DB. More particularly, a data service module (box64) receives the data, such as the metadata, workflow activities, and workflow activity packages defined by the user using the RDK client, from the workflow activity service module (box62). As described in more detail below, the data service module (box64) sends the data to a code generator module (box66), but may also send that data to a workflow activity metadata module (box82) in the persistence tier80. Sending the data to the workflow activity metadata module (box82) enables users to easily port workflow activities, as well as entire workflow activity packages, to other workflow activities and packages.

In one embodiment, for example, a user can enter a command at the RDK client to copy the contents of a working folder comprising the workflow activities and associated metadata for use in another workflow. In response, a workflow activity metadata module (box82) receives the data, and then communicates the data to a source code module (box84), and/or to a workflow activity package module (box88). Upon receipt, these modules can insert or otherwise utilize the data for other workflow activities and/or workflow activity packages.

The Code Generation stage116comprises the functions that are performed by a code generator module (box66), a template module (box68), and a documentation generator (box70) in server tier60, as well as the previously mentioned source code module (box84) and a documentation module (box86) in the persistence tier80.

In the Code Generation stage116, code generator module (box66) at the server tier60receives metadata from the data service module (box64), and merges that metadata with workflow activity code templates at a workflow activity template module (box68). The merged data is then provided to the source code module (box84) to produce the source code for the workflow activity packages. Additionally, a document generator module (box70) may be included to generate appropriate documentation for the workflow activity and/or packages from the data received at the code generator module (box66). In such embodiments, the document generator module (box70) may provide its data to a documentation module (box86) in the persistence tier80to be merged with, or included in, the workflow activity and/or the workflow activity package that is output by the source code module (box84). Such documentation may identify or describe, for example, the various parameters and functions of a given workflow activity or workflow activity package so that other users can utilize that code.

In at least one embodiment, templates can be replaced and/or updated to perform code generation that is compatible with other selected IT orchestration/automation frameworks. Thus, embodiments of the present disclosure are not limited to only a single pre-defined framework, but rather, can support multiple different frameworks associated with other IT tools. Optionally, the generated source code can be modified and/or customized using any applicable Integrated Development Environment (IDE).

In the final stage, or Build stage, the server tier60builds the workflow activity package from the identified workflow activities. More particularly, a builder module (box72) at the server tier60receives data from the document generator module (box70) and the template module (box68), and assembles that data to generate the workflow activity package (box88) in a format that can be deployed to the target IT orchestration/automation toolset. In at least one embodiment, the format for the resultant workflow activity package is determined by the framework associated with the selected IT orchestration/automation toolset. However, in other embodiments, the format is determined by a Software Development Kit (SDK) selected by the user.

FIGS. 5A-5Dare flow diagrams illustrating methods for generating workflow files according to one embodiment of the present disclosure. Particularly,FIG. 5Ais a flow diagram illustrating a method120for generating a workflow activity package for delivery to a target computing device16according to one embodiment of the present disclosure. Method120begins with displaying the GUI for RDK tool40on the client computing device20for the user (box122). As previously stated, the RDK tool40may be executing locally on client computing device20, remotely on application server14, or both, and provides the GUI that displays a plurality of available APIs, as well as a plurality of available frameworks, for selection by the user. Other information may or may not be displayed by the GUI as needed or desired.

In operation, the user would select one or more APIs (box124) as well as an application framework (box126). As previously stated, the GUI displays a plurality of different application frameworks, each comprising a reusable set of software components that may be used to build the workflow activity package for delivery to the target device16, and to execute the workflow activities on the target device16. The user also selects, via the GUI, a plurality of workflow activities (box128). The workflow activities are compatible with at least one of the selected APIs. In one embodiment, however, different workflow activities selected by the user are compatible with different APIs. Therefore, in one embodiment, the GUI provided by RDK tool40allows the users to select different workflow activities to include in the workflow activity package, and to associate different workflow activities in the workflow activity package with different APIs.

The user may then enter a command, for example, that controls the RDK tool40to parse the data associated with the selected activities (box130). Such parsing exposes the parameters of the selected workflow activity, and as described in more detail later, allows the users creating the workflow activity package to identify parameters and values output by one workflow activity to another, different workflow activity for use by that different workflow activity (box132).

Once the user is finished, the user may issue a command to cause the RDK tool40to compile the workflow activities for execution on the target computing device based on the first application framework selected by the user (box134). Particularly, the RDK tool40compiles the source code associated with the selected workflow activities. The RDK tool40then generates the workflow activity package to comprise the compiled workflow activities (box136), and delivers the compiled workflow activity package to the target device16for execution (box138).

In some embodiments of the present disclosure, the workflow activities in the workflow share parameter values. For example, a first workflow activity in the workflow may have an output value that can be utilized by another workflow activity later in the workflow. To facilitate such sharing, the user creating the workflow uses the GUI of the RDK tool40to identify and bind the parameters across different workflow activities in the workflow.

FIG. 5Bis a flow diagram illustrating a method140for binding the values of one workflow activity to a global parameter so that one or more other workflow activities in the workflow are able to access those values. As seen inFIG. 5B, the user must first identify a particular output value of a first workflow activity that is to be shared with other workflow activities. To accomplish this, the RDK tool40provides a “test execution environment” in which the functions of the first workflow activity are executed (box142). Executing the workflow activity in this test environment allows the user to view the values that are output by the first workflow activity. Once the user has identified a given output value (box144), the user binds that output value to an output parameter (box146).

By way of example, the RDK tool40may display the value or values output by the first workflow activity, along with their respective variable names, to a specially indicated area of the GUI. This allows the user to then manually enter the name of a desired variable into another specially marked area of the GUI associated with a given parameter that is accessible to other workflow activities in the workflow. Thereafter, upon execution of the workflow on the target device16, underlying code in the workflow sets the given parameter to the output value of the first workflow activity. This binds the output of the first workflow activity to the global parameter that is available to other workflow activities, thereby providing access to that value by other workflow activities in the workflow.

Generally, conventional workflow development tools only operate with a specific, well-defined application framework, such as Product Asset Management (PAM), Reference Architecture (RA), and other workflow orchestration products, for example, associated with a target device. However, this limits conventional tools to generating workflows only for that specific framework. Further, all workflow activities in the workflow can only be written for that particular framework. Thus, if the functionality of a particular workflow activity is desired for a different framework, the user would have to utilize a completely different tool associated with the different framework, and recreate the workflow activity. This also requires the user to have specific knowledge of the particular framework on which the workflow activities will operate. Embodiments of the present disclosure, such as method150seen inFIG. 5C, for example, avoid such problems by allowing a user to dynamically switch between a plurality of different application frameworks.

In more detail, the RDK tool40in this embodiment is preconfigured to operate with a plurality of different application frameworks, such as those frameworks mentioned above. Further, method150assumes that a workflow activity package has been created by the user using a one of those application frameworks. If the user decides to create the workflow activity package for another target device having a different framework, the user utilizes the GUI of RDK tool40and simply selects a different application framework (box152). The various frameworks available to the user may be listed, for example, in a drop-down box on the GUI. Selecting the new application framework from the GUI effectively causes the RDK tool40to replace the currently selected application framework with the newly selected application framework (box154). The user may then use the RDK tool40to compile the workflow activity package based on the newly selected framework (box156), and deliver the compiled package to the target device16(box158).

In addition, the RDK tool40of the present disclosure also allows a user to create new workflow activities from existing workflow activities, and modify existing workflow activities. Such functions allow users to create a variety of different workflow activities, as well as their corresponding workflows, very quickly.

FIG. 5Dis a flow diagram that illustrates a method160for modifying the workflow activities in a given workflow. Method160begins with the user selecting, using the GUI of RDK tool40, a desired workflow activity (box162). By way of example, the selected workflow activity may comprise program code that configures a processor circuit of target device16to read one or more values from a specific file. If the user wanted to create a similar workflow activity in which a different value would be read from the same or a different file, the user would first generate the new workflow activity based on the selected workflow activity (box164). In one embodiment, generating the new workflow activity may be performed by the RDK tool40copying the contents of the selected workflow file to a new workflow file. Once generated, the user may provide the information defining the new values and/or file to be read for the newly generated workflow activity (box166). Additionally, if the user wanted to remove a given workflow activity that is no longer needed from the workflow, the user would simply select the desired workflow activity on the GUI of RDK tool40, and issue a command to remove the selected workflow activity (box168). Regardless of the modifications, however, the RDK tool40is configured to re-generate the workflow activity package to include the new and/or modified workflow activities based on a user input command.

FIG. 6is a block diagram illustrating some of the functional components of a client computing device20configured according to one embodiment of the present disclosure. As seen inFIG. 6, client computing device20comprises a processor circuit22, a user Input/Output (I/O) interface24, a communications interface circuit26, and a memory circuit28. Those of ordinary skill in the art will readily appreciate that the components shown herein are merely for illustrative purposes, and that client computing device20may comprise other components not specifically shown herein, as needed or desired.

Processor circuit22may be implemented by one or more microprocessors, hardware, firmware, or a combination thereof, and generally controls the operation and functions of client computing device20according to the appropriate standards. Such operations and functions include, but are not limited to, communicating with the application server14via network12to perform the functions described above with respect to the RDK tool40, which may execute on the application server14, as well as for delivering the compiled workflow activity package to the target device16, as previously described. In this regard, the processor circuit22may be configured to the implement logic and instructions associated with the client tier50portion of RDK tool40according to the embodiments as previously described.

The user I/O interface24provides the components necessary for a user to interact with client computing device20, and thus, comprises a display30and one or more user input devices32, such as a keyboard and a mouse, for example. The display30is configured to display the GUI provided by the RDK tool40in accordance with the associated code in the client tier50, while the input devices allow the user to navigate the GUI, make selections from information displayed by the GUI, and issue commands via the GUI to build and compile the workflow activities.

The communications interface circuit26facilitates communications with the application server14and the target device16via network12. To accomplish this function, the communications interface26may utilize any protocol or protocols known in the art to communicate messages and data in accordance with the previously described embodiments. In one embodiment, communications interface26comprises an ETHERNET card that communicates using the well-known Transmission Control Part (TCP)/IP protocols. However, the present disclosure also allows for the use of other communication protocols known in the art.

Memory circuit28may comprise any non-transitory, solid state memory or computer readable media known in the art. Suitable examples of such media include, but are not limited to, ROM, DRAM, Flash, or a device capable of reading computer-readable media, such as optical or magnetic media. The memory circuit28stores programs and instructions, such as the code34and data36for executing the functions of client tier50that control the processor circuit22to perform the functions previously described.

FIG. 7is a block diagram illustrating some of the functional components of an application server14configured according to one embodiment of the present disclosure. As seen inFIG. 7, application server14is a network-based computing device that comprises a processor circuit180, a communications interface circuit182, and a memory circuit184. As above, those of ordinary skill in the art will readily appreciate that the components shown herein are merely for illustrative purposes, and that application server14may comprise other components not specifically shown herein, as needed or desired.

The processing circuit180is similar to processing circuit22of client computing device20in that it may be implemented by one or more microprocessors, hardware, firmware, or a combination thereof, and generally controls the operation and functions of application server14according to the appropriate standards. In embodiments of the present disclosure, however, processing circuit180is configured to perform the previously described functions in accordance with the logic and data of the RDK tool40. Such functions include, but are not limited to, providing the client computing device20with the GUI for RDK tool40, information and data for display to the user via the GUI, and providing the capabilities and resources needed by the user to generate, compile, and deliver a workflow activity package, as previously described. Such communications are facilitated over network12via a communications interface circuit182.

The memory circuit184, which also comprises any non-transitory, solid state memory or computer readable storage media known in the art, is configured to store the code and data associated with the RDK tool40. Such code and data includes, but is not limited to, the code and data associated with the server tier60portion of the RDK tool40.

Thus, the foregoing description and the accompanying drawings represent non-limiting examples of the methods and apparatus taught herein. As such, the present invention is not limited by the foregoing description and accompanying drawings. Instead, the present invention is limited only by the following claims and their legal equivalents.