Systems and methods for independent application design and deployment to a platform host

Abstract

Systems and methods are provided for creating, sharing, and integrating vendor applications. The method for developing and deploying an application is for a host platform to communicate with a framework package corresponding to an application framework, the framework package comprising software abstractions for providing general functionality in the development of vendor applications, and for the host platform to receive an application package corresponding to the vendor application, the application package comprising a plurality of metadata files, control method descriptions, and content files, and to integrate the application package to generate an integration of the vendor application based on the application framework.

Description

Technical Field

[0001] Cross - reference to Related Applications This application claims the priority of U.S. Patent Application No. 17 / 824,563, filed on May 25, 2022, the entire content of which is incorporated herein by reference.

[0002] The present invention relates to methods and standards for application packaging and integration, and more particularly, to application resource integration and deployment within a cloud.

Background Art

[0003] Computer systems have several issues regarding the development and installation of updates and patches for hosted web applications. Software - as - a - Service (SaaS) web applications are integrated into a system by a vendor using special delivery and installation packages. However, when a vendor needs to integrate / deploy its own applications within a cloud, the vendor has to repeat all integration operations multiple times for each host or hosting platform. Hosts and hosting platforms have applications that control the host or hosting platform. These applications are very difficult and costly to integrate with external (third - party) applications or web services.

[0004] Currently, the integration of applications into hosts and hosting platforms is performed by a controller. In the case of a cloud system, the cloud (or cloud server) is a combination of the host provider's software and hardware that provides the functionality of external applications in its client accounts.

[0005] In the field of cloud computing platforms, in parallel with the operation of the platform format, there are inefficiencies in the creation and deployment of client applications. For example, cloud computing platforms may encounter problems regarding the development and / or deployment of effective applications as hosts. Software as a Service (SaaS) web applications are generally developed in strong association with a platform host. All processes regarding new applications in development are strongly tied to the deployment of the platform host stack. Such a method has brought about inconvenience and loss of time, along with the background regarding the need to solve application problems at the core level.

[0006] A major disadvantage of the prior art is that during the creation and deployment of a new application, the platform host is required to communicate with a package having an indeterminate test environment inside the package during application development. Furthermore, the prior art requires excessive deployment time and a continuous Internet connection is required during application creation. Therefore, in this technical field, there is a desire for an efficient and inexpensive method for the application itself, application updates, and patch integration into the cloud platform host.

Summary of the Invention

[0007] Embodiments described herein provide for the design and deployment of independent applications to a platform host.

[0008] According to an embodiment of the present invention, a system and method for independent application design and deployment (IADD) to a platform host are provided to improve the application development process. The IADD solution effectively addresses the above technical problems, provides an independent application creation process and efficient application deployment to the platform host, and minimizes downtime at the core level of the platform host.

[0009] An IADD system and method for creating, sharing, and integrating vendor applications are provided. The system and method for application development and deployment involve the host platform communicating with a framework package corresponding to the application framework, where the framework package includes software abstractions for providing general functionality in the development of vendor applications, and the host platform receiving an application package corresponding to the vendor application, where the application package includes a plurality of metadata files, control method descriptions, and content files, and integrating the application package to generate an integration of the vendor application based on the application framework.

[0010] According to some embodiments, the IADD system and method differ from prior art in that a strong connection between an application and a host is severed during application development. The host "adopts" an already operational application that can be easily deployed. For such scenarios, even an always-on Internet connection during application development is not required. Conventional systems and methods may require several hours just to start the process of developing a new application due to host operation. According to an exemplary embodiment, the platform host is separated from the application development process that requires much effort. A new application can be created and tested before host deployment, enabling the generation of highly reliable applications at the time of deployment. Furthermore, the need to repair host core-level failures during application development is eliminated, solving additional problems in the prior art. The IADD system and method enable efficient application creation in terms of speed, reliability, and resource savings.

Brief Description of Drawings

[0011]

Figure 1

Figure 2

Figure 3

Figure 4

Figure 5

Figure 6

Figure 7

[0012] For the purpose of promoting an understanding of the principles of the present disclosure, reference is now made to the embodiments illustrated in the drawings and specific language is used to describe them. It will be understood, however, that no limitation of the scope of the present disclosure is thereby intended.

[0013] Embodiments may be implemented in hardware, firmware, software, or any combination thereof. Embodiments may also be implemented as instructions stored on a machine-readable medium, which may be read and executed by one or more processors. A machine-readable medium may include any mechanism for storing or transmitting information in a form readable by a machine (e.g., a computing device). For example, a machine-readable medium may include read-only memory (ROM), random access memory (RAM), magnetic disk storage media, optical storage media, flash memory devices, and others. Further, firmware, software, routines, instructions may be described herein as performing certain actions. However, such descriptions are for convenience only and such actions are actually obtained by a computing device, processor, controller, or other device executing the firmware, software, routines, instructions, etc.

[0014] The operations shown in the illustrative method are not exhaustive, and it should be understood that other operations may be performed before, after, or in between any of the illustrated operations. In some embodiments of the present disclosure, the operations can be performed in a different order and / or vary.

[0015] Application Creation An IADD system and method for addressing the above technical problems are provided. The IADD system and method are local and provide a specific layer for vendor applications independent of the platform host. This enables application development even with a non-persistent Internet connection mode.

[0016] FIG. 1 illustrates an IADD system according to some embodiments. As shown in FIG. 1, the IADD system 100 provides an ecosystem for various projects that can be separated, for example, based on functionality, responsiveness, and teams. The IADD system 100 includes a development platform 110, a bundle 120, and a platform host (hosting cloud) 130.

[0017] As depicted, application creation on the development platform 110 is separate from the platform host 130 itself. According to an exemplary embodiment, one or more frameworks associate the applications of the development platform 110 with the (production) applications of the platform host (130). That is, the frameworks interconnect the respective applications. The frameworks are equipped with the basic templates necessary for application and testing on the development platform 110. The frameworks further comprise specific means necessary for integrating and deploying the applications in the platform host (hosting cloud) 130.

[0018] In an exemplary embodiment, the development platform 110 includes an application 102 and a framework 104. The application 102 can include code written by a developer. The framework 104 (e.g., VUE) can provide a software abstraction for providing general functionality that can be selectively adapted and implemented by the application 102, thereby providing software for specific purposes such as building a user interface. The framework 104 can provide this abstraction built on top of standard programming languages (e.g., HTML, CSS, JavaScript, etc.), and provides a declarative and component-based programming model that enables efficient development of software for specific purposes such as user interfaces, regardless of simplicity or complexity.

[0019] When IADD100 is configured to deploy the application 102, the development platform 110 can generate an application bundle 120 that implements the application 102 and the framework 104 as stand-alone, all within one container. According to an exemplary embodiment, a developer (e.g., a cloud application vendor, etc.) can bundle the application 102 and the framework 104 according to the APS. The form of the bundle depends on the receiving side, e.g., the platform host 130. If the receiving side is a standard Windows desktop, the software can be packaged using a standard installer, and the file has an extension of *.exe or *.msi. The installer includes unpacking rules including user dialogs, writing to the registry, checking for updates, etc. In the case of APS, the bundle can have an extension of app.zip and includes metadata, scripts, and the software code itself.

[0020] The exemplary development application 102 is transferred to the platform host 130 via the application bundle 120. The application 132 is generated inside the platform host 130. The platform host 130 comprises the application 132 and the framework 134, the adapter 136 and the application packaging standard (APS) module 138.

[0021] The adapter 136 connects the framework 104 / 134 to the platform host at runtime and renders the interpreted application 132 and the framework 134 as a web application that provides an interface to the client via the APS module 138.

[0022] The APS module 138, also referred to as a controller or an application packaging controller, is a runtime module configured to distribute the application 132 to the client 140. As shown in FIG. 1, one application can be delivered to one client or multiple clients. APS is a specification that defines the life cycle of the application 132 in the cloud. The life cycle of an application includes packaging, delivery to the cloud, integration (and unpacking / deployment) into the cloud, distribution to the client, licensing, functionality, updates, and deletion. APS can include an application programming interface (API) for accessing the APS functionality from program code or by means of http / https requests. APS provides for the efficient integration of SaaS web applications, such as the application 132, into the cloud. According to an exemplary embodiment, for the application to function according to APS, the APS module 138 (i.e., the controller) is integrated into the software hosting platform of the hosting cloud (platform host 140).

[0023] The APS module 138 functions as a connector for controlling the application 132. The APS module 138 receives application control requests, and the APS module 138 distributes the requests to the appropriate scripts of the application APS package 120. The response of the application 132 to the client 140 (outside the cloud 100) is also processed by the controller module 110 and provided to the client 125. To integrate the applications, the APS module 138 applies the framework 134 and can verify each of the format and structure of the application package (e.g., bundle 120), the metadata of the metadata file, and at least one application programming interface (API) function of the vendor application.

[0024] Figure 2 illustrates the communication between the application and the platform host. As shown in Figure 2, the system 200 includes a local development application 210 and a platform host 230. The local development application 210 includes an adaptive layout framework 220 (skeleton) and a preset module 222, which can include a high-speed development system preset. The preset can include, for example, one or more plugins with several option configurations. For example, the preset can include plugins / options bundled with other configuration options, such that selecting the preset would mean selecting all of those options.

[0025] For example, the default preset can include plugins (such as Babel, Typescript, Vuex, ESLint, Unit-Jest, etc.) as options / features. When a developer selects the default preset, a local development application 210 can be created, and utility modules can be installed during project creation. Additionally, or alternatively, the developer can further manually select the desired options and plugins. Presets make it possible to speed up project creation. The preset module 222 operates by communicating with the adaptive layout framework 220 (skeleton).

[0026] As described above, the environment prepares the framework as an auxiliary layer. The framework has everything required for a new application detached from the production stack, which can also be further used for testing. As will be described in more detail below, the application can be compiled into a bundle file that is dynamically communicated to the platform host, enabling optimization of communication and implementation to the platform host. The bundle file can be prepared as a set of asynchronous web components that can be communicated part by part when opening a new page representation of the application.

[0027] According to some embodiments, the platform host 230 can include a user experience (UX) framework module 240, a UX user interface (UX-UI) kit module 250, and a UX-UI theme module 260. The UX framework module 240 includes runtime components that operate at runtime for local development and testing. For example, the platform host 230 can be an embodiment of the platform host 130. In some embodiments, the platform host 230 includes a UX-UI kit module 250 that uses a set of components (UI blocks) and includes means for creating a ready-to-go form via mockups, which can be included as a non-public part integrated with the UX framework module 240. The UX-UI theme module 260 provides a repository that includes design tokens, global styles and override styles, i.e., elements representing design decisions and values.

[0028] Unlike the conventional deployment process, a hot module replacement (HMR) process can be performed to enable the development of the application 210 using the environment of a framework (e.g., corresponding to the UX framework 240). Thus, developers can evaluate changes to the application 210 without deploying the application to the platform host 230.

[0029] The platform host 230 can receive a first indicator from the IADD system 200. According to some embodiments, the platform host 230 can be triggered to request the status of the local development application 210, for example, in response to a prompt by the IADD system 200, a request from the local development platform, a scheduled event, etc.

[0030] In response to receiving the first indicator, the platform host 210 performs the operation of receiving the development application 210. In some embodiments, the platform host may request the transmission of the development application 210 and wait for the transmission. In some embodiments, the transmission is performed asynchronously.

[0031] After receiving the transmission including the development application 210, the platform host 230 can then perform a process for integrating the application. In some embodiments, the platform host 230 continues the current version of the runtime of the application (which can be the APS runtime) and integrates the application while minimizing downtime. For example, in some embodiments, the platform host 230 can synchronously apply web components to integrate the application. In some embodiments, the platform host 230 can provide a supplementary layer (such as the framework 240) to the development platform. The framework 240 includes a basic abstraction of the operating environment and can enable the development platform to be configured to develop applications in a decoupled stack format. The framework 240 provides basic support for the application architecture used for application development and testing.

[0032] The compiled bundle file can be provided to be dynamically downloaded to the platform host. This can optimize the download of the file to the platform host. The bundle file can be prepared as one or more asynchronous web components that are downloaded incrementally when a new page (i.e., the route or representation of the application) is rendered by the APS adapter.

[0033] At the same time, the final bundle file does not contain the code of the primary vendor library. This code is downloaded directly from the framework 240 to the host. In this way, the application can be deployed while minimizing the size of the bundle file. In this case, the bundle file only contains specific business layer code. The IADD system and method system enable the organization of web components for optimizing the deployment of the platform host. The web components provide a new layer of separate applications independent of the platform host.

[0034] Therefore, with the IADD system and method, a new application is configured to exist in parallel with the old application, and the applications do not affect each other. That is, the old and new applications coexist with an optimal platform host load.

[0035] By providing supplementary functions to the framework for local application development (for example, the adaptive layout framework 220), a convenient debugging process can be enabled that includes the use of specific real-time means such as utility tools (for example, VUE DEVTOOLS) that help developers develop applications.

[0036] Due to the independent application creation mode, it is not necessary to send the code to the stack for verification every time, resulting in the achievement of faster application creation. As a result, different from the previous cases, the set business goals can be achieved more quickly. Such a process organization brings convenience to the process and shortens the time. Additional advantages include the deployment of more reliable applications and patches. The framework prepares the same environment for runtime, testing, and local development. At the framework level, possible runtime usage cases are each considered, enabling development by focusing on specific business layers. In this way, a smoother transition from the old workflow to the new workflow can be achieved, making it possible to perform staged development while minimizing unnecessary downtime.

[0037] Integration Figure 3 shows an IADD method system 300 for deploying a new workload integrated at APS runtime. By using specific description parameters, a new application can be deployed using a framework with means for APS integration. According to an embodiment, the IADD method 300 enables the old and new applications to operate simultaneously in parallel.

[0038] As shown in FIG. 3, in operation 310, the platform host 230 can receive application metadata corresponding to an application, such as an APS application. In operation 320, the platform host 230 determines whether the framework is loaded. Based on the determination, the platform host (e.g., the UX framework module 240) can take out and start the framework as a supplementary layer that can include a basic abstraction of the operating environment. Thus, the platform host 320 is configured to maintain supplementary support including support for the application architecture under development at runtime. These supplementary functions facilitate the debugging process and make it possible to minimize the downtime of production applications such as the APS runtime.

[0039] FIG. 4 illustrates an IADD system 400 including a container as a controller representing an application that utilizes a set of web components. As shown in FIG. 4, for the application 410 rendered on a client (e.g., client 130), the application 410 represents itself as a set of web components such as a route 420.

[0040] System 400 includes one or more containers that function as a controller 415 for an application 410. The controller 415 serves as one or more web components configured to organize the flow and operation of other web components, i.e., acting as the upper layer of a route 420. The route 420 is a web component that can be provided with an organization implemented by the controller 415. The route array 420 includes one or more routes and provides a library for page navigation (routes) of an application, such as a web application. Each route 420 is another view that can be rendered (e.g., the current route 422) or hidden as required by the web application 410, for example, by user navigation. The application 410 can include a specific representation with an internal physical structure. Thus, the application 410 itself represents a web component configured to control other web components, i.e., the route 420.

[0041] Figure 5 illustrates a browser application deployment process 500. As shown in Figure 5, the browser application deployment process 500 can include an operation 501 of initializing a localization scheme 505 to configure web components.

[0042] In operation 502, the web components configured by the localization scheme 501 are integrated into a container 515 by a controller 510. For example, the initial (i.e., home) route can be integrated into the container 515.

[0043] In operation 503, the application deployment can include an operation of splitting a bundle into application bundle chunks 520. Operation 530 can include the integration of each chunk 520 that can include or correspond to a specific web route component.

[0044] In operation 504, once the addition of each web component to the browser is complete, the initial application lifecycle can proceed. Operation 504 can include rendering an application configured for a client (e.g., client 140).

[0045] Platform Host Handshaking FIG. 6 illustrates a process 600 for performing a new deployment of an application (which can be an embodiment of application 102 deployed as application 132, application 210, 410, etc.). Process 600 includes a handshake between an application provided by a local development platform (e.g., platform 110) and a platform host (e.g., platform host 130), and can cause the deployment of the application to occur at runtime. As shown in FIG. 6, after the application is developed, it can be deployed to the platform host.

[0046] In operation 605, platform host 601 can perform operations corresponding to web component creation, such as the operation of sending a connected web component to an application (e.g., a container such as a main container).

[0047] In operation 610, the connected web component is mounted in container 602. Operation 610 can include initiating a handshake between container 602 and platform host 601.

[0048] In operation 615, data including a first indicator, e.g., a flag, is communicated between container 602 and platform host 601, indicating that the application is ready for deployment.

[0049] In operation 620, the platform host 601 waits for communication of the first indicator. When the first indicator is received, the platform host 601 can be configured to start a deployment process, which can be an embodiment such as the deployment process 500.

[0050] In operation 625, when the first indicator is received, the platform host 601 can be configured to integrate the corresponding application parameters as described above.

[0051] In operation 630, after configuring the application parameters, the platform host 601 can communicate data including a second indicator indicating that the application is being deployed.

[0052] In operation 635, the application waits for communication of the second indicator. When the second indicator is received, the container 602 sets the application parameters (e.g., "public" parameters) in operation 640 and permits the rendering of the application by the runtime process. Operation 640 can include, for example, setting the parameters so that the APS runtime can be rendered by the platform host 130 to the client 140.

[0053] Event system According to an exemplary embodiment, a methodology of event-based system interaction is provided to enable coordination between a vendor application development platform and a platform host. The event-based methodology of system interaction comprises one or more processes for creating a particular event-controllable system, which can be, for example, an embodiment of system 100. The event-based methodology of system interaction enables coordination to be achieved without strong communication between the vendor application development platform and the platform host, allowing the vendor application to be changed independently. This event-based methodology provides an advantage over conventional processes that require a strong dependency between the development platform and the platform host, while enabling the local development and host runtime environments to be managed as predictable operations.

[0054] According to some embodiments, the interaction between the host platform and the vendor application development platform additionally enables the coordination of one or more platform frameworks between the platform host and the development platform. According to an exemplary embodiment, these interactions can include (A) a vendor application development platform that sends events with one or more frameworks to the platform host, and (B) a vendor application development platform that periodically utilizes platform host events. In some embodiments, (1) private events that include one or more frameworks can be sent from the application to the host platform, for example, internal use events, (2) private events can be sent from the platform host to the application, for example, for internal use, (3) public events with one or more frameworks can be sent from the application to the platform host, for example, for public use by UX1 framework developers, (4) public events can be sent from the platform host to the vendor application development platform, for example, including abstractions for providing general-purpose functions that can be selectively adapted and implemented by application 102.

[0055] This event-based methodology can be configured to perform basic system communication. Such communication can include information utilized, for example, for routing, notification, sending out analytics data (such as GOOGLE analytics data), etc., and the event-based methodology can be configured to share components associated with application functionality.

[0056] The resulting solution is flexible and can be extended without limitation to any number of new features (system communications). The two-way system interaction between the platform host and the application is performed using a proprietary framework system, which can include providing one or more web components configured to organize the interaction at the native browser level. According to some embodiments, the IADD event system enables independent changes to the application under development and the platform host without requiring strong bundles or dependencies.

[0057] Various embodiments may be implemented using one or more computer systems, such as the computer system 700 shown in FIG. 7, for example. The one or more computer systems 700 may be used, for example, to implement any of the embodiments described herein, as well as combinations and sub-combinations thereof. For example, the computer system 700 can be used to implement the framework 104 / 134 of FIG. 1, the method 600 for performing a communication handshake between the platform host and the application, and / or the system 100 for the design and deployment of independent applications including any other implementation of the disclosed embodiments.

[0058] The computer system 700 may include one or more processors (also referred to as central processing units or CPUs), such as the processor 704, for example. The processor 704 may be connected to a communication infrastructure, or bus 706.

[0059] Also, the computer system 700 may include user input / output devices 708, such as a monitor, keyboard, pointing device, etc., which may communicate with the communication infrastructure 706 via a user input / output interface 702.

[0060] One or more of the processors 704 may be a graphics processing unit (GPU). In some embodiments, the GPU may be a processor that is a special electronic circuit designed to process mathematically intensive applications. The GPU may have a parallel structure that is efficient for parallel processing of large blocks of data, such as the mathematically intensive data common to computer graphics applications, images, videos, and the like.

[0061] The computer system 700 may also include a main or primary memory 708, such as a random access memory (RAM). The main memory 708 may include one or more levels of cache. The main memory 708 may have control logic (i.e., computer software) and / or data stored therein.

[0062] The computer system 700 may also include one or more secondary storage devices or memories 710. The secondary memory 710 may include, for example, a hard disk drive 712 and / or a removable storage device or drive 714. The removable storage drive 714 may be a floppy disk drive, magnetic tape drive, compact disk drive, optical storage device, tape backup device, and / or any other storage device / drive.

[0063] The removable storage drive 714 may interact with a removable storage unit 718. The removable storage unit 718 may include a computer-usable or readable device having computer software (control logic) and / or data stored thereon. The removable storage unit 718 may be a floppy disk, magnetic tape, compact disk, DVD, optical storage disk, and / or any other computer data storage device. The removable storage drive 714 may read from and / or write to the removable storage unit 718.

[0064] The secondary memory 710 may include other means, devices, components, media, or other approaches to enable a computer program and / or other instructions and / or data to be accessed by the computer system 700. Such means, devices, components, media, or other approaches may include, for example, a removable storage unit 722 and an interface 720. Examples of the removable storage unit 722 and the interface 720 may include a program cartridge and a cartridge interface (such as those found in video game devices), a removable memory chip (such as an EPROM or PROM), and an associated socket, a memory stick and a USB port, a memory card and an associated memory card slot, and / or any other removable storage device and an associated interface.

[0065] The computer system 700 may further include a communication or network interface 724. The communication interface 724 may enable the computer system 700 to communicate and interact with any combination of external devices, external networks, external entities, etc. (collectively and individually referred to by reference numeral 728). For example, the communication interface 724 may enable the computer system 700 to communicate with an external or remote device 728 via a communication path 726 that may be wired and / or wireless (or a combination thereof) and may include any combination of a LAN, a WAN, the Internet, etc. Control logic and / or data may be transmitted to and from the computer system 700 via the communication path 726.

[0066] Also, computer system 700 can be any of, by way of some non-limiting examples, a personal digital assistant (PDA), a desktop workstation, a laptop or notebook computer, a netbook, a tablet, a smartphone, a smartwatch or other wearable, an appliance, a part of the Internet of Things, and / or an embedded system, or any combination thereof.

[0067] Computer system 700 can be a client or a server that accesses or hosts any application and / or data through any delivery paradigm, including but not limited to remote or distributed cloud computing solutions, local or on-premises software (an “on-premises” cloud-based solution), a “as a service” model (e.g., Content as a Service (CaaS), Digital Content as a Service (DCaaS), Software as a Service (SaaS), Managed Software as a Service (MSaaS), Platform as a Service (PaaS), Desktop as a Service (DaaS), Framework as a Service (FaaS), Backend as a Service (BaaS), Mobile Backend as a Service (MBaaS), Infrastructure as a Service (IaaS), etc.), and / or a hybrid model that includes any combination of the foregoing examples or other services or delivery paradigms.

[0068] Any applicable data structures, file formats, and schemas in computer system 700 may be derived from standards including, but not limited to, JavaScript Object Notation (JSON), Extensible Markup Language (XML), Yet Another Markup Language (YAML), Extensible Hypertext Markup Language (XHTML), Wireless Markup Language (WML), MessagePack, XML User Interface Language (XUL), or any other functionally similar representations, alone or in combination. Alternatively, proprietary data structures, formats, or schemas may be used, either exclusively or in combination with known or open standards.

[0069] In some embodiments, a tangible, non-transitory device or article of manufacture comprising a tangible, non-transitory computer-usable or readable medium having stored thereon control logic (software) may also be referred to herein as a computer program product or program storage device. This includes, but is not limited to, tangible articles of manufacture embodying any of the foregoing combinations in addition to computer system 700, main memory 708, secondary memory 710, and removable storage units 718 and 722. Such control logic, when executed by one or more data processing devices (such as computer system 700), can cause such data processing devices to operate as described herein.

[0070] It should be understood that the operations shown in the exemplary methods are not exhaustive, and that other operations may be performed before, after, or between any of the illustrated operations. In some embodiments of the present disclosure, the operations may be performed in a different order and / or vary.

[0071] It should be understood that for purposes of interpreting the claims, the detailed description, rather than the abstract, is intended to be used. The abstract may state one or more, but not all, of the exemplary embodiments of the invention intended by the inventor, and thus is not intended to limit the invention and the appended claims in any way.

[0072] In the foregoing, the present invention has been described with the aid of functional building blocks that illustrate the implementation of specific functions and their relationships. The boundaries of these functional building blocks are arbitrarily defined herein for ease of explanation. Alternative boundaries can be defined as long as the specific functions and their relationships are properly implemented.

[0073] The foregoing description of specific embodiments is to fully disclose the general nature of the present disclosure, and by applying the knowledge of those skilled in the art, such specific embodiments can be easily modified without departing from the general concept of the present invention and without performing more experiments than necessary, and / or can be applied to various uses. Therefore, such applications and modifications are intended to be within the meaning and scope of equivalents of the disclosed embodiments based on the teachings and guidance presented herein. It should be understood that the expressions or terms herein are for illustrative purposes, and thus the terms or expressions herein should be interpreted by those skilled in the art in light of the teachings and guidance.

[0074] The breadth and scope of the present invention should not be limited by any of the foregoing exemplary embodiments, but should be defined only by the claims and their equivalents.

Claims

1. A method for creating, sharing, and integrating vendor applications within a host platform, the method comprising: communicating, by the host platform, with a framework package corresponding to an application framework, the framework package comprising software abstractions for providing general functionality in the development of vendor applications; receiving, by the host platform, an application package corresponding to a vendor application, the application package comprising a plurality of metadata files, control method descriptions, and content files; integrating the application package to generate an integration of the vendor application based on the application framework.

2. The method of claim 1, further comprising updating, by an application packaging controller, one or more integrated applications corresponding to the application package.

3. The method of claim 1, wherein the integrating comprises providing one or more updated services from the application package to extend the functionality of the integration associated with the application package of the vendor application.

4. The method of claim 1, wherein the integrating comprises applying one or more presets using one or more plugin components.

5. The method of claim 1, further comprising performing a handshake between the vendor application provided by the application package and the host platform, the handshake comprising mounting one or more web components and setting public parameters of the application to enable access to the one or more web components.

6. The method of claim 1, wherein the integrating comprises generating one or more routes as web components having an organization implemented by a controller of the host platform, the host platform being configured to render each of the one or more routes.

7. Further comprising generating an application bundle for implementing a vendor application within a container, wherein said receiving comprises receiving said application bundle and splitting said application bundle into one or more application bundle chunks, each bundle chunk comprising a specific web path component, the method according to claim 1.

8. Communicating by a host platform with a framework package corresponding to an application framework, said framework package comprising software abstractions for providing general functionality in the development of vendor applications, the communicating; Receiving by said host platform an application package corresponding to a vendor application, said application package comprising a plurality of metadata files, control method descriptions, and content files, the receiving; Integrating said application package to generate an integration of said vendor application based on said application framework, a processing system comprising one or more processors executing computer-readable instructions causing the processing system to perform the foregoing, a system for creating, sharing, and integrating applications.

9. The system according to claim 8, further comprising updating, by an application packaging controller, one or more integrated applications corresponding to said application package.

10. The system according to claim 8, wherein said integrating comprises providing one or more updated services from said application package to extend said integrated functionality associated with said application package of said vendor application.

11. The system according to claim 8, wherein said integrating comprises applying one or more presets using one or more plug-in components.

12. The system according to claim 8, further comprising performing a handshake between the vendor application provided by the application package and the host platform, the handshake comprising mounting one or more web components and setting public parameters of the application to enable access to the one or more web components.

13. The system according to claim 8, wherein the integrating comprises generating one or more routes as web components having an organization implemented by a controller of the host platform, the host platform being configured to render each of the one or more routes.

14. The system according to claim 8, further comprising generating an application bundle that implements a vendor application within a container, the receiving comprising receiving the application bundle and splitting the application bundle into one or more application bundle chunks, each bundle chunk comprising a specific web route component.

15. A computer program product for creating, sharing, and integrating an application, comprising computer-readable program code that, when retrieved from a non-transitory computer-readable medium, can be executed by at least one processor, the program code comprising communicating, by the host platform, with a framework package corresponding to an application framework, the framework package comprising software abstractions for providing general functionality in the development of vendor applications; receiving, by the host platform, an application package corresponding to a vendor application, the application package comprising a plurality of metadata files, control method descriptions, and content files; integrating the application package to generate an integration of the vendor application based on the application framework, and instructions configured to cause the above.

16. The computer program product according to claim 15, further comprising updating one or more integrated applications corresponding to the application package by an application packaging controller.

17. The computer program product according to claim 15, wherein the integrating comprises providing one or more updated services from the application package to extend the integration functionality associated with the application package of the vendor application.

18. The computer program product according to claim 15, further comprising performing a handshake between the vendor application provided by the application package and the host platform, the handshake comprising mounting one or more web components and setting public parameters of the application to enable access to the one or more web components.

19. The computer program product according to claim 15, wherein the integrating comprises generating one or more routes as web components having an organization implemented by a controller of the host platform, the host platform being configured to render each of the one or more routes.

20. The computer program product according to claim 15, further comprising generating an application bundle that implements a vendor application within a container, the receiving comprising receiving the application bundle and splitting the application bundle into one or more application bundle chunks, each bundle chunk comprising a specific web route component.

Images