Managing new versions of integration flows during rolling updates

Abstract

The method includes receiving an indication of a new integrated flow document that updates a current integrated flow document for the integrated flow; determining a last switchable node included in both the current integrated flow document and the new integrated flow document; for each executing instance of the integrated flow using the current integrated flow document, determining whether a currently executing node of the instance is less than or equal to the last switchable node; in response to determining that the currently executing node of the instance is less than or equal to the last switchable node, switching the instance to the new integrated flow document; and in response to determining that the currently executing node of the instance is greater than the last switchable node, waiting for completion of the instance using the current integrated flow document. Includes.

Description

[Technical field]

[0001] Aspects of the present invention relate generally to integration flows and, more particularly, to managing new versions of integration flows during rolling updates. [Background technology]

[0002] Integration products implement trigger actions, data synchronization, and batch scenarios between different applications. Integration flows are integration product artifacts that are created by tools such as graphical flow editors and executed by the integration product runtime. An integration flow is a sequence of nodes (i.e., components) that are linked together and represent event-driven control through integration, which is a software development activity in which separate software components are combined into an executable whole. Each node in an integration flow typically performs an integration action (e.g., accessing an external system and retrieving data from the external system, posting data to the external system, or making a call to an external system and generating data from the call). Each node in an integration flow is a component that has inputs and outputs that define an interaction (or interactions) with an object exposed by an external application. These inputs and outputs are defined in input and output arrays for the node, respectively, and the arrays may be included in mappings for the node. The mapping defines how to calculate or set values ​​for its parameters, which are used to interact with the external application or system.

[0003] Integrations may be developed using tools such as integration templates and a rich graphic editing experience. Using these tools, users may be able to organize and reorganize the integration flow and the position of each component, or node, within the flow. For example, users may be able to reposition or move components using a drag-and-drop mechanism. Summary of the Invention

[0004] In a first aspect of the present invention, there is a computer-implemented method including receiving, by a computing device, an indication of a new integrated flow document that updates a current integrated flow document for an integrated flow; determining, by the computing device, a last switchable node included in both the current integrated flow document and the new integrated flow document; determining, by the computing device, for each execution instance of the integrated flow using the current integrated flow document, whether a currently executing node of the instance is less than or equal to the last switchable node; in response to determining that the currently executing node of the instance is less than or equal to the last switchable node, switching the instance to the new integrated flow document; and in response to determining that the currently executing node of the instance is greater than the last switchable node, waiting for completion of the instance using the current integrated flow document.

[0005] In another aspect of the invention, there is a computer program product including one or more computer readable storage media having program instructions collectively stored on the one or more computer readable storage media, the program instructions being executable to: receive an indication of a new integrated flow document that updates a current integrated flow document of an integrated flow, determine a last switchable node included in both the current integrated flow document and the new integrated flow document, for each execution instance of the integrated flow using the current integrated flow document, determine whether the currently executing node of the instance is less than or equal to the last switchable node, in response to determining that the currently executing node of the instance is less than or equal to the last switchable node, switch the instance to the new integrated flow document, and in response to determining that the currently executing node of the instance is greater than the last switchable node, wait for completion of the instance using the current integrated flow document.

[0006] In another aspect of the invention, there is a system including a processor, a computer-readable memory, one or more computer-readable storage media, and program instructions collectively stored on the one or more computer-readable storage media, where the program instructions are executable to: receive an indication of a new integrated flow document that updates a current integrated flow document of an integrated flow, determine a last switchable node included in both the current integrated flow document and the new integrated flow document, determine for each execution instance of the integrated flow using the current integrated flow document whether a currently executing node of the instance is less than or equal to the last switchable node, in response to determining that the currently executing node of the instance is less than or equal to the last switchable node, switch the instance to the new integrated flow document, and in response to determining that the currently executing node of the instance is greater than the last switchable node, wait for completion of the instance using the current integrated flow document.

[0007] Aspects of the invention are described in the following detailed description in conjunction with a number of drawings, which are given as non-limiting examples of illustrative embodiments of the invention. [Brief description of the drawings]

[0008] [Figure 1] FIG. 2 illustrates a cloud computing node according to an embodiment of the present invention. [Diagram 2] FIG. 1 illustrates a cloud computing environment according to an embodiment of the present invention. [Diagram 3] FIG. 2 illustrates an abstract model layer according to an embodiment of the present invention. [Figure 4] FIG. 1 illustrates a block diagram of an exemplary environment in accordance with an aspect of the present invention. [Figure 5A] FIG. 2 illustrates an example of a visualization of an integrated flow document in accordance with an aspect of the present invention. [Figure 5B] FIG. 2 illustrates an example of a visualization of an integrated flow document in accordance with an aspect of the present invention. [Figure 6] FIG. 2 illustrates an exemplary pseudocode for a process in accordance with an aspect of the present invention. [Figure 7] FIG. 2 illustrates a flowchart of an exemplary method according to an aspect of the present invention. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0009] Aspects of the present invention relate generally to integrated flows, and more particularly to managing new versions of integrated flows during rolling updates. For a seamless experience of updating the flow document of a running integrated flow, a rolling update deployment of the flow document is used to achieve zero downtime. During a rolling update, a user may have to wait a long time for the new version to be applied across all of the running instances of the flow. For example, when a rolling update is initiated, any instances currently running using the current flow document continue to completion using the current flow document, and any new instances start using the new flow document. In some rolling updates, instances that continue to completion using the current flow document are then re-run using the new flow document to ensure that they run against the updated version of the flow document. Continuing to completion using the current flow document and then simply turning around and re-running using the new flow document consumes system resources and takes time. Some flows may take days or even weeks to complete, and waiting this amount of time for instances to finish running using the current flow document before applying the update is an undesirable situation.

[0010] An embodiment of the present invention addresses this problem by providing a method for optimizing the switching time to a newer version of an integrated flow by comparing the underlying flow integration documents. According to an aspect of the present invention, the system identifies the last switchable node by comparing the current flow document and the new flow document. The last switchable node is then used to switch an existing running integrated flow instance when applicable. In an embodiment, the system finds the last common node in the two flow documents (the current document and the new document), and any processes that are executing the current document and have not yet reached the last common node are automatically switched to executing the new document, thereby causing these processes to finish the flow using the new document. As a result, an embodiment of the present invention may reduce the rolling update time compared to conventional approaches by avoiding the practice of continuing to completion using the current flow document before running the flow from the beginning again using the new flow document.

[0011] In this manner, embodiments of the present invention provide an improvement in the art of integrated flows by decreasing the time to complete a rolling update of the integrated flow. Embodiments of the present invention also modify the operation of a computing device executing an integrated flow during a rolling update by changing the operation from using a first integrated flow document to using a second integrated flow document having different instructions than the first integrated flow document.

[0012] As described herein, there is a method for reducing the time required to perform a rolling update of an integrated flow by first comparing an old version and a new version of the flow to identify a common subset of nodes in the flows, and then secondly performing an update to the executing flow when a currently executing node is within the identified subset.

[0013] The invention may be a system, method, or computer program product, or combination thereof, at any possible level of technical detail of integration. The computer program product may include a computer-readable storage medium (or media) having computer-readable program instructions thereon for causing a processor to perform aspects of the invention.

[0014] A computer readable storage medium may be a tangible device that can hold and store instructions for use by an instruction execution device. A computer readable storage medium may be, for example, but not limited to, an electronic storage device, a magnetic storage device, an optical storage device, an electromagnetic storage device, a semiconductor storage device, or any suitable combination of the foregoing. A non-exhaustive list of more specific examples of computer readable storage media includes portable computer diskettes, hard disks, random access memory (RAM), read only memory (ROM), erasable programmable read only memory (EPROM or flash memory), static random access memory (SRAM), portable compact disk read only memory (CD-ROM), digital versatile disk (DVD), memory sticks, floppy disks, punch cards or mechanically encoded devices such as ridge structures in grooves that allow instructions to be recorded thereon, and any suitable combination of the foregoing. As used herein, a computer-readable storage medium should not be construed as a transitory signal per se, such as radio waves or other freely propagating electromagnetic waves, electromagnetic waves propagating through a waveguide or other transmission medium (e.g., light pulses passing through a fiber optic cable), or electrical signals transmitted through an electrical wire.

[0015] The computer readable program instructions described herein may be downloaded from the computer readable storage medium to the respective computing / processing device or to an external computer or storage device via a network, such as the Internet, a local area network, a wide area network, or a wireless network, or a combination thereof. The network may include copper transmission cables, optical transmission fiber, wireless transmission, routers, firewalls, switches, gateway computers, or edge servers, or a combination thereof. A network adapter card or network interface in each computing / processing device receives the computer readable program instructions from the network and transfers the computer readable program instructions for storage in the computer readable storage medium in the respective computing / processing device.

[0016] The computer readable program instructions for carrying out the operations of the present invention may be either source code or object code written in any combination of one or more programming languages, including assembler instructions, instruction set architecture (ISA) instructions, machine instructions, machine dependent instructions, microcode, firmware instructions, state setting data, configuration data for integrated circuits, or object oriented programming languages ​​such as Smalltalk®, C++, and procedural programming languages ​​such as the “C” programming language or similar programming languages. The computer readable program instructions may execute completely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or completely on a remote computer or server. In the latter scenario, the remote computer may be connected to the user's computer through any type of network, including a local area network (LAN) or a wide area network (WAN), or the connection may be made to an external computer (e.g., through the Internet using an Internet Service Provider). In some embodiments, electronic circuitry including, for example, a programmable logic circuit, a field programmable gate array (FPGA), or a programmable logic array (PLA), may execute computer readable program instructions by individualizing the electronic circuitry with state information of the computer readable program instructions to perform aspects of the invention.

[0017] Aspects of the present invention are described herein with reference to flowchart illustrations and / or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each block of the flowchart illustrations and / or block diagrams, and combinations of blocks in the flowchart illustrations and / or block diagrams, can be implemented by computer readable program instructions.

[0018] These computer readable program instructions may be provided to a processor of a computer or other programmable data processing apparatus to produce a machine such that the instructions, executed by the processor of the computer or other programmable data processing apparatus, generate means for performing the functions / operations specified in one or more blocks of the flowcharts and / or block diagrams. These computer readable program instructions may also be stored on a computer readable storage medium such that the computer readable storage medium on which the instructions are stored comprises an article of manufacture including instructions for performing aspects of the functions / operations specified in one or more blocks of the flowcharts and / or block diagrams, and may direct a computer, programmable data processing apparatus, or other device, or combination thereof, to function in a particular manner.

[0019] The computer readable program instructions may also be loaded onto a computer, other programmable data processing apparatus, or other device to cause the computer, other programmable apparatus, or other device to perform a series of operational steps to create a computer-implemented process, such that the instructions executing on the computer, other programmable apparatus, or other device perform the functions / operations specified in one or more blocks of the flowcharts and / or block diagrams.

[0020] The flowcharts and block diagrams in the figures illustrate the architecture, functionality, and operation of possible implementations of systems, methods, and computer program products according to various embodiments of the present invention. In this regard, each block in the flowcharts or block diagrams may represent a module, segment, or part of an instruction, including one or more executable instructions for implementing a specified logical function. In some alternative implementations, the functions described in the blocks may occur out of the order described in the figures. For example, two blocks shown in succession may in fact be implemented as one step, executed simultaneously, substantially simultaneously, partially or fully overlapping in time, or the blocks may be executed in the reverse order depending on the functionality involved. It should also be noted that each block in the block diagrams and / or flowchart illustrations, and combinations of blocks in the block diagrams and / or flowchart illustrations, may be implemented by a dedicated hardware-based system that performs the specified functions or operations or executes a combination of dedicated hardware and computer instructions.

[0021] Although this disclosure includes a detailed description of cloud computing, it should be understood that implementations of the teachings provided herein are not limited to cloud computing environments. Rather, embodiments of the invention may be practiced in conjunction with any other type of computing environment now known or later developed.

[0022] Cloud computing is a service delivery model for enabling convenient, on-demand network access to a shared pool of configurable computational resources (e.g., networks, network bandwidth, servers, processing, memory, storage, applications, virtual machines, and services) and for rapidly provisioning and releasing these resources with minimal administrative effort or interaction with a service provider. This cloud model may include at least five characteristics, at least three service models, and at least four deployment models.

[0023] The features are as follows: On-Demand Self-Service: Cloud consumers can unilaterally provision computing capabilities, such as server time and network storage, as needed, automatically, without the need for human interaction with the service provider. Broad network access: Cloud capabilities are available over the network and can be accessed using standard mechanisms, facilitating usage by heterogeneous thin- or thick-client platforms (e.g., mobile phones, laptops, and PDAs). Resource Pool: The provider's computing resources are pooled and offered to multiple consumers using a multi-tenant model. Different physical and virtual resources are dynamically allocated and reallocated according to demand. There is a sense of location independence, consumers usually have no control or knowledge regarding the exact location of the resources offered, although at a higher level of abstraction they may be able to specify a location (e.g. country, state, or data center). Rapid Elasticity: Cloud capacity is rapidly and elastically provisioned, in some cases automatically, and can be quickly scaled out and quickly released to quickly scale in. To the consumer, the capacity available for provisioning often appears unlimited, and any amount can be purchased at any time. Measured Services: Cloud systems leverage metering to automatically control and optimize resource usage at a level of abstraction appropriate to the type of service (e.g., storage, processing, bandwidth, and active user accounts). Resource usage can be monitored, controlled, and reported, providing transparency to both providers and consumers of the services used.

[0024] The service model is as follows: Software as a Service (SaaS): The capability offered to the consumer is the use of the provider's applications running on a cloud infrastructure. Those applications can be accessed from a variety of client devices through thin-client interfaces such as web browsers (e.g., web-based email). The consumer does not manage or control the underlying cloud infrastructure, including the network, servers, operating systems, storage, or individual application functionality, except for the possibility of limited user-specific application configuration settings. Platform as a Service (PaaS): The capability provided to a consumer is to deploy applications that the consumer creates or acquires, written using programming languages ​​and tools supported by the provider, onto a cloud infrastructure. The consumer does not manage or control the underlying cloud infrastructure, including networks, servers, operating systems, or storage, but does have control over the deployed applications and, in some cases, the configuration of the application hosting environment. Infrastructure as a Service (IaaS): The capability provided to a consumer is the provisioning of processing, storage, network, and other basic computational resources over which the consumer can deploy and run any software, which may include operating systems and applications. The consumer does not manage or control the underlying cloud infrastructure, but has control over the operating systems, storage, deployed applications, and in some cases, limited control over selected network components (e.g., host firewalls).

[0025] The deployment model is as follows: Private Cloud: The cloud infrastructure is operated solely for an organization. It can be managed by the organization or a third party and can exist on-premise or off-premise. Community Cloud: Cloud infrastructure is shared by multiple organizations to support a specific community with shared concerns (e.g., mission, security requirements, policy, and compliance considerations). It can be managed by these organizations or by a third party and can reside on-premise or off-premise. Public Cloud: The cloud infrastructure is made available to the general public or large industry organizations and is owned by an organization that sells cloud services. Hybrid Cloud: The cloud infrastructure is a composite of two or more clouds (private, community, or public) that remain a unique entity but are joined by standardized or proprietary technologies that enable data and application portability (e.g., cloud bursting for load balancing between clouds).

[0026] A cloud computing environment is a service-oriented environment with an emphasis on statelessness, loose coupling, modularity, and semantic interoperability. At the heart of cloud computing is an infrastructure that contains a network of interconnected nodes.

[0027] 1, an example of a cloud computing node is shown generally. Cloud computing node 10 is merely one example of a suitable computing node and is not intended to suggest any limitation as to the scope of use or functionality of the inventive embodiments described herein. Regardless, cloud computing node 10 is capable of implementing and / or performing any of the functionality described above.

[0028] Cloud computing node 10 includes computer system / server 12, which may be operational with numerous other general purpose or special purpose computing system environments or configurations. Examples of well-known computing systems, environments, or configurations, or combinations thereof, that may be suitable for use with computer system / server 12 include, but are not limited to, personal computer systems, server computer systems, thin clients, thick clients, handheld or laptop devices, multiprocessor systems, microprocessor-based systems, set-top boxes, programmable appliances, network PCs, minicomputer systems, mainframe computer systems, and distributed cloud computing environments that include any of the above systems or devices.

[0029] The computer system / server 12 may be described in the general context of computer system executable instructions, such as program modules, being executed by a computer system. Generally, program modules may include routines, programs, objects, components, logic, data structures, etc. that perform particular tasks or implement particular abstract data types. The computer system / server 12 may be implemented in a distributed cloud computing environment where tasks are performed by remote processing devices linked through a communications network. In a distributed cloud computing environment, program modules may be located in both local and remote computer system storage media, including memory storage devices.

[0030] 1, computer system / server 12 in cloud computing node 10 is shown in the form of a general purpose computing device. Components of computer system / server 12 may include, but are not limited to, one or more processors or processing units 16, a system memory 28, and a bus 18 coupling various system components including system memory 28 to processor 16.

[0031] Bus 18 represents any one or more of several types of bus structures, including a memory bus or memory controller, a peripheral bus, a high-speed graphics port, and a processor or local bus using any of a variety of bus architectures, including, by way of example and not limitation, an Industry Standard Architecture (ISA) bus, a Micro Channel Architecture (MCA) bus, an Enhanced ISA (EISA) bus, a Video Electronics Standards Association (VESA) local bus, and a Peripheral Component Interconnect (PCI) bus.

[0032] Computer system / server 12 typically includes a variety of computer system readable media. Such media may be any available media that can be accessed by computer system / server 12 and includes both volatile and nonvolatile media, removable and non-removable media.

[0033] The system memory 28 may include computer system readable media in the form of volatile memory, such as random access memory (RAM) 30 and / or cache memory 32. The computer system / server 12 may further include other removable / non-removable, volatile / non-volatile computer system storage media. By way of example only, the storage system 34 may be provided for reading from and writing to a non-removable non-volatile magnetic medium (not shown, and typically referred to as a "hard drive"). Although not shown, a magnetic disk drive may be provided for reading from and writing to a removable non-volatile magnetic disk (e.g., a "floppy disk"), as well as an optical disk drive for reading from or writing to a removable non-volatile optical disk, such as a CD-ROM, DVD-ROM, or other optical media. In such instances, each may be connected to the bus 18 by one or more data media interfaces. As further shown and described below, the memory 28 may include at least one program product having a set (e.g., at least one) of program modules configured to perform the functions of an embodiment of the present invention.

[0034] A program / utility 40 having a set (at least one) of program modules 42 may be stored in memory 28, as well as, by way of example and not limitation, an operating system, one or more application programs, other program modules, and program data. Each of the operating system, one or more application programs, other program modules, and program data, or any combination thereof, may include an implementation of a networked environment. The program modules 42 generally perform the functions and / or methodologies of the embodiments of the invention described herein.

[0035] The computer system / server 12 may also communicate with one or more external devices 14, such as a keyboard, pointing device, display 24, one or more devices that allow a user to interact with the computer system / server 12, or any device that allows the computer system / server 12 to communicate with one or more other computing devices (e.g., network cards, modems, etc.), or combinations thereof. Such communication may occur through an input / output (I / O) interface 22. Additionally, the computer system / server 12 may communicate with one or more networks, such as a local area network (LAN), a general wide area network (WAN), or a public network (e.g., the Internet), or combinations thereof, through a network adapter 20. As shown, the network adapter 20 communicates with other components of the computer system / server 12 through a bus 18. Although not shown, it is understood that other hardware and / or software components may be used in conjunction with the computer system / server 12. Examples include, but are not limited to, microcode, device drivers, redundant processing units, external disk drive arrays, RAID systems, tape drives, and data archive storage systems.

[0036] Referring now to FIG. 2, an exemplary cloud computing environment 50 is shown. As shown, the cloud computing environment 50 includes one or more cloud computing nodes 10 with which local computing devices used by cloud users, such as a personal digital assistant (PDA) or cell phone 54A, a desktop computer 54B, a laptop computer 54C, or an automobile computer system 54N, or combinations thereof, may communicate. The nodes 10 may communicate with each other. They may be physically or virtually grouped in one or more networks, such as a private cloud, a community cloud, a public cloud, or a hybrid cloud, or combinations thereof, as described above (not shown). This allows the cloud computing environment 50 to offer infrastructure, platform, and / or software as a service without the cloud user having to maintain resources on the local computing device. It should be understood that the types of computing devices 54A-N shown in FIG. 2 are intended to be exemplary only, and that the computing node 10 and cloud computing environment 50 may communicate with any type of computerized device via any type of network and / or network-addressable connections (e.g., using a web browser).

[0037] Referring now to Figure 3, a set of functional abstraction layers provided by cloud computing environment 50 (Figure 2) is shown. It should be understood in advance that the components, layers, and functions shown in Figure 3 are intended to be merely illustrative, and that embodiments of the present invention are not limited thereto. As shown, the following layers and corresponding functions are provided:

[0038] The hardware and software layer 60 includes hardware and software components. Examples of hardware components include mainframes 61, Reduced Instruction Set Computer (RISC) architecture based servers 62, servers 63, blade servers 64, storage devices 65, and networks and networking components 66. In some embodiments, the software components include network application server software 67 and database software 68.

[0039] The virtualization layer 70 provides an abstraction layer at which the following examples of virtual entities may be provided: virtual servers 71, virtual storage 72, virtual networks including virtual private networks 73, virtual applications and operating systems 74, and virtual clients 75.

[0040] In one example, management layer 80 may provide the functions described below. Resource provisioning 81 provides dynamic procurement of computing and other resources utilized to execute tasks within the cloud computing environment. Metering and pricing 82 provides cost tracking as resources are utilized within the cloud computing environment and billing or invoicing for the consumption of these resources. In one example, these resources may include application software licenses. Security provides protection for data and other resources as well as identity verification for cloud consumers and tasks. User portal 83 provides consumers and system administrators with access to the cloud computing environment. Service level management 84 provides cloud computing resource allocation and management so that required service levels are met. Service level agreement (SLA) planning and fulfillment 85 provides pre-positioning and procurement of cloud computing resources where future requirements are anticipated according to SLAs.

[0041] The workload layer 90 provides examples of functionality for which a cloud computing environment may be utilized. Examples of workloads and functions that may be provided from this layer include mapping and navigation 91, software development and lifecycle management 92, virtual classroom instructional delivery 93, data analytics processing 94, transaction processing 95, and rolling update management 96.

[0042] An embodiment of the present invention may include the computer system / server 12 of Fig. 1, in which one or more of the program modules 42 are configured to perform (or cause the computer system / server 12 to perform) one or more functions of the rolling update management 96 of Fig. 3. For example, one or more of the program modules 42 may be configured to receive an indication of a new integrated flow document that updates a current integrated flow document of an integrated flow, determine a last switchable node included in both the current integrated flow document and the new integrated flow document, determine for each running instance of the integrated flow using the current integrated flow document whether the currently running node of the instance is less than or equal to the last switchable node, switch the instance to the new integrated flow document while the instance is still running in response to determining that the currently running node of the instance is less than or equal to the last switchable node, and wait for completion of the instance using the current integrated flow document in response to determining that the currently running node of the instance is greater than the last switchable node.

[0043] 4 illustrates a block diagram of an exemplary environment according to an aspect of the invention. In an embodiment, the environment includes a network 401 that provides communication between an integration server 405 and a plurality of user devices 410a, 410b, ..., 410n. The network 401 may include any one or more communication networks, such as a LAN, a WAN, and the Internet, and combinations thereof. In a cloud embodiment, the network 401 includes or is part of the cloud environment 50 of FIG. 2, the integration server 405 includes one or more cloud computing nodes 10 of FIG. 2, and each of the user devices 410a-n includes one of the local computing devices 54A-N of FIG. 2.

[0044] In an embodiment, the integration server 405 executes an integration flow editor 415, which may include one or more programs (e.g., program / utility 40 of FIG. 1). In one example, the integration server 405 is one or more computing devices, each including one or more elements of the computer system / server 12 of FIG. 1. In another example, the integration server 405 is one or more virtual machines (VMs) or containers running on one or more computing devices. In an embodiment, the integration server 405 includes a rolling update module 416, which may include one or more program modules (e.g., program module 42 of FIG. 1). In an embodiment, the rolling update module 416 is an extension of the integration runtime that handles the deployment of the integration flows. The integration server 405 may include additional or fewer programs / modules than those shown in FIG. 4. In an embodiment, separate programs / modules may be combined into a single program / module. Additionally or alternatively, a single program / module may be implemented as multiple programs / modules. Furthermore, the quantity of devices and / or networks in an environment is not limited to those shown in Figure 4. In practice, an environment may include additional devices and / or networks, fewer devices and / or networks, different devices and / or networks, or different configurations of devices and / or networks than those shown in Figure 4.

[0045] There may be any number “n” of user devices 410a-n. Each user device 410a-n may include a computing device such as a smartphone, a desktop computer, a laptop computer, a tablet computer, etc., and may include one or more elements of computer system / server 12 of FIG. 1. In an embodiment, each user device 410a-n includes an integrated client application 417 that communicates with integrated flow editor 415 to provide integrated flow editing capabilities to a user of user device 410a-n. In one example, integrated client application 417 includes a program (e.g., programs / utilities 40 of FIG. 1) specifically related to integrated flow editor 415, e.g., as part of the same software product. In another example, integrated client application 417 is a browser application that provides web-based access to integrated flow editor 415. In an embodiment, in both examples, the integration client application 417 and the integration flow editor 415 communicate with each other to provide a user with integration flow editing capabilities, including, but not limited to, creating, displaying, and modifying an integration flow as a graphical construct in a user interface (UI) on the user device 410a-n. For example, the integration flow editor 415 may utilize a JSON document to encode the structure of the integration flow in a JSON document and generate the integration flow as a graphical construct.

[0046] According to an aspect of the present invention, the integration server 405 provides a plurality of users of an enterprise with an integrated product for integrating interactions with the business applications 421, 422, 423. The business applications 421-423 may be provided as cloud services on external cloud service systems 431, 432, 433. Cloud services may be referred to as software as a service (SaaS). One or more of the business applications 421-423 may also be provided to the enterprise on a non-cloud-based computer system, locally or remotely. The systems 431-433 providing the business applications 421-423 are referred to as external systems because they are external to the integrated system. In the example shown in FIG. 4, the system 431 is associated with customer relationship management services, and the business application 421 provides customer service, marketing automation, analytics, and application development capabilities to the users. In the example shown in FIG. 4, the system 432 is associated with email services, and the business application 422 provides email capabilities to the users. 4, system 433 is associated with a business communications platform and business applications 423 provide business communications capabilities (other than email) to users. These examples of services and business applications are not limiting, and different types and / or numbers of services and / or business applications may be used in embodiments of the present invention.

[0047] The integration server 405 may be provided as a fully managed integration platform on the cloud from a cloud integration service. The integration server 405 may be deployed from packaged integration assets provided to enterprise clients by a toolkit. The integration server 405 may run its own container to ensure workload isolation and enable enterprise clients to package applications with all of their dependencies into a standard unit for software development that includes all the necessary components including runtime, system tools, and libraries that allow clients to deploy their integration solutions.

[0048] Enterprise clients may use the integration flow editor 415 to build integration flows between business applications 421-423, which may be exposed as application programming interface (API) operations. Integration flows provide automated movement of data between sources and targets.

[0049] In embodiments, the integrated flow editor 415 and / or the rolling update module 416 perform one or more of the processes described herein, including identifying a last switchable node by comparing the current flow document and the new flow document of the integrated flow, and using the last switchable node to switch existing running integrated flow instances, if applicable, e.g., for instances that are executing the current flow document and have not yet reached the last switchable node. For example, the integrated flow editor 415 and the rolling update module 416 may be configured to receive an indication of a new integrated flow document that updates a current integrated flow document for the integrated flow, determine a last switchable node contained in both the current integrated flow document and the new integrated flow document, determine for each execution instance of the integrated flow using the current integrated flow document whether the currently executing node of the instance is less than or equal to the last switchable node, in response to determining that the currently executing node of the instance is less than or equal to the last switchable node, switch the instance to the new integrated flow document while the instance is still executing, and in response to determining that the currently executing node of the instance is greater than the last switchable node, wait for completion of the instance using the current integrated flow document.

[0050] 5A and 5B show examples of visualizations of integration flow documents according to an embodiment of the present invention. FIG. 5A shows a visualization 500 of a current integration flow document for an integration flow, and FIG. 5B shows a visualization 505 of a new / updated integration flow document for the same integration flow. For example, the integration flow editor 415 may utilize a JSON document to encode the structure of the integration flow in a JSON document and generate the integration flow as a graphical construct, which may be used to create and display the visualization 500, 505 in the UI of the integration client application 417 on one of the user devices 410a-n.

[0051] In the example shown in FIG. 5A, the current integration flow document includes four nodes, including a first node 501 that retrieves leads using business application 421 of FIG. 4, a second node 502 that starts a loop to a process for each of the retrieved leads, a third node 503 that performs a task for one of the retrieved leads (e.g., gets a lead ID), and a fourth node 504 that creates an email (using the lead ID from step 503) using business application 422 of FIG. 4. In the example shown in FIG. 5A, nodes 501, 502, and 504 are top-level nodes, and any node not included in the top level is not a top-level node (e.g., node 503 is below the top level and therefore is not a top-level node). By executing an instance of this exemplary integration flow, the system retrieves some data using a first external application (e.g., business application 421), processes the retrieved data, and sends an email using a second external application (e.g., business application 422) based on the processing of the retrieved data.

[0052] In the example shown in FIG. 5B, the new integration flow document includes four nodes, including a first node 501 that retrieves leads using the business application 421 of FIG. 4, a second node 502 that starts a loop to each process of the retrieved leads, a third node 503 that performs a task for one of the retrieved leads (e.g., obtains a lead ID), and a fourth node 504' that creates an SMS message (using the lead ID from step 503) using the business application 423 of FIG. 4. In the example shown in FIG. 5A and FIG. 5B, the nodes 501, 502, and 503 match in both the current integration flow document and the new integration flow document. The difference between the flow documents is the fourth node, i.e., node 504 and node 504', respectively. In the example, the user created the new integration flow document by opening the current integration flow document in the UI of the integration client application 417, editing the integration flow document by changing node 504 to node 504', and providing input in the UI to update the integration flow document.

[0053] According to an aspect of the present invention, in response to receiving this input (or a similar input) to update the integrated flow document for the integrated flow, the rolling update module 416 identifies the last switchable node in the current integrated flow document and the new integrated flow document. In an embodiment, the last switchable node is the last matching node at the top level of both flow documents excluding asynchronous nodes. In an embodiment, an asynchronous node is a node that triggers another flow to execute asynchronously relative to the current integrated flow. In an embodiment, last in this context refers to the order of execution of the nodes defined by the integrated flow documents. In the example of FIG. 5A and FIG. 5B, the last matching node at the top level of both flow documents is node 502. In an embodiment, the rolling update module 416 identifies the last switchable node by analyzing and comparing data defining each of the nodes in the current integrated flow document and the new integrated flow document, which data is included in the respective integrated flow documents.

[0054] According to an aspect of the present invention, in response to identifying the last switchable node included in both the current integrated flow document and the new integrated flow document, the rolling update module 416 analyzes the currently executing instance of each integrated flow using the current integrated flow document to determine whether the execution instance is at a node in the integrated flow that is before or the same as the last switchable node. In an embodiment, the rolling update module 416 analyzes the runtime status of the execution instance to determine the currently executing node. The currently executing node is a node in the currently executing integrated flow document. In an embodiment, the rolling update module 416 compares the determined currently executing node to the last switchable node to determine whether the currently executing node is (i) before the last switchable node in the current integrated flow document, (ii) the same as the last switchable node in the current integrated flow document, or (iii) after the last switchable node in the current integrated flow document. In an embodiment, the terms before, the same, and after in this context refer to the order of execution of the nodes defined by the integrated flow document.

[0055] According to an aspect of the invention, in response to determining that the currently executing node is (i) before the last switchable node in the current integrated flow document or (ii) the same as the last switchable node in the current integrated flow document, the rolling update module 416 switches this execution instance of the integrated flow to use the new integrated flow document instead of the current integrated flow document. In one example of switching, the rolling update module 416 uses a migration process. In another example of switching, the rolling update module 416 retains all data associated with this execution instance (e.g., generated by the execution instance) and applies that data at the same node (e.g., the currently executing node) in the new integrated flow document. In an embodiment, in both examples, the execution instance then completes its execution from this node using the integrated flow defined by the new integrated flow document. In this manner, an embodiment of the invention competes for a rolling update for this particular instance by switching to the new integrated flow document without waiting for the instance to execute to completion using the current integrated flow document and without re-executing the entirety of the same instance using the new integrated flow document.

[0056] According to an aspect of the invention, in response to determining that the currently executing node is (iii) after the last switchable node in the current integrated flow document, the rolling update module 416 waits for completion of this execution instance of the integrated flow using the current integrated flow document. In this situation, the rolling update module 416 does not switch to a new integrated flow document because doing so would produce a runtime error or unintended results. In an embodiment, after completion of this execution instance of the integrated flow using the current integrated flow document, the rolling update module 416 then re-executes this instance using the new integrated flow document to complete the rolling update.

[0057] To illustrate aspects of the present invention, an exemplary use case will now be described with reference to Figures 5A and 5B. In this example, a user has an existing integration flow (represented by 500) that retrieves leads from business application 421 at node 501, then calls a customized API (Application Program Interface) for each record in turn at nodes 502 and 503. After all leads are processed at nodes 502 and 503, an email is sent using business application 422 at node 504. In this example, the user modifies the integration flow to change the last node from sending an email (node ​​504) to sending an SMS message (node ​​504'). In this example, the entire flow takes 5.5 minutes to complete. Continuing with this example, when the user provides input to the system to update the integration flow, the system determines that there are four currently running instances of the integration flow in the integration flow runtime. In this example, the four execution instances are: instance 1, which has a completed node 501 and has an estimated completion time of 5 minutes for the remainder of the flow; instance 2, which has a completed node 502 and has an estimated completion time of 10 seconds for the remainder of the flow; instance 3, which is the currently processing node 503 and has an estimated completion time of 4 minutes for the remainder of the flow; and instance 4, which is the currently processing node 504 and has an estimated completion time of 1 second for the remainder of the flow.

[0058] Continuing with this exemplary use case, in a conventional system not including aspects of the present invention, such a system would complete all four instances (instances 1-4) using the current integrated flow document, and then re-run all four instances using the new integrated flow document. This would take at least five minutes for all four instances to complete (due to instance 1 having an estimated completion time of five minutes) before re-running using the new integrated flow document, and another 5.5 minutes to complete the re-run using the new integrated flow document. In contrast, a system operating in accordance with aspects of the present invention would take at most a few seconds to transition instances 1-3 to the new integrated flow document, and then run those instances to completion using the new integrated flow document (each of which has the same estimated time to completion as before). In this example, the rolling update module 416 operates to compare the two integrated flow documents, determine that the last switchable node is node 502, check all four running instances (instances 1 to 4) in the integrated runtime, switch instances 1 to 3 to a new integrated flow document because the currently running nodes of instances 1 to 3 are less than or equal to the last switchable node, wait for instance 4 to complete using the current integrated flow document, and notify the user that the update to the new version of the integrated flow document is complete. In this way, the rolling update of instances 1 to 3 is completed faster than in the conventional system.

[0059] FIG. 6 illustrates an exemplary pseudocode 600 of a process according to an embodiment of the present invention. Line 1 of the pseudocode 600 corresponds to a first step of receiving an indication of a new integrated flow document that updates the current integrated flow document of the integrated flow. Lines 2-9 of the pseudocode 600 correspond to a second step of determining the last switchable node contained in both the current integrated flow document and the new integrated flow document. Lines 3-14 of the pseudocode 600 correspond to a third step of determining, for each execution instance of an integrated flow that uses the current integrated flow document, whether the currently executing node of the instance is less than or equal to the last switchable node, and determining whether to continue with the current integrated flow document or switch to a new integrated flow document. The rolling update module 416 may be programmed with code corresponding to the pseudocode 600 to perform one or more steps of the method of FIG. 7 described herein.

[0060] 7 shows a flow chart of an exemplary method according to an embodiment of the present invention. The steps of the method may be performed in the environment of FIG. 4 and will be described with reference to elements shown in FIG. 4, FIG. 5A, and FIG. 5B.

[0061] In step 705, the system receives an indication of a new integrated flow document that updates the current integrated flow document for the integrated flow. In an embodiment, as described in connection with FIGURE 4, the rolling update module 416 receives input from the UI, the input indicating a new integrated flow document (e.g., as shown at 504') that is an update to the current integrated flow document (e.g., as shown at 504).

[0062] In step 710, the system determines the last switchable node included in both the current integrated flow document and the new integrated flow document. In an embodiment, the rolling update module 416 determines the last switchable node by analyzing node data included in the current integrated flow document and the new integrated flow document, as described in connection with FIG.

[0063] In step 715, for each execution instance of an integration flow that uses the current integration flow document, the system determines whether the currently executing node of the instance is less than or equal to the last switchable node. In an embodiment, as described in connection with FIG. 4, the rolling update module 416 analyzes the integration runtime to determine the currently executing node for each instance and compares the currently executing node to the last switchable node.

[0064] In step 720, in response to determining that the currently executing node of the instance is less than or equal to the last switchable node, the system switches the instance to a new integrated flow document. In step 725, in response to determining that the currently executing node of the instance is greater than the last switchable node, the system waits for completion of the instance using the current integrated flow document.

[0065] In embodiments, a service provider may offer to perform the processes described herein. In this case, the service provider may create, maintain, deploy, support, etc., a computer infrastructure that performs the process steps of the present invention for one or more customers. These customers may be, for example, any business that uses technology. In return, the service provider may receive payments from the customer under a subscription and / or fee agreement, or the service provider may receive payments from the sale of content advertising to one or more third parties, or both.

[0066] In yet an additional embodiment, the present invention provides a computer-implemented method over a network. In this case, a computer infrastructure, such as computer system / server 12 (FIG. 1), may be provided, and one or more systems for performing the processes of the present invention may be acquired (e.g., created, purchased, used, modified, etc.) and deployed to the computer infrastructure. To this extent, deployment of a system may include one or more of: (1) installing program code from a computer-readable medium onto a computing device, such as computer system / server 12 (shown in FIG. 1); (2) adding one or more computing devices to the computer infrastructure; and (3) incorporating and / or modifying one or more existing systems of the computer infrastructure to enable the computer infrastructure to perform the processes of the present invention.

[0067] The description of various embodiments of the present invention is presented for illustrative purposes, but is not intended to be exhaustive or limited to the disclosed embodiments. Many modifications and variations will be apparent to those skilled in the art without departing from the scope and spirit of the described embodiments. The terms used in this specification are selected to best explain the principles of the embodiments, practical applications, or technical improvements beyond the technology found in the market, or to enable other skilled in the art to understand the embodiments disclosed herein.

Claims

1. A method executed by one or more processors, comprising: receiving an indication of a new integration flow document that updates a current integration flow document for the integration flow; determining a last switchable node included in both the current integration flow document and the new integration flow document; For each execution instance of the integration flow that uses the current integration flow document, determining whether a currently executing node of the instance is less than or equal to the last switchable node; in response to determining that the currently executing node of the instance is less than or equal to the last switchable node, switching the instance to the new integration flow document; in response to determining that the currently executing node of the instance exceeds the last switchable node, waiting for completion of the instance using the current integration flow document; A method comprising:

2. The method of claim 1 , further comprising executing a new instance of the integration flow using the new integration flow document in response to completion of the instance using the current integration flow document.

3. The method of claim 1 , wherein the determining the last switchable node comprises analyzing the current integrated flow document and the new integrated flow document.

4. 4. The method of claim 3, wherein said analyzing said current and new integration flow documents comprises analyzing top-level nodes within said current and new integration flow documents.

5. The method of claim 4 , wherein the analyzing ignores asynchronous nodes.

6. 4. The method of claim 3, wherein said analyzing said current integration flow document and said new integration flow document comprises analyzing only top-level nodes in said current integration flow document and said new integration flow document.

7. The method of claim 6 , wherein the analyzing ignores asynchronous nodes.

8. A computer program product causing one or more processors to carry out a method according to any one of claims 1 to 7.

9. A computer-readable storage medium having recorded thereon a computer program for causing one or more processors to execute the method according to any one of claims 1 to 7.

10. 1. A system comprising: a processor; a computer-readable memory; one or more computer-readable storage media; and program instructions collectively stored on the one or more computer-readable storage media, the program instructions comprising: receiving an indication of a new integration flow document that updates the current integration flow document of the integration flow; determining a last switchable node included in both the current integration flow document and the new integration flow document; For each execution instance of the integration flow that uses the current integration flow document, determining whether a currently executing node of the instance is less than or equal to the last switchable node; in response to determining that the currently executing node of the instance is less than or equal to the last switchable node, switching the instance to the new integration flow document; in response to determining that the currently executing node of the instance exceeds the last switchable node, waiting for completion of the instance using the current integration flow document; The system is viable for:

11. 11. The system of claim 10, wherein the program instructions are executable to execute a new instance of the integrated flow using the new integrated flow document in response to completion of the instance using the current integrated flow document.

12. The system of claim 10 , wherein the determining the last switchable node comprises analyzing the current integration flow document and the new integration flow document.

13. 13. The system of claim 12, wherein said analyzing the current integration flow document and the new integration flow document comprises analyzing top-level nodes within the current integration flow document and the new integration flow document.

14. The system of claim 13 , wherein the analyzing ignores asynchronous nodes.

15. 13. The system of claim 12, wherein said analyzing said current integration flow document and said new integration flow document comprises analyzing only top-level nodes in said current integration flow document and said new integration flow document.