Patent Application
20190220331
The present disclosure relates generally to distributed systems and more particularly, to distributed systems utilizing a service based architecture for event serving and event-driven programming.
In our modern era, globalization and rapidly evolving technology have enabled decentralized organizations with distributed partner eco-systems and supply-chains. These decentralized organizations have become increasingly fragmented, depending on their IT estate more than ever to impose transparency, interoperability, and management across their environments. Unfortunately, decomposition into modular service-based architectures has not been balanced with a higher-level event-driven programming model to coordinate activity. This presents a roadblock to transformation into real-time digital businesses.
There are many modern software architectures, deployment technologies, languages, and tools which serve different use-cases. Ideally, these assets would be composable to flexibly address constantly evolving business requirements. However, the absence of a unified programming model results in business and technical silos, which constrain interoperability, prevent meaningful re-use and composability, and limit transparency. As a further result of the absence of the unified programming model, application development and DevOps automation is constrained. With the exception of giant web-companies that are “digital natives,” for most organizations, testing and debugging software is difficult and change is time-consuming as well as expensive. Despite evolution of modern software architectures, long promised agility remains elusive, which impedes transformation to real-time, highly-connected and adaptable digital businesses.
Organizations want to be agile so they may seize opportunities, respond to threats, and generally self-improve. The ability to adapt behavior for a current context is a fundamental optimization and survival strategy. Organizations that fail to evolve with their environment are not sustainable over time.
A challenge for many organizations is that their existing information, communication and automation systems, in and of themselves, do not support this new mode of operations. While there exist innumerable software languages and technologies that satisfy a wide variety of requirements, a significant challenge is how to flexibly and dynamically connect people, information, systems and devices for a new class of ‘smart’ processes.
An exemplary system for implementing complex distributed events in a cloud-native architecture comprises one or more processors and memory storing instructions that, when executed by the one or more processors, cause the system to perform: receiving one or more published events by an event hook application program interface (API) from one or more client applications, passing a model to a web server configured to generate web containers in concurrent threads, receiving, by any number of worker nodes, each web container, each of the worker nodes including a system agent program for dynamically assigned functions, the web containers being provided to the any number of worker nodes for logical isolation of system agent execution in memory, and performing the dynamically assigned functions by the system agent program in a blackboard memory, the blackboard memory being a shared memory with non-blocking reads and writes and performing functionality, the dynamically assigned functions being executed in parallel and at least two of the dynamically assigned functions sharing context between inter-dependent processes.
The any number of worker nodes may be dynamically assigned web containers based at least in part on one or more published events from the one or more client applications. In some embodiments, dynamically assigning web containers enables the system agent program to execute utilizing at least one of the web containers to act as an event broker. The web server may be a listener exposed as an event hook interface to dispatch schedule-free, non-blocking, concurrent, multi-threaded, logically isolated web containers for the any number of system worker nodes. The blackboard memory may implement the shared memory as immutable, append-only, log style persistence which supports the non-blocking reads and writes.
In various embodiments, the reads and writes to the blackboard memory follow a Command Query Responsibility Segregation (CQRS) pattern. The method may further comprise writing to a database from the blackboard memory, the writing to the database being as a stream of observable events for event sourcing, thereby allowing event chaining. The event chaining may enable processors to be modeled as dataflows. The method may further comprise modeling system microflow as a dataflow process based at least in part on the blackboard memory, the CQRS pattern, the event-sourcing and event chaining models. The system agent programs may utilize one or more dataflows to decompose complex event processing into a set of discrete tasks as part of the microflow. In various embodiments, the web server includes a system language that supports Common Object Model based on Directed Acyclic Graphs (DAGs) implementation as isomorphism. The web server may include a system runtime that supports Monadic Transformer support efficient DAG processing for implicitly complex objects.
An example non-transitory computer readable medium may comprise executable instructions. The instructions may be executable by a processor to perform a method for implementing complex distributed events in a cloud-native architecture. The method may comprise receiving one or more published events by an event hook application program interface (API) from one or more client applications, passing a model to a web server configured to generate web containers in concurrent threads, receiving, by any number of worker nodes, each web container, each of the worker nodes including a system agent program for dynamically assigned functions, the web containers being provided to the any number of worker nodes for logical isolation of system agent execution in memory, and performing the dynamically assigned functions by the system agent program in a blackboard memory, the blackboard memory being a shared memory with non-blocking reads and writes and performing functionality, the dynamically assigned functions being executed in parallel and at least two of the dynamically assigned functions sharing context between inter-dependent processes.
An example method comprises receiving one or more published events by an event hook application program interface (API) from one or more client applications, passing a model to a web server configured to generate web containers in concurrent threads, receiving, by any number of worker nodes, each web container, each of the worker nodes including a system agent program for dynamically assigned functions, the web containers being provided to the any number of worker nodes for logical isolation of system agent execution in memory, and performing the dynamically assigned functions by the system agent program in a blackboard memory, the blackboard memory being a shared memory with non-blocking reads and writes and performing functionality, the dynamically assigned functions being executed in parallel and at least two of the dynamically assigned functions sharing context between inter-dependent processes.
Various embodiments of the present disclosure include systems, methods, and non-transitory computer readable media configured to detect one or more real-time events and determine a context based on the one or more real-time events. An application model is fetched based on the context and meta-data associated with the one or more real-time events, the application model referencing one or more micro-functions, each micro-function being a declarative model of one or more atomic functions and including at least one pre-condition descriptor and at least one post-condition descriptor. A functional graph is constructed based on the one or more micro-functions of the application model. The one or more micro-functions are transformed into a plurality of micro-capabilities, each micro-capability of the plurality of micro-capabilities being capable of satisfying at least one pre-condition of the at least one pre-condition descriptor and at least one post-condition of the at least one post-condition descriptor, by determining at least one computing resource for execution of at least one of the plurality of micro-capabilities by matching pre-conditions of the at least one micro-capability of the plurality of micro-capabilities and matching post-conditions of the at least one micro-capability of the plurality of micro-capabilities; and enabling execution and configuration of the at least one micro-capability on the at least one computing resource by providing access in a target environment to an application program interface (API), the API capable of calling the at least one micro-capability to configure the at least one micro-capability on the at least one computing resource and execute the micro-capability on the at least one computing resource. A request is received to execute and configure the at least one micro-capability on the at least one computing resource from the target environment. The at least one micro-capability is executed and configured on the at least one computing resource, and an output of the at least one micro-capability is provided from the at least one computing resource to the target environment.
In some embodiments, the one or more real-time events include a real-time system request of the target environment. In related embodiments, the real-time system request indicates an application object in a header of the real-time system request, and the context includes an identifier indicating the application object. In related embodiments, the output of the at least one micro-capability from the at least one computing resource comprises a customized representation of the requested application object.
In some embodiments, the application model, the one or more micro-functions, the plurality of micro-capabilities, and the at least one computing resource are modeled from a root object defining base properties and capabilities.
In some embodiments, the systems, methods, and non-transitory computer readable media further comprise a plurality of computing resources, wherein the plurality of computing resources includes the at least one computing resource, the plurality of computing resources providing a virtualized pool of resources, each of the plurality of computing resources being a virtualized infrastructure, a physical infrastructure, or a software-controlled device.
In some embodiments, the plurality of computing resources are distributed across a multi-dimensional network of nodes connected by one or more links.
In some embodiments, the at least one computing resource includes one or more computing resource descriptors, the one or more computing resource descriptors including an API descriptor associated with the API. In related embodiments, the one or more computing resource descriptors comprise any of one or more local interfaces, local capabilities, local services, supporting services, and operating system kernels. In related embodiments, the one or more computing resource descriptors facilitate management of thread handling, resources, and memory spaces for the at least one computing resource much as an operating system performs for a singular virtual infrastructure unit, physical infrastructure unit, or software-controlled device.
Various embodiments of the present disclosure include systems, methods, and non-transitory computer readable media configured to provide a solution for the dynamic design, construction, deployment, use, and modification of software applications on a plurality of computing resources that operate collaboratively and in parallel.
In various embodiments, the systems and methods described herein are based on a multi-paradigmatic design, bridging Metaprogramming, Functional Programming, Object Oriented Programming and Model-Driven Engineering concepts, which results in a real-time interaction-driven system that dynamically constructs the components it needs in a dataflow pipeline of virtual functions to resolve a specific system request as a contextually optimized service.
In some embodiments, applications are declarative models of requirements for desired software behavior(s), which reference, directly or indirectly, Micro-functions. The application “intent” is realized by a Software Agent, which processes a cascade of models to render concrete behavior. The Agent resolves references for Micro-functions and executes them as a dataflow pipeline of contextualized Micro-capabilities on dynamically provisioned and configured Computing Resources on a short-lived thread
Various embodiments of the present disclosure include systems, methods, and non-transitory computer readable media configured to provide a federated computer system consisting of at least two computing devices and a logical and physical fabric.
In some embodiments, a system comprises a plurality of computing resources, each of which may be a tangible embodiment (e.g., a computing device) or a virtual embodiment of a group of a plurality of computing resources. The traits of these resources may be identified and made accessible through a classification scheme, providing unified access and usage of these resources independent of their embodiment.
In some embodiments, systems, methods, and non-transitory computer readable media are configured to provide a plurality of sets of small software elements, where each element embodies a single function without side effects, utilizing the resources of the underlying system embodiment through selective usage of identified traits as required for the function's embodiment. These small software elements may constitute contextualized micro-capabilities, which may be uniquely identified, and defined by their preconditions, post-conditions, and/or an embodied algorithm.
In some embodiments, systems, methods, and non-transitory computer readable media are configured to provide a plurality of sets of models and metamodels, which describe and define the interfaces and related semantics of all components of a system described herein. A metamodel may define a declarative language for the creation of a plurality of models describing the traits of the embodiment of the computing resources. These models may describe these traits in their structural aspects and in their exhibited semantics (e.g., application program interfaces (APIs)).
In some embodiments, a metamodel also may be used to define a language for the creation of a plurality of models, each of which may define the structural aspects and semantics (e.g., APIs) of a single micro-capability. The semantics defined by the model may include the algorithm embodied by the described micro-capability. Additionally, the semantics may include the preconditions that must be satisfied before invoking any execution of the algorithm embodied by the micro-capability. Preconditions may include the structure and type of any information required as input for the algorithm embodied by the micro-capability, any specific conditions of the surrounding environment required for the execution, and/or the like. These environment conditions may include all required supporting software and traits of the computing resource hosting the micro-capability embodiment. The model may further define the post-conditions holding after completion of the execution. Post-conditions may describe the structure and type of the execution results, their meaning, the specific conditions of the surrounding environment that must be met for a transfer of execution results and control flow, and/or the like.
In some embodiments, systems, methods, and non-transitory computer readable media are configured to provide ways and means to organize micro-capabilities. Micro-capabilities may follow two principles demanded by the paradigms of Model-Driven Architecture® and Functional Programing. These principles are separation of concerns and an absence of side effects. With respect to micro-capabilities, this means that each micro-capability may implement a single, distinct and atomic algorithm. It may perform the execution of this algorithm exclusively on the basis of the prevailing preconditions at the moment of invocation and may deliver results only in the form specified by the post-conditions. Besides these results, the execution may have no further effects on the surrounding environment. The conditions may be modeled as a micro-function, an implementation-independent definition (e.g., an abstract definition), sufficient to describe and classify a plurality of equivalent micro-capability embodiments hosted on a plurality of computing resources. The cascade of models used by the system transforms the micro-function into a contextualized embodiment for each use. These embodiments of micro-capabilities may be organized in a plurality of collections, like repositories or libraries. However, the definition and classification of micro-capabilities may be singular and common for all their embodiments. This enables the classification of all micro-capabilities independent of their embodiment, and provides an ability to maintain the plurality of classifications definitions for all micro-capabilities in a common catalog structure. This catalog may afford an ability to automatically derive executable solutions from the plurality of micro-capabilities.
In some embodiments, systems, methods, and non-transitory computer readable media are configured to provide a methodology and embodiment to construct executable software applications from micro-capabilities. Applications may be modeled using a declarative modeling methodology and environment. Applications may be defined in structure and function by a declarative model. This model comprises a plurality of sets of models that describe functional elements of the application as referenced micro-functions. A platform-independent embodiment (e.g., an abstract embodiment) of the application may then be constructed by assembling a solution graph from micro-function definitions based on algorithms and pre- and post-conditions. A software agent may perform a recursive transformation and combination of contextualized micro-capabilities. The result may be a complete core application, however in a representative (e.g., abstract) form, which means there is yet no real and executable embodiment of the application, but a complete composition plan listing all required micro-capabilities and their combination. After deciding the deployment target, the agent may retrieve the micro-capability embodiments built for and compatible with the traits of the execution environment and construct the application embodiment based on the composition plan (e.g., an abstract composition plan). The composition plan may provide a real-time system by deploying and executing the software as a dataflow pipeline of contextualized Micro-capabilities on dynamically provisioned and configured Computing Resources in a short-lived thread. Or, since the composition plan is completely platform-independent, it may be pre-calculated and stored, and then reused for a plurality of deployments on a plurality of target platforms.
In some embodiments, systems, methods, and non-transitory computer readable media are configured to extend the technology presented herein into a federation over a plurality of computing resource embodiments distributed across a multi-dimensional arrangement of nodes. These nodes may represent physically separated embodiments of one or more computing resources, or may represent isolated logical computing resources within a larger hosting environment. An example for the latter would be a typical datacenter arrangement, where a plurality of virtual servers is hosted by a single physical server system. Each embodiment of a computing resource may represent an autonomous, self-contained system, connected to the plurality of surrounding computing resource embodiments by the means of a communication facility. These embodiments may expect this communication facility to provide a standardized set of peer-to-peer communication services for synchronous, asynchronous and ad-hoc messaging. The underlying technology to realize these services may vary from case to case. The plurality of interconnected computing resources allows applications to include models for Distributed Operating System concerns including, but not limited to, thread handling, resource management, memory spaces, and/or the like.
In some embodiments, a fabric of interconnected computing resources may be described as nodes, interconnected by links. Each node may host a complete embodiment of an execution environment capable of executing applications constructed from an arrangement of micro-capabilities. However, not all nodes need to have the ability to perform the construction process, or require this ability. This distinction allows the inclusion of nodes with very limited resources into the federated arrangement without losing the benefits of the model-driven automated composition of applications. The minimum abilities from such a limited, or basic node may include: (1) the presence of an execution environment that supports the execution of an application composed from micro-capabilities without relying on resources outside of that node; (2) the ability to report the traits and state of this node to other nodes; (3) the ability to receive and/or replace complete applications and/or individual micro-capabilities, communicated to that node by other nodes that are part of the fabric; (4) the ability to initialize, start, stop, reset, delete, or otherwise influence loaded applications based on communications received from other nodes in the fabric; and/or the like. In an embodiment, there must be at least one node in the fabric of nodes that has extended abilities beyond the abilities of a basic node, however, there is no upper limit on the plurality of such extended nodes.
In some embodiments, systems, methods, and non-transitory computer readable media are configured to provide a method of a rigorous structural and semantic description of APIs for all micro-functions and micro-capabilities. Based on this, an automated selection, matching and combination of micro-capabilities may be provided. This may be accomplished on the model level and therefor independent of the embodiment.
Applications are already rapidly evolving from centrally defined and controlled ‘monoliths’ to composite applications of Services and APIs that need to cross silos, organizational boundaries, domains, protocols and technologies. However, the prevailing application development practice is to develop software solutions on top of discrete software components required to process functional requirements (i.e., “middleware”), which results in siloed, static and brittle solutions. Middleware software components (e.g., Enterprise Service Buses; Business Process Management Suites; Complex Event Processing software; Business Rules Management Systems; API Gateways; Integration Technologies; Business Intelligence tools; etc.); are pre-integrated to form a middleware “stack”. Each component generally represents a long-running synchronous process, waiting for inputs to perform transformations and output results (i.e., operations). Since all connections between applications and components, components and components, and components and their underlying infrastructure (i.e., compute, storage and network resources) are established a priori creating a tangle of fixed dependencies (i.e., “tight-coupling”), any change to this solution architecture may cause applications to fail to perform desired target behavior. In addition, this design is based on a linear series of message-passing for communicating application state between component processes with the output of one component being the input to the next component, for an ordered series of operations (i.e., “orchestration”), which ultimately results in the targeted application behavior. The middleware stack introduces its own collective overhead, which impacts development considerations regarding compute and input-output intensive applications. The linear message-passing does not lend itself to a broad real-time evaluation of application state making it more ‘expensive’ from a processing perspective to dynamically customize application behavior per interaction (e.g., personalize user-experience; optimize transaction; etc.). Also, since application state related to executing functions is distributed across components, if any component process (i.e., executing thread) fails, state can be lost, leading to a failed transaction with no direct compensations. As a result of these inherent limitations, the prevailing application development practice involving middleware components is a rate-limiter on emerging business requirements, business agility writ-large and the transformation of modern companies into digital businesses.
In middleware software development, adaptations are traditionally accomplished through a directed and comparably slow process, constrained by the nature of the organizations and their systems. To date, exception and change management still generally remain inefficient, disconnected and largely manual processes.
Traditional engineering approaches are not necessarily capable of supporting rapid and dynamic adaptation of software systems in the dimensions of structure, functionality and spatial federation. The common practice of specifying and creating technical systems as a whole consists in the majority of cases of a single process stream, which typically leads to products forming large, cohesive units, with their characteristics “cast in stone” at a very early stage. This approach may be suitable for long-lasting infrastructure projects, like bridges or buildings, but not for information technology. However, to date, a similar single-stream process is a quite common practice in software engineering too, where it becomes more and more inappropriate, as it results in monolithic products that are difficult to maintain or change, and impossible to prove for correctness.
Many approaches have been proposed over the past decade to change this and make the development process in software engineering, or information technology in general, more agile and adaptable. A promising methodology among those is the Model-Driven Architecture® (MDA®) proposed by the Object Management Group® (OMG®). This methodology prescribes a cascade of modeling activities as the principle design phase for a system. The cascade starts with a high-level and conceptual model (e.g., abstract conceptual model), derived as a response to, and fulfillment of the system requirements. In the MDA® methodology, a sequence of model transformations follows that transition step-by-step from the conceptual model towards one or more implementable platform-specific models (PSM). During this cascade of model transformations and extensions, more and more external information is introduced to convert the concept into implementable specifications. While the pure and literal application of the MDA® methodology provides ample opportunity for change and verification along that cascade of model transformations and refinements, it still generally results in a monolithic end product. Though derived through a model-based and flexible design phase, a PSM implementation is itself a static output (i.e., the PSM is compiled to a non-portable, non-dynamic, non-adaptive, non-evolutionary platform).
Changes in the way we work may require us to re-think application architecture and the middle-tier. The conventional middleware stack is being disrupted by the broader technology movements mentioned above. Successful organizations are complex adaptive systems. In some embodiments, organizational systems support a complex adaptive operation, which is capable of adapting to a changing environment through dynamic networks of interactions and individual and collective behaviors that mutate and self-organize in response to changes and events to increase an agility and sustainability of the organization.
In some embodiments, the middle-tier is a lightweight, horizontally-architected, elastically scalable layer between the end-points an organization has access to and the behavior it wants (i.e., application logic). In this manner, middleware is re-imagined as a virtualized software-defined server with a distributed operating system, which supports the composition, run-time and management of highly responsive, connected and adaptive applications with related middleware functionality realized as dynamic services, rather than discrete software components.
Re-conceptualization of the middle-tier as a virtual software-defined server with a distributed operating system may allow organizations to more naturally express themselves as complex adaptive systems.
Adaptation, as it relates to the new middle-tier may include an ability to handle each system interaction individually, as its own dynamically interpreted complex-event, in order to construct a custom policy-controlled response based on real-time operational intelligence. Instead of deploying processes that simply execute fixed models for standardized responses from static connections, a fully dynamic “situationally-aware” approach may natively support variance at the model level to personalize user-experiences, contextualize policy-enforcement, recommend or direct next-best-actions (e.g., logical workflow), and/or the like, while at the metamodel level using interaction-metadata to translate policies that drive the discovery and binding of just the relevant system objects to resolve and record the event.
An ability to support variance at the model level affords the potential for in-flight user-driven policy-constrained modifications for a single instance without disruptive exception management processes. Likewise, an ability to support variance at the metamodel level affords the potential for adaptation of any of the participating system objects, without disruptive change management processes, as the objects, or even specific versions of each object, may be found and/or bound in real-time (e.g., dynamic composition and automated interoperability for non-disruptive API evolution).
A flexible and adaptable middle-tier may be extended by queries, functions, predictive analytics machine-learning algorithms, and/or the like, which may be other endpoints that may be referenced at either the model or metamodel level.
In an embodiment, the MDA® methodology is combined with principles from Functional Programming, Functional Reactive Programming, Dataflow Programming, Metaprogramming, and the like, in a multi-paradigmatic solution. Such a combination makes a new approach explicit: instead of producing a monolithic application as specified by the PSM, build a functional equivalent application as an arrangement of lightweight functional units. These functional units may conform to functional elements found in the conceptual model or one of its early derivatives in the model cascade. Each such functional unit may implement exactly one function without further side-effects and/or conform to a common interface specification. From the perspective of Functional Decomposition, this embodiment includes, but is not limited to, functions, business entities, policies, services, applications, and/or the like, that are all described by metadata in a common pool. Interactions of this embodiment may take the form of functional chains configured by metadata as directed by models. Essentially, this may satisfy the criteria for the “Pipe-and-Filter” architectural pattern, which is also part of the REST architectural style. From a system perspective, these functional chains include, but are not limited to, system functions that perform middleware capabilities, system policies for non-functional concerns, and/or the like, that are assembled from the functional units as part of the model cascade.
Collectively, these high-level principles may be brought together in a solution that constructs the components it needs in a pipeline of virtual functions or “micro-capabilities” that exist ephemerally to resolve a specific request as a dynamically realized service. This stands in stark contrast to the current middleware stack paradigm of manually integrating purpose-built static components, and then writing static applications across them that are inherently tightly-coupled and brittle, inhibiting desired organizational agility.
Building an application as an arrangement of functional units may open up the application for change (by altering the arrangement and/or substituting functional units with alternatives), but also may provide a basis for spatial extensions. Functional units belonging to one application may be placed on alternative processing facilities, thus allowing for spatial distributed and potentially parallel execution.
While modeling is an approach to specify the desired product in various level of abstraction, meta-modeling may provide a capability to define the modeling language used to specify the product, and to specify all aspects of the production environment used to create and deploy the product, as a set of models. As a consequence, the production environment itself opens up for easy adaptation, which in turn provides yet another dimension of adaptability to the final product. Using a common approach for modeling and meta-modeling, the boundary between “design-time” and “run-time” may be allowed to vanish. Well-defined algorithms and methodologies exist to select functional units and to support construction of an arrangement representing the application.
By applying Meta-modeling concepts to MBA®, some embodiments are able to interpret models based on real-time interaction context, using a dataflow pipeline to perform transformations on-demand, resulting in declarative and dynamic solutions, this is contrast to traditional applications of MDA® for solution development where models are compiled in advance creating specific source to target transformations a priori, resulting in imperative and static programs.
In some embodiments, all elements and components of the system, including, but not limited to, Applications, Micro-functions, Micro-capabilities, Computing Resources, and the like, are modeled from a Root Object that defines base properties and capabilities (e.g., identifier, metadata descriptor, etc.). The cascade of models used to generate applications may provide a form of dataflow-based polymorphic inheritance, contextualizing all models from a common base-object, allowing the application of Object Oriented Design Patterns (e.g., Facade, Factory, etc.) to assembled Functional Programs.
Solution components, according to some embodiments, may be defined as follows:
Applications are declarative models of requirements for desired software behavior(s), which reference, directly or indirectly, Micro-functions. Application “intent” is realized by a
Software Agent, which processes a cascade of models to render concrete behavior. An embodiment of Application is described below.
Micro-functions are declarative models of atomic functions, side-effect free and independent of implementations that are consumed by Applications. Micro-functions are explicitly modeled. Micro-functions are transformed into contextualized Micro-capabilities during execution. An embodiment of Micro-functions is described below.
Micro-capabilities are ephemeral processing intermediaries that are dynamically constructed by the Software Agent when implementing a Micro-function as a component of a solution. An embodiment of Micro-capabilities is described below
Computing Resources are declarative models of infrastructure resources (i.e., virtual and tangible compute, storage and network nodes, centralized and distributed), which collectively present a hybrid distributed network as a unified pool of resources (i.e., a computational mesh, lattice, fabric, etc.). An embodiment of Computing Resources is described below.
A Software Agent is a proxy for the System, handling requests and interpreting the Declarative language in order to process the cascade of models to realize intended application behavior. Software Agents dynamically construct, alter and adapt applications in real-time, by rearranging and reconfiguring micro-capabilities based on changes in any of the models (or objects they represent). Such behavior would not be possible using traditional model-driven approached.
In some embodiments, a Software Agent is an application realized by a recursive process:
Other Embodiments of Software Agents are described below.
In some embodiments, all applications, end-user and system applications, may utilize a logically uniform computing resource to host their execution.
Traits are a relatively new concept, originally introduced in conjunction with the C++ meta-programming concept, but are now an intrinsic part of the latest generation of programing languages, like Scala, Swift, and others. Conceptually, traits are very similar to interfaces in that they provide a contract consisting of declarations for data structures and operations, but in contrast to regular interfaces, traits may also directly embody implementations for data structures and operations.
Computing_Resources require the incorporation of traditional operating system functionality to fulfill their service contract. The following discussion extends the architecture pattern introduced in
In an illustrative more “traditional” operating system environment, shown in
A third example variation for an extension of the basic architecture pattern, as shown in
In
Common (in architecture terms) to the three illustrative architectural alternatives presented in
A feature of an embodiment is the arrangement of Computing_Resources 110 as a federated and distributed computing environment. Two nodes are shown in
Two nodes may be connected by means of a physical connectivity 320 between Federation_Fabric_Endpoints 120 embedded in the respective Computing_Resources 110. “Physical” in this context means any embodiment of a communication means capable of supporting a live peer-to-peer connection based on a standardized peer-to-peer communication protocol. This protocol requirement may exist only for the exhibited peer-to-peer connection; the underlying “physical” implementation may be free to use any reasonable means as long as the peer-to-peer requirements may be guaranteed and as long as embodiments of corresponding communication ports 310 compatible with both, the embodiment of the incorporating Federation_Fabric_Endpoint 120 and the characteristics of the “physical” connection scheme 320, are available.
The peer-to-peer connectivity across the communication path 320 may support the virtual direct connectivity between Computing_Resources 110 as shown as a dashed line 330 in
The modeling language for all micro-capabilities may be defined by the micro-capability meta-component named MicroCapability 400, which is part of a metamodel according to an embodiment. The meta-component MicroCapability may be a logical blueprint for the modeling of a plurality of function micro-capabilities, of which three are shown as examples for the whole plurality 411, 412, 413. The fact that the meta-component MicroCapability may be a defining metamodel for those Function micro-capabilities is expressed by the dependency relationships 430, stereotyped as «definedBy».
Each of the functional micro-capability (component models) may be embodied by at least one, or a plurality, of micro-capability implementations, embodying the algorithm, preconditions, and post-conditions specified in the corresponding micro-capability model. This is shown example by items 421, 422, 423, 424 and 425. An instantiation relationship is shown as dependency 440 stereotyped «instantiates». Each modeled micro-capability, as for example Function1411, may be instantiated by a plurality of sets of micro-capability instances. These sets may span a two dimensional space, where variations in the embodiment of the concrete algorithm implementing the abstract algorithm defined by the modeled micro-capability component (Function1 in this example) may represent one dimension, and the dependency of the micro-capability embodiment on the plurality of possible embodiments of the target Computing_Resource 110 may represent another dimension.
The MicroCapability Descriptor 510 may define an information model holding classification keys and formal descriptors about the functional characteristics and properties of the MicroCapability. This information may be complemented by an API_Descriptor 511, which may define the information model describing the provided and required interfaces, and all associated pre-and post-conditions. Dependency 503 may refer to the provided API 501 (and related post-conditions), while Dependency 504 may refer to the required API 502 and related post-conditions. When a micro-capability is modeled based on this metamodel, the MicroCapability Descriptor and API_Descriptor may be instantiated. Their embodiment may hold all necessary information to create, combine and deploy an embodiment of that modeled micro-capability.
An equivalent arrangement may exist for the interface pairing 522 between micro-capability Function2412 and micro-capability Function3413, using part of API_Descriptor 542 to describe the required interface of micro-capability Function2412, and part of API_Descriptor 543 to describe the matching provided interface of micro-capability Function3413.
An example construction of an Application model 600 is shown in
This example is shown by 421, 423 and 425 for app1641, and by 422, 423 and 424 for app2642. The fact that these Application embodiments 641, 642 may be composed from micro-capability embodiments stored in the MicroCapability implementation repository 620 is expressed by the dependency relationships stereotyped «composedFrom» 660.
The MicroCapability implementation repository 620 may only logically be part of the Computing_Resource embodiment node1610. In this example, the embodiment of repository 620 may be collocated with another Computing_Resource embodiment and connected with the current Computing_Resource embodiment node1610 by means of the peer-to-peer communication services provided by the Federation Fabric Endpoints 120.
The shown three Computing_Resources may differ only in the services associated with them. They may also differ in the method of their embodiment, but on a logical level, they may be equal, as guaranteed by a provided common service contract. The Computing_Resource shown in the center of
In some embodiments, the Computing_Resource shown to the left in
The Computing_Resource shown on the right side in
Composition, configuration, and deployment of applications may be accomplished by autonomous agents on two logical levels. On the platform-independent model level, the Composer Agent 720 may accept application models from the Design_Studio 730 via the model input interface shown as the connector 732. The Composer Agent 720 (e.g., an agent configured to perform the composer role) may analyze the application model and construct an equivalent model as a lattice of interconnected micro-capabilities, using the descriptors and ontologies provided by the MicroCapability metadata repository 550 via the connector 721. An illustrative embodiment of this process is detailed in the next section. A result of this processing by the Composer Agent 720 may be a new model that includes a deployment and configuration plan. This model may be communicated to the plurality of Deployer Agents 710 (e.g., agents configured to perform the deployer role) which may construct the embodiment of the application using the appropriate combination of compatible embodiments of micro-capabilities as provided in the plurality of MicroCapability implementation repositories 620 and as directed by the deployment model communicated through connection 722 from the Composer Agent 720 to the plurality of Deployer Agents 710. The Deployer Agents 710 may be responsible to load and activate the application in the appropriate Computing_Resources 110 through their connection 712.
The returned Behavior Metric may be evaluated against the function requirements in action 805 and the returned micro-capability can be either accepted or rejected. If it is rejected, Selection Criteria and Start Conditions may be altered and the search pattern restarted. If the returned micro-capability is accepted, then it can be chained to preceding micro-capabilities in action 806 and the Start Conditions updated. This iterative process is repeated until the whole Function Graph is satisfied. This decision is made in action 807. In action 808, the final Start conditions may be converted into Terminal Conditions, which reflect the final function results and associated post-conditions. The completed MicroCapability Composition Plan can be published for subsequent deployment through the Deployer Agents (e.g., agents configured to perform the deployer role).
This results in an executable application deployed into the target Computing_Resource embodiment at the exit action 908 of the deployment process.
The computer system 1020 is shown including a processing component 1022 (e.g., one or more processors), a storage component 1024 (e.g., a storage hierarchy), an input/output (I/O) component 1026 (e.g., one or more I/O interfaces and/or devices), and a communications pathway 1028. In general, the processing component 1022 executes program code, such as a functional modeling interface 1030, which is at least partially fixed in the storage component 1024. While executing program code, the processing component 1022 may process data, which can result in reading and/or writing transformed data from/to the storage component 1024 and/or the I/O component 1026 for further processing. The pathway 1028 provides a communications link between each of the components in the computer system 1020. The I/O component 1026 may comprise one or more human I/O devices, which enable a human user 1012 to interact with the computer system 1020 and/or one or more communications devices to enable a system user 1012 to communicate with the computer system 1020 using any type of communications link. To this extent, the computer system 1020 may manage a set of interfaces (e.g., graphical user interface(s), application program interface, and/or the like) that enable human and/or system users 1012 to interact with the software executing thereon, such as the functional modeling interface 1030. Furthermore, the functional modeling interface 1030 may cause the computer system 1020 to manage (e.g., store, retrieve, create, manipulate, organize, present, or the like) the data, such as one or more functional model-based applications 1036, using any data management solution.
In any event, the computer system 1020 may comprise one or more general purpose computing articles of manufacture (e.g., computing devices) capable of executing program code installed thereon. As used herein, it is understood that “program code” means any collection of instructions, in any language, code or notation, that cause a computing device having an information processing capability to perform a particular function either directly or after any combination of the following: (a) conversion to another language, code or notation; (b) reproduction in a different material form; and/or (c) decompression.
As used herein, the term “component” means any configuration of hardware, with or without software, which implements the functionality described in conjunction therewith using any solution. The term “module” means program code that enables a computer system 1020 to implement the functionality described in conjunction therewith using any solution. When fixed in a storage component 1024 of a computer system 1020 that includes a processing component 1022, a module is a substantial portion of a component that implements the functionality. Regardless, it is understood that two or more components, modules, and/or systems may share some/all of their respective hardware and/or software. Furthermore, it is understood that some of the functionality discussed herein may not be implemented or additional functionality may be included as part of the computer system 1020.
When the computer system 1020 comprises multiple computing devices, each computing device may have only a portion of a software application, such as the functional modeling interface 1030 and/or the functional model-based application 1036, fixed thereon (e.g., one or more function models 1038 of the application 1036). However, it is understood that the computer system 1020 and program code (e.g., a software application) are only representative of various possible equivalent computer systems that may perform a process described herein. To this extent, in other embodiments, the functionality provided by the computer system 1020 and program code executing thereon can be at least partially implemented by one or more computing devices that include any combination of general and/or specific purpose hardware with or without program code. In each embodiment, the hardware and program code, if included, can be created using standard engineering and programming techniques, respectively.
Regardless, when the computer system 1020 includes multiple computing devices, the computing devices may communicate over any type of communications link. Furthermore, while performing a process described herein, the computer system 1020 may communicate with one or more other computer systems using any type of communications link. In either case, the communications link may comprise any combination of various types of wired and/or wireless links; comprise any combination of one or more types of networks; and/or utilize any combination of various types of transmission techniques and protocols. In an embodiment, the computer system 1020 comprises an application server, which communicates with users 1012 over the Internet.
As discussed herein, the functional model-based application 1036 may be represented by a set of function models 1038. Each function model 1038 may define a function as a set of hardware-independent actions. A function model 1038 may reference one or more micro-functions 1034, which can be made available for use in defining the functional model-based application 1036 in a distributed operating system 1032. To this extent, the functional modeling interface 1030 may provide an interface that enables a user 1012 to define, modify, and/or the like, a function model 1038 by selecting one or more micro-functions 1034 and defining the corresponding conditions, criteria, chain, and/or the like, as described herein.
When desired, the user 1012 may deploy the functional model-based application 1036 for execution in a target computing environment 1010. As part of the deployment process, the functional model-based application 1036 may be converted into an executable application by a set of nodes, such as the computer system 1020, in the target computing environment having a distributed operating system 1032. In particular, the set of nodes in the target computing environment can comprise a distributed operating system 1032, which includes one or more agents 1033, which are configured to process the function model(s) 1038 of the application 1036. Such processing can utilize the micro-functions 1034 to convert device-independent references for the corresponding micro-functions into implementations of the micro-functions capable of performing the corresponding micro-function within the target computing environment as contextualized micro-capabilities 1010. The micro-functions 1034 may provide the functional model-based application 1036 with unified access and usage of resources independent of their embodiment. As discussed herein, such a conversion may occur in real-time during execution of the functional model-based application 1036, thereby enabling the execution of the functional model-based application 1036 to be highly responsive to changes to the target computing environment.
The computing environment 1010 may include a fabric of interconnected computing resources, which includes computer system 1020 as well as one or more additional computer systems 1021A, 1021B. Each computer system 1021A, 1021B can be configured similar to the computer system 1020, although a computer system 1021A, 1021B may not include a functional modeling interface 1030 and/or a distributed operating system 1032. As illustrated, each of the computer systems 1020, 1021A, 1021B may communicate with each other using any solution. When a functional model-based application 1036 is deployed to the computing environment 1010, the computer system 1020 may utilize one or more resources of another computer system 1021A, 1021B to execute the functional model-based application 1036. Such utilization can include providing at least a portion of the functional model-based application 1036 for execution on the computer system 1021A, 1021B (e.g., when the computer system 1021A, 1021B includes a distributed operating system 1032).
As described herein, some embodiments may address significant issues with respect to the design, development, and deployment of software applications. In particular, some embodiments can allow a user to design and deploy an application using a functional modeling solution, such that the application is not restricted to execution in any particular target computing environment. Additionally, some embodiments can address significant issued regarding the execution of applications in distributed computing environments. In particular, as the amount and/or types of resources available in these computing environments can be frequently changed, binding of the software application to a particular configuration of computing resources can be delayed until such binding is required during execution of the application.
While shown and described herein as a method and system for managing (e.g., designing, constructing, deploying, using, and modifying) software applications on a plurality of computing resources, which can operate collaboratively and in parallel, it is understood that various alternative or additional embodiments may be provided. For example, in various embodiments, a computer program is fixed in at least one computer-readable medium, which when executed, enables a computer system to manage software applications on a plurality of computing resources. To this extent, the computer-readable medium includes program code, which enables a computer system to implement some or all of a process described herein. It is understood that the term “computer-readable medium” comprises one or more of any type of tangible medium of expression, now known or later developed, from which a copy of the program code can be perceived, reproduced, or otherwise communicated by a computing device. For example, the computer-readable medium can comprise: one or more portable storage articles of manufacture; one or more memory/storage components of a computing device; paper; and/or the like.
In another embodiment, a method provides a copy of program code, which enables a computer system to implement some or all of a process described herein. In this case, a computer system may process a copy of the program code to generate and transmit, for reception at a second, distinct location, a set of data signals that has one or more of its characteristics set and/or changed in such a manner as to encode a copy of the program code in the set of data signals. Similarly, some embodiments provide a method of acquiring a copy of the program code, which includes a computer system receiving the set of data signals described herein, and translating the set of data signals into a copy of the computer program fixed in at least one computer-readable medium. In either case, the set of data signals can be transmitted/received using any type of communications link.
In still another example, a method provides generating a system for managing software applications on a plurality of computing resources. In this case, the generating may include configuring a computer system, such as the computer system 1020 (
The conventional web server 1100 may include any number of client applications 1102 that publish events to a listener web server 1104 which subsequently dispatches web containers 1110 on concurrent threads. Client applications 1102 may be any executable application requesting creation or utilization of functionality.
A web server 1104 may be any conventional web server that utilizes Hypertext Transfer Protocol (HTTP) to serve files in the form of web pages to users in response to requests and may further include a dedicated computer. In this example, the client applications 1102 may communicate with the web server 1104 to create web containers 1110 for different functionality that may be handled on concurrent threads.
The web server 1104 typically includes a language 1106 and runtime environment 1108 to create the web containers 1110. Each web container 1110 may include a request/response processing engine which may process and provide functional responses based on the events published by a client application 1102.
Due in part to the nature of web containers 1110 utilizing request/response processing 1112 for functionality, they can be highly limited in capability.
Like the conventional web server 1100 discussed with regard to
In the example of
Various embodiments discussed herein include an approach to an Event server that can be naturally adopted by implementations of modern (e.g., modular, distributed, and/or service-based) software architectures (e.g., Service Oriented Architecture (SOA), microservices architecture, and/or “Serverless” functions-as-a-service architecture), to provide complex distributed, asynchronous, and/or multi-threaded event processing with optimistic concurrency. Systems discussed herein may enable sophisticated model-based subscriptions and may support related execution in a scalable cloud-native architecture.
Historically, Complex Event Processing (CEP) capabilities are generally part of heavily engineered systems, typically based on an Event-Driven Architectures (EDA) using some form of centralized bus with a large number of manually-integrated components (e.g., CEP engines, rules engines, workflow engines, databases) implemented as a tightly-coupled “monolith” (e.g., SOA).
Like the conventional web server 1100 and the conventional event server 1200, the conventional complex event solution 1300 approach may include any number of client applications 1102 that publish events to an event hook API 1302. The event queue platform 1304 in this example is a heavily engineered system using a centralized enterprise service bus 1314 with any number of manually integrated components, including, in this example, a rules engine 1316, a workflow engine 1318, and databases 1320. While only three manually integrated components are depicted in
The event queue platform 1304 may include functionality for sophisticated model based subscriptions 1306 that may pass models based on the event to the event queue engine 1308 to utilize the manually integrated components of the enterprise server bus 1314 to provide and/or build functionality.
Such conventional CEP implementations expose an asynchronous pub/sub messaging interface, but their internal processing is generally stateful, synchronous, and single-threaded. In this regard, CEP is not considered “cloud-native” (e.g., stateless, horizontally and elastically scalable, resilient and portable). However, CEP implementations support sophisticated model-based subscriptions and related execution, which defines the Complex Event Processing (CEP) category.
As discussed herein, this conventional complex event solution 1300 approach is tightly coupled, difficult to implement, and lacks flexibility and scalability.
Systems and methods described herein may include distributed systems, Service-based Architectures (SOA, Microservices, FaaS), coordination theory, blackboards, multi-agent systems, functional programming, dataflow processes, Complex Event Processing, event servers, and/or event-driven programming.
Cloud-native architectures often incorporate lighter-weight event processing capabilities within individual services to provide discrete dynamicity, however, the very tenets of cloud-native architecture (e.g., stateless, isolated, shared-nothing), constrain higher-level abstractions, mediation and management across cloud-native services (e.g., microservices and/or “serverless” functions). Conventional implementations often do not realize “complex” events. Such cloud-native event-processing engines typically expose an asynchronous pub/sub messaging interface and their internal processing is generally stateless, asynchronous, single-threaded in nature. In addition, they can be characterized as lighter-weight because they tend to be narrowly focused on low-level messaging concerns, “simple” CRUD events (i.e., manually coded events and handlers using HTTP verbs for simple imperative actions), which leads to recognized design problems (e.g., “call-back hell,” exploding pointers, and/or uncoordinated processes).
Industry attempts to have more expressive, complex, but cloud-native events end up reconstructing middleware component stacks for their services, which not only adds deployment complexity it undermines the tenets of cloud-native architecture. Alternative patterns, such as promise and futures, do support chaining of simple asynchronous events, but remain code-first one-off solutions.
Some embodiments provide a cloud-native event server for complex distributed, asynchronous, multi-threaded event processing with optimistic concurrency, which enables sophisticated model-based subscriptions and supports related execution.
In the example of
The system 1400 run-time may be implemented over an event queue and in-memory processing. In the example of
In
System agents 1416 (i.e., system agent programs 1416) may be or include an sophisticated model based subscription(s) 1418 modeled as a dataflow process which may direct the agent's internal methods for event processing (e.g., the system microflow).
System agent programs 1416 may be executed on worker nodes 1414 and may utilize in-process communications for shared-memory in a blackboard 1420 (i.e., Blackboard, Coordination Theory). The blackboard 1420 may be a shared memory that supports efficient coordination of 1) at least some system agent programs 1416 executing tasks in parallel, and 2) at least some system agent programs 1416 sharing context between inter-dependent processes.
The system 1404 may implement the shared-memory blackboard 1420 for the multi-agent system as immutable, append-only, log-style persistence, which inherently supports non-blocking reads and writes. Reads and writes to the system blackboard 1420 may follow a Command Query Responsibility Segregation (CQRS) pattern.
The system 1400 may treat database writes as a stream of observable events for event sourcing, thereby allowing chaining of events. Event chaining enables processes may be modeled as dataflows in the dataflow process 1422 (e.g., Saga Pattern).
The system agent program 1416 may leverage the blackboard 1420, CQRS, event-sourcing (e.g., through the dataflow process 1422) and Saga Patterns (e.g., system data architecture), to model system microflow as a dataflow process 1422, which may naturally support parallel processing consistent with functional programming paradigms.
It will be appreciated that the client applications 1102 and/or the blackboard 1420 may emit events. In some embodiments, the events may be published for further processing.
The agent system program 1416 may utilize a dataflow process to implement a divide-and-conquer algorithm, which decomposes Complex Event Processing (CEP) into a set of discrete tasks as part of the microflow.
Worker nodes 1414 may be dynamically assigned web containers (e.g., by the web server 1408 utilizing the events, such as context of the events, and/or models, such as a references model) for a system agent's execution in-memory (e.g., acting as an event broker).
In some embodiments, the systems and methods discussed herein enable the implementation of complex distributed events in a lightweight, cloud-native architecture to enable real-time digital businesses.
Unlike a mainstream divide-and-conquer map-reduce algorithm, which distributes the same workload task across many workers for efficient big data processing, the agent programs 1416 may distribute diverse workload tasks for (e.g., optimal) Complex Event Processing (CEP).
The agent programs 1416 may direct task processing. In one example, one or more agent programs 1416 memorize intermediary results in their respective worker nodes 1414. Upon completion, the agent programs 1416 may write results to the blackboard 1420. Updates to immutable objects may serve as event triggers to launch other worker nodes 1414, dynamically distributing processing of other tasks, parallel and serially, as part of the microflow.
In some embodiments, agent programs 1416 use Lazy-Evaluation and Goal-Oriented methods. The system 1414 may exploit the Saga Pattern, to progressively process, indirectly building a closure for a distributed transaction based on a Three-Phase Commit (3PC) providing a trace, compensations and roll-back.
The system 1400 may expose external interfaces (e.g., REST API) for system clients (e.g., client applications 1102) to model sophisticated subscriptions and dataflows using the system language 1410, and then the system 1414 may act as the event listener and event broker.
In various embodiments, as a whole, the system 1404 realizes a programming model, which abstracts complexity of distributed, asynchronous, parallel computing, to radically simplify the development of cloud-native complex event-driven applications.
The event server may also serve as a kernel for building higher-level systems, including, but not limited to: a serverless platform 1500, application controllers 1600 and/or application platforms 1700, described herein as embodiments of the event server.
Returning to
The system language 1410 may be based on JavaScript, a dynamic language, which natively supports Functional Programming and Object-Oriented Programming concepts, as well as non-hierarchical Prototypal Inheritance. The system language 1410 may materially extends JavaScript in multiple ways, including, but not limited to:
These extensions respectively may provide advanced and common methods, which may enable a declarative abstraction to be raised over JavaScript allowing the system language 1410 to support a model-based design and execution environment.
The functional programming hook extensions may provide interfaces over language primitives necessary to enable a rich model of multi-paradigmatic functional programming. The functional programming hooks may include, but are not limited to:
The functional programming hooks may support external interfaces (e.g., REST API) for system clients to model sophisticated subscriptions and dataflows as system objects.
In some embodiments, a common object model is provided for encoding entities as Directed Acyclic Graphs (DAG), which provides a language-level isomorphism. The common object model may implement a consistent data structure, for describing properties, behaviors, and dependencies of entities as a set of conditional relationships. The common object model may raise an abstraction over all entities, regardless of type, to support common methods (e.g., discovery, composition, transformation, orchestration, configuration, and/or policy-based management). Objects may be dynamically typed via prototypal inheritance.
Dataflow processes 1422, may describe any set of transformations and higher-level workflows. The dataflow processes may be naturally described as Directed Acyclic Graphs (DAG), so they can also be modeled directly as common objects of the system language 1410. Thus, the system language 1410 may provide a single notation for modeling data and methods, which may fundamentally support functional substitution (e.g., language-level composability). This may represent a unified model for abstract rewriting and transition systems, a long-sought Computer Science objective for concurrent communicating systems. It may support clean, concise, maintainable systems.
The system runtime 1412 may be based on a multi-agent system architecture. System agents (e.g., within the web server 1408) may be the event-broker for system interactions. An event queue (e.g., system-wide listener) may trigger a request for an instance of a system agent to execute a generic event-loop (e.g., the system agent program 1416) in-memory.
In some embodiments, the system runtime 1412 may be built over a JavaScript engine and the system agents may be stateless JavaScript Functions.
The system agent program 1416 may be a generic event-loop for side-effect free processing of the objects modeled in the system language 1410 (e.g., Directed Acyclic Graphs).
The system agent program 1416 may be implemented as a Monadic Transformer, which may be a functional programming pattern approximating first order logic for computationally intensive graph processing. In some embodiments, the principles that define a Monadic Transformer may make it uniquely capable of optimizing the Lazy Evaluation of the system's DAG objects making the coordination of real-time, event-driven, distributed applications tractable.
The serverless platform 1500 may perform JavaScript functions and perform as Back-end-as-a-Service. In some embodiments, the event server is embedded as the engine (e.g., web server 1408) for a serverless platform 1500 that abstracts infrastructure environment to provide Functions-as-a-Service. The serverless platform 1500 may inherit all the advantageous properties (e.g., sophisticated model-based subscriptions, parallel processing for complex events, event-chaining for dataflow processes across functions) of the event server, making it highly differentiated from currently leading offerings.
The serverless platform 1500 may bundle the event server with Java, a web server 1408 (e.g., Java Servlet Container, Apache HTTP Server), and client libraries (e.g., code repository 1502 including any number of functions 1504) necessary to support use of the serverless platform 1500.
The client libraries may be comprised of system objects, which may extend event-sever capabilities for the serverless platform 1500 implementation. The additional capabilities may include, but are not limited to:
The serverless platform 1500 may natively execute JavaScript functions and could be extended with adaptors to support other run-times. The serverless platform 1500 may be provided as a cloud-based service or made available as a deployment package for various target hosts (e.g., container, virtual machine, or server-based).
System agent programs 1416 executed by the worker nodes 1414 may output registered functions back to the client applications 1102 and/or provide calls to the code repository 1502. The registered functions may provide references to the code repository 1418 based on events published by the client applications 1102.
In some embodiments, the event server is embedded within the application controller 1600 to support Layer 7 middleware services for client applications 1102. The application controller 1600 may act as a local lightweight, low-latency, high-performance proxy, which decouples client applications from embedded middleware libraries and remote middleware stacks, so they may scale and evolve independently.
The application controller 1600 may inherit advantageous properties (e.g., sophisticated model-based subscriptions, parallel processing for complex events, event-chaining for dataflow processes across functions) of the event server, making it highly differentiated from currently leading offerings.
The application controller 1600 may bundle the event server with Java, a web server 1408 (e.g., Java Servlet Container, Apache HTTP Server), and client libraries necessary to support the application controller's use.
The client libraries may be comprised of system objects, which extend event server capabilities for the application controller 1600 implementation. The additional capabilities may represent common messaging and middleware patterns modeled as dataflows, including but are not limited to:
The application controller 1600 may support deployment packages for various target hosts (e.g., Container, Virtual Machine or Server-based).
Employing a standard application controller 1600 may provide an abstraction for an application fabric. The application fabric may provide observability over a mesh network of services and can act as an API Gateway exposing activity to Northbound systems (e.g., portals/dashboards, analytics/big data, and AI/ML). The application fabric may also automate the lifecycle management of the application controller 1600 via immutable updates for configuration consistency and resilience.
The application platform 1700 may include the modeled applications 1102, the event hook API 1402, the web server 1408 (which includes the system language 1410 and the system runtime 1412), as well as the worker nodes 1414, and system agent programs 1416 as depicted in
In some embodiments, the event server may be embedded within an application platform 1700 to provide logically centralized discovery, composability, integration, orchestration, automation and management for distributed business and infrastructure applications. The event server may support Layer 7 middleware services for the application platform 1700.
The application platform 1700 may inherit advantageous properties (e.g., sophisticated model-based subscriptions, parallel processing for complex events, event-chaining for dataflow processes across functions) of the event server, making it highly differentiated from currently leading offerings.
The application platform 1700 bundles the event server with Java, a web server 1408 (e.g., Java Servlet Container, Apache HTTP Server), and client libraries necessary to support the application platform's use.
The client libraries may be comprised of system objects, which may extend event server capabilities for the application platform 1700 implementation. The additional capabilities may represent common messaging and middleware patterns modeled as Dataflows, and may include but are not limited to:
The application platform 1700 may be provided as a cloud-based service or made available as deployment packages for various target hosts (e.g., container, virtual machine, or server-based).
The application platform 1700 may act as an API Gateway exposing activity to Northbound systems (e.g., portals/dashboards, analytics/big data, and AI/ML).
The present invention(s) are described above with reference to example embodiments. It will be appreciated that various modifications may be made and other embodiments may be used without departing from the broader scope of the present invention(s). Therefore, these and other variations upon the example embodiments are intended to be covered by the present invention(s).
The present application claims the benefit of U.S. Provisional Patent Application Ser. No. 62/618,027 filed Jan. 16, 2018 and entitled “Application Abstraction and Runtime for Serverless ‘Functions-As-A-Service’ Architecture,” which is incorporated herein by reference. Aspects of the current disclosure are related to U.S. patent spplication Ser. No. 15/417,122 filed Jan. 26, 2017 and entitled “Unified Operating System for Distributed Computing,” now U.S. Pat. No. 9,841,955, which claims the benefit of U.S. Provisional Patent Application Ser. No. 62/287,201 filed Jan. 26, 2016 and entitled “Unified Operating System for Distributed Computing,” each of which is incorporated herein by reference. Aspects of the current disclosure are also related to U.S. patent application Ser. No. 14/936,020 filed Nov. 9, 2015 and entitled “Resource Processing Using an Intermediary for Context-Based Customization of Interaction Deliverables,” which is a continuation of U.S. patent application Ser. No. 14/022,033 filed Sep. 9, 2013 and entitled “Resource Processing Using an Intermediary for Context-Based Customization of Interaction Deliverables,” now U.S. Pat. No. 9,182,977, which is a continuation of U.S. patent application Ser. No. 12/698,361 filed Feb. 2, 2010 and entitled “Resource Processing Using an Intermediary for Context-Based Customization of Interaction Deliverables,” now U.S. Pat. No. 8,533,675 (included as Appendix A hereto), which claims the benefit of U.S. Provisional Patent Application Ser. No. 61/149,179 filed Feb. 2, 2009 and entitled “Dynamic Context-Based System Interaction Construction,” each of which is incorporated herein by reference. Aspects of the current disclosure are also related to U.S. patent application Ser. No. 14/791,820 filed Jul. 6, 2015 and entitled Declarative Software Application Meta-Model and System for Self-Modification,” now U.S. Pat. No. 9,483,238, which is a continuation of U.S. patent application Ser. No. 13/846,630 filed Mar. 18, 2013 and entitled “Declarative Software Application Meta-Model and System for Self-Modification,” now U.S. Pat. No. 9,075,616 (included as Appendix B hereto), which claims the benefit of U.S. Provisional Patent Application Ser. No. 61/612,907 filed Mar. 19, 2012 and entitled “Software Application Modeling Environment,” each of which is incorporated herein by reference.
| Number | Date | Country | |
|---|---|---|---|
| 62618027 | Jan 2018 | US |
