System and method for managing updates of workpieces associated with applications

Abstract

A system (200) and method for updating a workpiece in a live production environment of an application is disclosed. In one embodiment, a system (200) includes a database server (216) and an application server (100, 202), where a workpiece definition of an application hosted update is stored on the database server (216). The application server (100, 202) retrieves, by the user device (212), the updated workpiece definition from the database server (216) when notified of the user of the update of the workpiece definition. The application server (100, 202) further presents the updated workpiece based on the updated workpiece definition in the live production environment of the application in real time on the user device (212).

Description

Technical Field

[0001] The present invention relates to application management, and more particularly, to a method and system for updating artifacts associated with an application in a live production environment. Background Art

[0002] A key feature of any "low-code platform" that enables users to create and modify declarative artifacts or user interface (UI) view content through simple drag-and-drop operations is the ability to instantly preview newly created or modified artifacts in a live production environment. Although users can modify artifacts locally, instantly previewing these changes in a live production environment presents a huge technical challenge. Recompiling and redeploying the entire application along with the modified artifacts is not feasible because it requires a lot of time and downtime (redeployment), which affects all other users.

[0003] There are two major technical hurdles involved in having artifacts rendered instantly into live production applications: dynamically creating artifacts from code in string format on the client side (browser) and replacing existing artifacts with newly created artifacts in live production applications. These challenges have been addressed in web development environments where developer code changes are reflected in the application after a delay using standard Hot Module Replacement (HMR) techniques and a development server that tracks changes and triggers incremental in-memory builds of the application. However, the problem of replacing artifacts in live production environments of web applications remains unsolved. Therefore, a mechanism to overcome these problems is needed.

[0004] Typically, there are two major technical hurdles involved in bringing artifacts to live production applications instantly: dynamically creating artifacts from code in string format on the client side (browser), and replacing existing artifacts with newly created artifacts in live production applications. In a web development environment, by using standard HMR technology and a development server that tracks changes and triggers incremental in-memory builds of the application, the developer's code changes are reflected in the application after a delay.

[0005] However, HMR technology is not suitable for presenting artifacts into live production applications because it requires a continuously running development server to preview changes, which is not ideal for a multi-user environment. In addition, the development server requires a lot of resources when running. In addition, these changes are not reflected in the live production application immediately, and even a minor change takes several seconds to be reflected in a complex application. The development server also relies on web sockets to trigger an application reload on the client, which adds complexity. In addition, a failure of the development server requires user notification and restart, which is very time-consuming. Therefore, a method and system for updating artifacts in an application in a live production environment is needed. Summary of the invention

[0006] A system and method for updating artifacts associated with a web application in a live production environment is disclosed.

[0007] In one embodiment, a system for updating artifacts associated with a web application in a live production environment includes a database server and an application server. The database server is configured to store one or more versions of one or more artifacts associated with the application. The application server hosting the application is configured to provide a code editor interface on a user device communicatively coupled to the application server, for enabling a user to update at least one artifact definition associated with at least one artifact associated with the application. In one embodiment, the user device is configured to enable a user to access the code editor interface to update at least one artifact definition associated with the application, wherein the updated artifact definition is stored in the database server; and an event notification is published to the application server when a user updates the artifact definition. In one embodiment, the code editor interface enables a user to update the artifact definition using a low-code programming language. In one embodiment, user updates are detected based on local storage of updated artifact definitions in the user device. In another embodiment, a wrapper component associated with the artifact is subscribed to event notifications.

[0008] The application server is also configured to retrieve the updated artifact definition from the database server by the user device when the user is notified of the update to the artifact definition. In one embodiment, when the updated artifact definition is retrieved from the database server when the user is notified of the update to the artifact definition, the application server is configured to use a graph query language to query a graph database of the database server in which the updated artifact definition is stored; and retrieve the updated artifact definition from the database server based on the query of the graph database.

[0009] The application server is further configured to compile the updated artifact definition to generate a corresponding updated artifact suitable for presentation in a live production environment of the application. In one embodiment, when presenting the updated artifact in real time in the live production environment of the application on a user device, the application server is configured to replace a current version of the artifact stored on the application server (100, 202) with the updated artifact; and update a user interface of the user device to reflect the updated artifact stored on the application server within the application. The application server is further configured to present the updated artifact in the live production environment of the application in real time on the user device.

[0010] In another embodiment of the present invention, a method for updating an artifact in a live production environment of an application includes providing a code editor interface by a processing unit on a user device, for enabling a user to update at least one artifact definition associated with at least one artifact associated with the application, wherein the updated artifact definition is stored on a database server. In one embodiment, the user device is configured to enable a user to access the code editor interface to update at least one artifact definition associated with the application, wherein the updated artifact definition is stored in the database server; and to publish an event notification to the application server when a user update to the artifact definition is detected. In one embodiment, the code editor interface enables a user to update an artifact definition using a low-code programming language. In one embodiment, user updates are detected based on local storage of updated artifact definitions in the user device. In another embodiment, a wrapper component associated with the artifact is subscribed to event notifications.

[0011] The method further includes retrieving, by the user device, the updated artifact definition from the database server upon being notified of the user's update to the artifact definition. In one embodiment, retrieving the updated artifact definition from the database server upon being notified of the user's update to the artifact definition includes using a graph query language to query a graph database of the database server in which the updated artifact definition is stored; and retrieving the updated artifact definition from the database server based on the query of the graph database.

[0012] The method also includes compiling the updated artifact definition to generate a corresponding updated artifact suitable for presentation in a live production environment of the application. The method also includes presenting the updated artifact in the live production environment of the application in real time on the user device. In one embodiment, presenting the updated artifact in the live production environment of the application in real time on the user device includes replacing a current version of the artifact stored on the application server with the updated artifact; and updating a user interface of the user device to reflect the updated artifact stored on the application server within the application. BRIEF DESCRIPTION OF THE DRAWINGS

[0013] Figure 1 is a block diagram of an exemplary application server 100 according to one embodiment of the present invention;

[0014] Figure 2 is a schematic diagram of a system 200 for managing updates of artifacts associated with an application in a live production environment according to another embodiment of the present invention;

[0015] Figure 3 is a process flow diagram 300 depicting an exemplary method of managing updates of artifacts associated with an application in a live production environment, according to one embodiment of the present invention; and

[0016] Figure 4is a timing diagram according to an embodiment of the present invention. DETAILED DESCRIPTION

[0017] The present disclosure relates to a method and system for managing updates of artifacts associated with applications in a live production environment. Various embodiments are described with reference to the accompanying drawings, wherein the same reference numerals are used with respect to the accompanying drawings. The same reference numerals are always used to refer to the same elements. In the following description, many specific details are set forth in order to provide a thorough understanding of the embodiments. These specific details are not required to practice the embodiments. In other cases, in order to avoid unnecessarily obscuring the embodiments, well-known materials or methods are not described in detail. Although the present disclosure is susceptible to various modifications and alternative forms, its specific embodiments are shown in the accompanying drawings by way of example and will be described in detail herein. It is not intended to limit the present disclosure to the specific form disclosed. On the contrary, the present disclosure will cover all modifications, equivalents, and substitutes that fall within the spirit and scope of the present disclosure.

[0018] Figure 1 1 is a block diagram of an exemplary application server 100 for managing updates of artifacts associated with an application in a live production environment according to one embodiment of the present invention. The live production environment refers to a live version of an application that a user can interact with. The user can access the live production environment through a user device that is communicatively coupled to the application server 100 via a network, as described later with reference to FIG. Figure 2 Explained.

[0019] The application server 100 may be a personal computer, a workstation, a laptop computer, a tablet computer, etc. Figure 1 In the embodiment, the application server 100 includes a processing unit 102 , a memory unit 104 , a storage unit 106 , a bus 108 , an input unit 110 , and a display unit 112 .

[0020] As used herein, processing unit 102 represents any type of computing circuit, such as, but not limited to, a microprocessor, a microcontroller, a complex instruction set computing microprocessor, a reduced instruction set computing microprocessor, a very long instruction word microprocessor, an explicitly parallel instruction computing microprocessor, a graphics processor, a digital signal processor, or any other type of processing circuit. Processing unit 102 may also include an embedded controller, such as a general or programmable logic device or array, an application specific integrated circuit, a single chip computer, etc.

[0021] The memory unit 104 may be a non-transitory volatile memory and a non-volatile memory. The memory unit 104 may be coupled for communication with the processing unit 102, such as a computer-readable storage medium. The processing unit 102 may execute instructions and / or codes stored in the memory unit 104. Various computer-readable instructions may be stored in the memory unit 104 and may be accessed from the memory unit 104. The memory unit 104 may include any suitable element for storing data and machine-readable instructions, such as a read-only memory, a random access memory, an erasable programmable read-only memory, an electrically erasable programmable read-only memory, a hard disk drive, a removable media drive for processing optical disks, digital video disks, magnetic disks, tape cassettes, memory cards, etc.

[0022] In the present embodiment, memory unit 104 comprises a live exchange module 114 stored in any of the above-mentioned storage media in the form of machine-readable instructions, and can communicate with processing unit 102 and be executed by processing unit 102. Live exchange module 114 enables processing unit 102 to manage the update of the artifact associated with application in live production environment. Specifically, live exchange module 114 manages the update of the artifact associated with application by providing a code editor interface on user equipment by processing unit, and this code editor interface is used to enable the user to update at least one artifact definition associated with at least one artifact associated with application. In addition, when being notified of the update of the artifact definition by the user, the updated artifact definition is retrieved from the database server by the user equipment. The updated artifact definition is further compiled to generate the corresponding updated artifact (e.g., web component) suitable for presenting in the live production environment of application. The updated artifact is further presented in the live production environment of application on user equipment in real time.

[0023] The storage unit 106 may be a non-transitory storage medium storing a database 116. The database 116 stores application data, such as artifacts, wrapper components corresponding to the artifacts, etc., associated with the application. The input unit 110 may include an input device, such as a keyboard, a touch-sensitive display, a camera (e.g., a camera that receives gesture-based input), etc. This enables an operator to provide input associated with the management application. The display unit 112 may be a device with a user interface for displaying options associated with the application data associated with the management application. The bus 108 serves as an interconnection between the processing unit 102, the memory unit 104, the storage unit 106, the input unit 110, and the display unit 112.

[0024] Those of ordinary skill in the art will understand that Figure 1The hardware components depicted in the can vary for a particular implementation. For example, other peripherals, such as optical drives, local area network (LAN) / wide area network (WAN) / wireless (e.g., Wi-Fi) adapters, graphics adapters, disk controllers, input / output (I / O) adapters, etc., can be used in addition to or in place of the hardware depicted. The depicted examples are provided for purposes of explanation only and are not meant to imply architectural limitations with respect to the present disclosure.

[0025] The application server 100 according to an embodiment of the present disclosure includes an operating system that uses a graphical user interface. The operating system allows multiple display windows to be presented simultaneously in the graphical user interface, each display window providing an interface to a different application or to a different instance of the same application. A user can manipulate a cursor in the graphical user interface through a pointing device. The position of the cursor can be changed and / or an event such as clicking a mouse button can be generated to initiate a response.

[0026] Figure 2 2 is a schematic diagram of a system 200 for managing updates of artifacts associated with an application in a live production environment according to another embodiment of the present invention. In particular, the system 200 includes an application server 202 (similar to the application server 100) coupled to a plurality of user devices 212A-N via a network. Each user device 212A-N is connected to the application server 202 via a network 204 (e.g., a local area network (LAN), a wide area network (WAN), Wi-Fi, etc.).

[0027] The application server 202 includes a live exchange module 114 and a database 116. The application server 202 may also include a processing unit (not shown), a memory unit (not shown), and a storage unit (not shown). The live exchange module 114 may be stored in the memory unit in the form of machine-readable instructions and may be executed by the processing unit. The database 116 may be stored in the storage unit. The application server 202 may also include a communication interface for enabling communication with user devices 212A-N via the network 204. The system 200 also includes a database server 216 communicatively coupled to the application server 202 and the user devices 212A-N. The database server 216 is configured to store one or more versions of one or more artifacts associated with the application. In one embodiment, the database server 216 is a (Declarative Artifact Service) DARSI server.

[0028] Application server 202 includes cloud communication interface 206, cloud computing hardware and OS 208, cloud computing platform 210, live exchange module 114, and database 116. Cloud communication interface 206 enables communication between cloud computing platform 210 and user devices 212A-N such as smartphones, tablets, computers, etc. via network 204.

[0029] The cloud computing hardware and OS 208 may include one or more servers on which an operating system (OS) is installed, and includes one or more processing units, one or more storage devices for storing data, and other peripheral devices required to provide cloud computing functions. The cloud computing platform 210 is a platform that implements functions such as data storage, data analysis, data visualization, and data communication on the cloud hardware and OS 208 via APIs and algorithms; and uses cloud-based applications to deliver the above cloud services. Figure 1 As described, the cloud computing platform 210 employs the live exchange module 114 to manage updates of artifacts associated with the application in a live production environment. The cloud computing platform 210 also includes a database 116 for storing application data associated with the application, such as user sessions, user session data, and the like.

[0030] User devices 212A-N (hereinafter collectively referred to as user devices 212) include user interfaces 214A-N (hereinafter collectively referred to as user interfaces 214), which provide a code editor interface in which a user updates one or more artifact definitions associated with an application and a presentation of a live production environment associated with the application. Each user device 212A-N can be equipped with a communication interface for interfacing with application server 202. Users of user devices 212A-N can access applications and code editor interfaces hosted on application server 202 via user interfaces 214A-N. In one example, the application is accessible via a first browser tab, and the code editor interface is accessible via a second browser tab.

[0031] Figure 3 is a process flow diagram 300 depicting an exemplary method of managing updates of artifacts associated with an application in a live production environment, according to one embodiment of the present invention. It should be understood that the systems and methods described herein may be implemented in various forms of hardware, software, firmware, special purpose processing units, or combinations thereof. One or more of the present embodiments may take the form of a computer program product including program modules accessible from a computer usable or computer readable medium storing program code for use by or in conjunction with one or more computers, processing units, or instruction execution systems.

[0032] For the purposes of this specification, a computer-usable or computer-readable medium may be any data processing system that can contain, store, communicate, propagate or transport a program for use by or in connection with an instruction execution system, apparatus or device. The medium may be an electronic, magnetic, optical, electromagnetic, infrared or semiconductor system (or system or device) or propagation medium, which itself as a signal carrier is not included in the definition of a physical computer-readable medium, which includes semiconductor or solid-state memory, magnetic tape, removable computer disk, random access memory (RAM), read-only memory (ROM), hard disk, optical disk such as compact disk read-only memory (CD-ROM), compact disk read / write and digital versatile disk (DVD) or any combination thereof. As known to those skilled in the art, the processing units and program code used to implement each aspect of the technology may be centralized or distributed (or a combination thereof)

[0033] When an application is developed by a developer and deployed for the first time, each artifact is wrapped by a wrapper component. The wrapper component is subscribed to event notifications indicating that the user has made updates to the corresponding artifact.

[0034] The method may begin with a user requesting access to a live production environment of an application in a first browser tab and requesting access to a code editor interface in a second browser tab. The first browser tab and the second browser tab may be opened by a single user on a single user device, or by one or more users on different user devices. It must be understood that any number of first browser tabs and second browser tabs may remain open on one or more user devices at the same time. For ease of understanding, in conjunction with Figure 2 and Figure 4 In this embodiment, the functions of the live exchange module 114 also include a UI construction module 402, an orchestrator service 406, one or more wrapper components 408, and an artifact compilation module 410, which enable the live exchange module 114 to perform the previously described Figure 1 The application is referred to as application 404 hereinafter.

[0035] At step 302 , a code editor interface is provided on a user device 212 communicatively coupled to an application server 202 for enabling a user to update at least one artifact definition associated with at least one artifact associated with an application 404 .

[0036] The user device enables a user to access a code editor interface to update at least one artifact definition associated with application 404, wherein the updated artifact definition is stored in database server 216. In addition, the user device is configured to publish an event notification to application server 202 when a user update to an artifact definition is detected. In one embodiment, the user update is detected based on a local storage of the updated artifact definition in the user device. Figure 4 , the UI building module 402 provides the user with access to a code editor on the user device 212 as part of the user interface 214. In one embodiment, the code editor interface enables the user to update the artifact definition using a low-code programming language such as a graphical programming language. The user can provide updates in the form of strings in JSON or HTML format, for example. When the user updates the artifact definition, he / she / they can save the update by selecting a save option provided on the code editor interface. As the updated artifact definition is saved in the user-defined local storage, the UI building module 402 notifies the application 404 of the updated artifact definition, as shown in line 2 in Figure 400. More specifically, the application 404 is notified by publishing an event notification to the corresponding wrapper component 408 of the corresponding artifact. The UI building module 402 saves the updated artifact definition on the database server 216, as shown in line 2. The database server 216 stores the updated artifact definition in a hierarchical manner in a graphical database. Advantageously, the graphical database helps maintain the chronological order or version history of the updated artifact definition.

[0037] At step 304, upon being notified of updates to one or more artifact definitions by the user, the updated artifact definitions are retrieved from database server 216 by the user device. Specifically, application 404 calls orchestrator service 406, such as Figure 4 As shown in line 3 in , the user update is transmitted to the wrapper component 408 of the corresponding artifact. Figure 4 As shown in line 5, the orchestrator service 406 transmits updates to artifacts to the user by first using a graph query language to retrieve a list of identifiers associated with updated artifact definitions stored in the DARSI server. Figure 4 As shown in line 6, orchestrator service 406 also notifies wrapper component 408 by issuing an event notification to wrapper component 408, which is associated with the artifact associated with each updated artifact definition retrieved from the DARSI server. As shown in line 7, wrapper component 408 also obtains the updated artifact definition from the DARSI server based on the identifier of the artifact.

[0038] In step 306, the updated artifact definition is compiled to generate a corresponding updated artifact suitable for presentation in the live production environment of application 404. Specifically, as shown in line 8, wrapper component 408 passes the updated artifact definition to artifact compilation module 410. The updated artifact definition is, for example, in the form of a string based on JSON and / or HTML format. In one embodiment, artifact compilation module 410 is a reflection component that converts the string-based updated artifact definition into a format suitable for presentation on a browser (i.e., an updated artifact). As shown in line 9, artifact compilation module 410 also returns the updated artifact to wrapper component 408.

[0039] At step 308, the updated artifact is presented in real time in the live production environment of application 404 on the user device. In one embodiment, presenting the updated artifact definition in real time in the live production environment of application 404 includes replacing the existing artifact stored on application server 202 with the updated artifact generated at step 306, such as Figure 4 . More specifically, the wrapper component 408 of the current version of the artifact stored on the application server 202 replaces the current version artifact with the updated artifact. In addition, the user interface of the user device 212 is updated based on the updated artifact stored on the application server 202.

[0040] Advantageously, the present invention enables users of an application to make changes to an application's artifacts / web components in real-time from a browser, where the changes are presented in a live production environment of the application that can be viewed in real-time from another browser. Furthermore, the present invention facilitates the use of low-code programming languages ​​to make changes to artifact definitions. Furthermore, the present invention eliminates the need for a development server and / or web sockets, which are necessary to trigger an application reload on the client side.

[0041] Although the present disclosure has been described in detail with reference to certain embodiments, the present disclosure is not limited to these embodiments.In view of the present disclosure, many modifications and variations will be presented to those skilled in the art without departing from the scope of the various embodiments of the present disclosure as described herein.

[0042] Reference Mark List

[0043] 100 application server, configured to manage updates of artifacts associated with an application in a live production environment

[0044] 102 processing units

[0045] 104 memory cells

[0046] 106 storage units

[0047] 108 bus

[0048] 110 Input Units

[0049] 112 display units

[0050] 114 live switching module

[0051] 116 Database

[0052] 200 System for managing updates of artifacts associated with an application in a live production environment

[0053] 202 Application Server

[0054] 204 Network

[0055] 206 Cloud Communication Interface

[0056] 208 Cloud computing hardware and operating system

[0057] 210 Cloud Computing Platform

[0058] 212A-N User Equipment

[0059] 214A-N User Interface

[0060] 216 Database Server

[0061] 402 UI Building Blocks

[0062] 404 Application

[0063] 406 Orchestrator Service

[0064] 408 Wrapper Component

[0065] 410 artifact compilation module

Claims

1. A system (200) for enabling updating of artifacts in a live production environment of an application (404), the system (200) comprising: - a database server (216) configured to store one or more versions of one or more artifacts associated with an application (404); - an application server (100, 202), communicatively coupled to a database server (216) and in which an application (404) is hosted, configured to: providing a code editor interface on a user device (212) communicatively coupled to an application server (100, 202) for enabling a user to update at least one artifact definition associated with at least one artifact associated with an application (404), wherein the updated artifact definition is stored on a database server (216); · upon being notified of a user update to an artifact definition, retrieving, by the user device (212), the updated artifact definition from the database server (216); · compiling the updated artifact definitions to generate corresponding updated artifacts suitable for presentation in a live production environment of the application (404); and • Rendering updated artifacts in real time in a live production environment of the application (404) on the user device (212).

2. The system of claim 1, wherein the user equipment (212) is configured to: enabling a user to access a code editor interface to update at least one artifact definition associated with an application (404), wherein the updated artifact definition is stored in a database server (216); and When a user updates an artifact definition, an event notification is published to the application server (100, 202).

3. A system according to claim 1, wherein the code editor interface enables a user to update artifact definitions using a low-code programming language.

4. The system according to claim 2, in, User updates are detected based on a local storage of updated artifact definitions in a user device (212).

5. The system according to claim 4, in, A wrapper component (408) associated with the artifact is subscribed to the event notification.

6. The system of claim 1 , wherein upon being notified of a user update to an artifact definition, the application server ( 100 , 202 ) is configured to: · using a graph query language to query a graph database of a database server (216) in which updated artifact definitions are stored; and Retrieving updated artifact definitions from a database server (216) based on a query of the graph database.

7. The system of claim 1, wherein when presenting updated artifacts in real time in a live production environment of an application (404) on a user device (212), the application server (100, 202) is configured to: replacing a current version of an artifact stored on an application server (100, 202) with an updated artifact; and • Updating the user interface (214) of the user device (212) to reflect the updated artifacts stored on the application server (100, 202) within the application (404).

8. A method (300) for updating an artifact in a live production environment of an application (404), the method comprising: providing, by the processing unit (102), a code editor interface on the user device (212) for enabling a user to update at least one artifact definition associated with at least one artifact associated with the application (404), wherein the updated artifact definition is stored on the database server (216); · upon being notified of a user update to an artifact definition, retrieving, by the user device (212), the updated artifact definition from the database server (216); · compiling the updated artifact definitions to generate corresponding updated artifacts suitable for presentation in a live production environment of the application (404); and - Presenting updated artifacts in a live production environment of the application (404) in real time on the user device (212).

9. The method according to claim 8, wherein the user equipment (212) is configured to: enabling a user to access a code editor interface to update at least one artifact definition associated with an application (404), wherein the updated artifact definition is stored in a database server (216); and When a user updates an artifact definition, an event notification is published to the application server (100, 202).

10. The method according to claim 8, in, The code editor interface enables users to update artifact definitions using a low-code programming language.

11. The method of claim 9, wherein user updates are detected based on local storage of updated artifact definitions in the user device (212).

12. The method of claim 11, wherein a wrapper component (408) associated with the artifact is subscribed to the event notification.

13. The method of claim 11, wherein retrieving updated artifact definitions from a database server (216) upon being notified of updates to the artifact definitions by a user comprises: · using a graph query language to query a graph database of a database server (216) in which updated artifact definitions are stored; and Retrieving updated artifact definitions from a database server (216) based on a query of the graph database.

14. The method of claim 8, wherein presenting updated artifacts in a live production environment of an application (404) in real time on a user device (212) comprises: replacing a current version of an artifact stored on an application server (100, 202) with an updated artifact; and • Updating the user interface (214) of the user device (212) to reflect within the application the updated artifacts stored on the application server (100, 202).

Images