CN113741951A

CN113741951A - Local packaging method and device

Info

Publication number: CN113741951A
Application number: CN202010475708.8A
Authority: CN
Inventors: 唐谢军
Original assignee: Beijing Jingdong Century Trading Co Ltd; Beijing Wodong Tianjun Information Technology Co Ltd
Current assignee: Beijing Jingdong Century Trading Co Ltd; Beijing Wodong Tianjun Information Technology Co Ltd
Priority date: 2020-05-29
Filing date: 2020-05-29
Publication date: 2021-12-03

Abstract

The invention discloses a local packaging method and device, and relates to the technical field of computers. The method comprises the following steps: traversing a first-level dependency item set of business engineering dependencies in the configuration file; for each primary dependent item in the primary dependent item set, under the condition that the package file corresponding to the primary dependent item needs to be constructed, constructing the package file corresponding to the primary dependent item, and caching the package file corresponding to the primary dependent item; pulling the latest code of the business engineering on the target branch; and constructing a package file corresponding to the business project according to the latest code of the business project on the target branch and the package file corresponding to each primary dependent item of the business project. Through the steps, the packing error probability of the business engineering in the development and test processes can be reduced, and the execution efficiency of local packing is improved.

Description

Local packaging method and device

Technical Field

The invention relates to the technical field of computers, in particular to a local packaging method and a local packaging device.

Background

When developing large front-end projects, situations of complex business engineering (Project) dependencies are often encountered. For example, business project1 depends on library file 1, library file 2, and library file 3 simultaneously, library file 2 in turn depends on library file 1, and library file 3 in turn depends on library file 1 and library file 2.

Meanwhile, if the business engineering depends on a self-developed dependency library (referred to as a "self-research dependency library"), the business engineering and the self-research dependency library also need to maintain different git branch versions. When the business engineering is finally on-line, the business engineering is compiled and packaged based on the code of the master branch, and the self-research dependency packages installed in the compiling process are all formal packages issued to the private server. However, in the development and test process, because the relevant codes are not verified, the self-research dependency library has no way to release the formal package, and at this time, the self-research dependency library corresponding to the branch can be installed in a manual local packaging manner, so that the local packaging of the business engineering is realized.

In the process of implementing the invention, the inventor finds that the existing manual local packaging mode at least has the following problems: first, the more complex the dependency, the more error prone to manual local packaging; second, the more complex the dependency, the more steps that need to be performed manually, and the longer it takes. Developers need to pay attention to the connection process of every two steps, and a large amount of time is consumed by the developers. The entire manual local packaging process is time consuming.

Disclosure of Invention

In view of this, the present invention provides a local packing method and device, which can reduce the packing error probability of the service engineering in the development and test processes, and improve the execution efficiency of local packing.

To achieve the above object, according to one aspect of the present invention, there is provided a local packing method.

The local packaging method comprises the following steps: acquiring a configuration file and loading the configuration file into a memory; the configuration file is used for describing the dependency relationship between the business engineering and the dependent items; traversing a first-level dependency item set of business engineering dependencies in the configuration file; for each primary dependent item in the primary dependent item set, under the condition that the package file corresponding to the primary dependent item needs to be constructed, constructing the package file corresponding to the primary dependent item, and caching the package file corresponding to the primary dependent item; pulling the latest code of the business engineering on the target branch; and constructing a package file corresponding to the business project according to the latest code of the business project on the target branch and the package file corresponding to each primary dependent item of the business project.

Optionally, the method further comprises: before the packet file corresponding to the first-level dependent item is constructed and cached, pulling the latest code of the first-level dependent item on a target branch; and confirming that the package file corresponding to the first-level dependent item needs to be constructed under the condition that the latest code of the first-level dependent item on the target branch is updated or the package file corresponding to the first-level dependent item does not exist in the cache.

Optionally, the method further comprises: and confirming that the package file corresponding to the first-level dependent item is not required to be constructed under the condition that the latest code of the first-level dependent item on the target branch is not updated and the package file corresponding to the first-level dependent item exists in the cache.

Optionally, the constructing the package file corresponding to the first-level dependency item and caching the package file corresponding to the first-level dependency item includes: traversing a secondary dependency item set on which the primary dependency item depends in the configuration file; for each secondary dependent item in the secondary dependent item set, storing a package file corresponding to the secondary dependent item in a cache into a corresponding folder under the primary dependent item record; and packing the first-level dependent item according to the latest code of the first-level dependent item on the target branch and the package file of each second-level dependent item on which the first-level dependent item depends to obtain the package file corresponding to the first-level dependent item, and then caching the package file corresponding to the first-level dependent item.

Optionally, the constructing the package file corresponding to the first-level dependency item and caching the package file corresponding to the first-level dependency item further includes: and under the condition that the first-level dependent item does not have a dependent second-level dependent item, packing the first-level dependent item according to the latest code of the first-level dependent item on the target branch to obtain a package file corresponding to the first-level dependent item, and then caching the package file corresponding to the first-level dependent item.

Optionally, the method further comprises: before the step of caching the packet files corresponding to the first-level dependency items, packet extraction is carried out on the packet files corresponding to the first-level dependency items through a packet extraction command, and then the compressed packets obtained through packet extraction are decompressed.

Optionally, the first-level dependency in the configuration file is a self-research first-level dependency, and the second-level dependency in the configuration file is a self-research second-level dependency; the method further comprises the following steps: installing a third-party primary dependent item which is dependent on the business engineering before the step of constructing a package file corresponding to the business engineering according to the latest code of the business engineering on the target branch and the package file corresponding to each primary dependent item of the business engineering; and installing a third-party secondary dependent item on which the primary dependent item depends before the step of packaging the primary dependent item according to the latest code of the primary dependent item on the target branch and each secondary dependent item on which the primary dependent item depends.

To achieve the above object, according to another aspect of the present invention, there is provided a local packaging apparatus.

The local packaging apparatus of the present invention includes: the acquisition module is used for acquiring the configuration file and loading the configuration file into the memory; the configuration file is used for describing the dependency relationship between the business engineering and the dependent items; the first packing module is used for traversing a first-level dependency item set depended on by the business engineering in the configuration file; the first packing module is further used for establishing a package file corresponding to the first-level dependent item and caching the package file corresponding to the first-level dependent item under the condition that the package file corresponding to the first-level dependent item needs to be established for each first-level dependent item in the first-level dependent item set; the second packing module is used for pulling the latest codes of the business engineering on the target branch; and the second packaging module is also used for constructing a package file corresponding to the business project according to the latest code of the business project on the target branch and the package file corresponding to each level of dependency item of the business project.

To achieve the above object, according to still another aspect of the present invention, there is provided an electronic apparatus.

The electronic device of the present invention includes: one or more processors; and storage means for storing one or more programs; when executed by the one or more processors, cause the one or more processors to implement the local packaging methods of the present invention.

To achieve the above object, according to still another aspect of the present invention, there is provided a computer-readable medium.

The computer-readable medium of the invention has stored thereon a computer program which, when being executed by a processor, implements the local packaging method of the invention.

One embodiment of the above invention has the following advantages or benefits: traversing a first-level dependency item set of business engineering dependency in a configuration file by acquiring the configuration file and loading the configuration file into a memory; for each primary dependent item in the primary dependent item set, under the condition that the package file corresponding to the primary dependent item needs to be constructed, constructing the package file corresponding to the primary dependent item, and caching the package file corresponding to the primary dependent item; and pulling the latest code of the business engineering on the target branch, and constructing a package file corresponding to the business engineering according to the latest code of the business engineering on the target branch and the package file corresponding to each level dependency item of the business engineering, so that the packaging error probability of the business engineering in the development and test processes can be reduced, and the execution efficiency of local packaging is improved.

Further effects of the above-mentioned non-conventional alternatives will be described below in connection with the embodiments.

Drawings

The drawings are included to provide a better understanding of the invention and are not to be construed as unduly limiting the invention. Wherein:

fig. 1 is a schematic main flow chart of a local packaging method according to a first embodiment of the present invention;

fig. 2 is a schematic main flow chart of a local packaging method according to a second embodiment of the present invention;

FIG. 3 is a diagram illustrating an alternative implementation of step S206 in the second embodiment of the present invention;

fig. 4 is a schematic main flow chart of a local packaging method according to a third embodiment of the present invention;

fig. 5 is a schematic diagram of main blocks of a local packaging apparatus according to a fourth embodiment of the present invention;

FIG. 6 is an exemplary system architecture diagram in which embodiments of the present invention may be employed;

FIG. 7 is a block diagram of a computer system suitable for use with the electronic device to implement an embodiment of the invention.

Detailed Description

Exemplary embodiments of the present invention are described below with reference to the accompanying drawings, in which various details of embodiments of the invention are included to assist understanding, and which are to be considered as merely exemplary. Accordingly, those of ordinary skill in the art will recognize that various changes and modifications of the embodiments described herein can be made without departing from the scope and spirit of the invention. Also, descriptions of well-known functions and constructions are omitted in the following description for clarity and conciseness.

It should be noted that the embodiments and features of the embodiments may be combined with each other without conflict.

Before describing in detail various embodiments of the present invention, some technical terms related to the embodiments of the present invention will be described.

And (4) business engineering: the technical terminology in software development, English may be referred to as "project", which may also be referred to as "project" or "project".

Dependent terms: technical terms in software development may also be referred to as "dependencies," dependency libraries, "or" dependency packages.

First order dependent terms: refers to a library file on which business engineering depends.

Secondary dependent terms: refers to a library file on which the first-level dependent item depends.

Self-study dependent term: often autonomously developed dependencies, as distinguished from third party dependencies. The self-research dependency term may also be referred to as a "self-research dependency," library of self-research dependencies, "or a" package of self-research dependencies.

Fig. 1 is a main flow diagram of a local packaging method according to a first embodiment of the present invention. As shown in fig. 1, the local packaging method according to the embodiment of the present invention includes:

step S101, obtaining a configuration file and loading the configuration file into a memory.

Wherein the configuration file is used for describing the dependency relationship between the business engineering and the dependent item.

In an alternative example, the configuration file is used to describe the business project and the dependencies of all the dependencies it depends on. For example, if business project1 depends on library file 1, library file 2, and library file 3, the dependency between business project1 and library file 1, library file 2, and library file 3 on which it depends may be described in a configuration file.

In another alternative example, the configuration file is used to describe the dependency of the business project and all of the self-developed dependencies on which it depends. For example, if the business project1 depends on the self-research dependency 1, the self-research dependency 2, and the third-party dependency 3, the business project1 and the dependency relationship between the self-research dependency 1 and the self-research dependency 2 may be described in the configuration file.

In this step, after the local packaging device is triggered, the configuration file may be obtained from the file path where the configuration file is located, and loaded into the memory. Typically, the configuration file loaded into memory is a JSON (JSON is a lightweight data exchange format) data object.

Step S102, traversing a primary dependency item set of business engineering dependency in the configuration file; and aiming at each first-level dependent item in the first-level dependent item set, under the condition that the package file corresponding to the first-level dependent item needs to be constructed, constructing the package file corresponding to the first-level dependent item, and caching the package file corresponding to the first-level dependent item.

Wherein, the primary dependency item set can be expressed in array form. For example, a "config.dependences array" may be adopted to represent a set of primary dependencies that a business engineering depends on, and specifically includes the following three primary dependencies: library file 1, library file 2, library file 3. When traversing the 'config.dependencies array', firstly judging whether a package file corresponding to the library file 1 needs to be constructed or not aiming at the library file 1, and constructing and caching the package file corresponding to the library file 1 under the condition that the package file corresponding to the library file 1 needs to be constructed; then, judging whether a package file corresponding to the library file 2 needs to be constructed or not aiming at the library file 2, and constructing and caching the package file corresponding to the library file 2 under the condition that the package file corresponding to the library file 2 needs to be constructed; next, it is determined whether a package file corresponding to the library file 3 needs to be constructed with respect to the library file 3, and if it is determined that the package file corresponding to the library file 3 needs to be constructed, the package file corresponding to the library file 3 is constructed and cached. By caching after the package files corresponding to the first-level dependency items are constructed, the time required by the whole local package can be greatly shortened, and the packaging efficiency is improved.

S103, pulling the latest code of the business project on the target branch; and constructing a package file corresponding to the business project according to the latest code of the business project on the target branch and the package file corresponding to each primary dependent item of the business project.

In this step, the latest code of the business project on the target branch may be pulled according to the description information of the business project in the configuration file. For example, a complete business project path can be spliced according to the name field of the business project contained in the configuration file, and the business project path enters the root directory of the business project; then, the target branch is switched to according to the target branch field of the traffic engineering contained in the configuration file, and the latest code on the target branch is pulled through a command such as git pull.

After the packet file corresponding to each first-level dependency item of the business engineering and the latest code of the business engineering on the target branch are obtained, the packet file corresponding to each first-level dependency item in the cache can be copied to a corresponding folder under a business engineering directory, and then a project packing command (such as an npm run build command) is executed to pack the business engineering, so that the packet file corresponding to the business engineering is obtained.

In the embodiment of the invention, the complex dependency relationship is described through the configuration file, so that the complexity of the dependency relationship does not influence the difficulty of local packaging, and the probability of packaging errors is greatly reduced; automatic local packaging can be realized through the steps S101 to S103, developers do not need to pay attention to packaging details, packaging error probability is reduced compared with manual local packaging, and packaging efficiency is improved.

Fig. 2 is a schematic main flow chart of a local packaging method according to a second embodiment of the present invention. As shown in fig. 2, the local packaging method according to the embodiment of the present invention includes:

step S201, a configuration file is obtained and loaded into a memory.

Step S202, creating a cache directory.

The cache directory may be a folder newly created in a root target of a computer local project space. By creating the cache directory, the subsequent caching of the locally packaged dependent packages, such as the package files corresponding to the first-level dependent items, is facilitated.

Step S203, determine whether i is less than dependency. If the determination result is yes, executing step S204; in the case where the determination result is no, step S207 is executed.

Wherein i represents a counter which starts from 0 and increments by 1 each time; the dependencies represents a primary dependency item array of business engineering dependence; length denotes the length of the array of first-order dependent terms, i.e. how many first-order dependent terms there are in the array.

Length, when i is less than dependency, it means that all elements of the first-level dependency array have not been traversed; length, when i is greater than or equal to dependency, it indicates that all elements of the primary dependency array have been traversed.

And S204, pulling the latest code of the ith primary dependent item of the business engineering dependence on the target branch.

Illustratively, the latest code of the ith primary dependent item on the target branch can be pulled according to the description information of the ith primary dependent item in the configuration file. For example, a complete item path may be spliced according to the name field of the ith primary dependent item included in the configuration file, and the complete item path may enter the root directory of the item; then, switching to the target branch according to the target branch field of the ith primary dependent item contained in the configuration file, and pulling the latest code of the ith primary dependent item on the target branch through a command such as git pull.

And S205, judging whether a package file corresponding to the primary dependency item needs to be constructed or not.

In this step, it is necessary to determine whether the ith primary dependent item needs to construct a package file corresponding to the ith primary dependent item. For example, whether a package file corresponding to the ith primary dependent item needs to be constructed may be determined according to the following manner: judging whether the latest code of the ith first-level dependent item on the target branch is updated or not, and judging whether a packet file corresponding to the ith first-level dependent item exists in the cache directory or not; confirming that a package file corresponding to the ith first-level dependent item needs to be constructed under the condition that the latest code of the ith first-level dependent item on the target branch is updated or the package file corresponding to the ith first-level dependent item does not exist in a cache; and under the condition that the latest code of the ith first-level dependent item on the target branch is not updated and the package file corresponding to the ith first-level dependent item exists in the cache, confirming that the package file corresponding to the ith first-level dependent item does not need to be constructed.

During specific implementation, the submission id (identification) of the latest code of the ith primary dependent item pulled at this time can be compared with the submission id (identification) of the code of the ith primary dependent item pulled at the last time, and if the two are not consistent, the latest code of the ith primary dependent item can be updated; if the two are consistent, it can be stated that the latest code of the ith primary dependent item is not updated. In addition, in specific implementation, whether a corresponding package file exists in the cache directory can be searched through the name of the ith primary dependent item, and if the corresponding package file can be searched, the package file corresponding to the ith primary dependent item exists in the cache directory; if the corresponding package file cannot be found, it can be said that the package file corresponding to the ith first-level dependency does not exist in the cache directory.

Further, in the case where the determination result of step S205 is yes, step S206 may be performed; in the case where the determination result of step S205 is no, i may be made i +1 (meaning that the value of the counter i is increased by 1), and then step S203 may be executed again.

And S206, constructing a package file corresponding to the first-level dependency item, and storing the package file corresponding to the first-level dependency item into a cache directory. After step S206, i may be made i +1, and then step S203 is performed again.

How step S206 is implemented will be described in detail below with reference to fig. 3.

And step S207, pulling the latest code of the business engineering on the target branch.

In this step, the latest code of the business project on the target branch can be pulled according to the description information of the business project in the configuration file. For example, a complete business project path can be spliced according to the name field of the business project contained in the configuration file, and the business project path enters the root directory of the business project; then, the target branch is switched to according to the target branch field of the traffic engineering contained in the configuration file, and the latest code on the target branch is pulled through a command such as git pull.

And S208, constructing a package file corresponding to the business project according to the latest codes of the business project on the target branch and the package files corresponding to the primary dependent items of the business project.

After obtaining the package files corresponding to each first-level dependency item of the service project and the latest code of the service project on the target branch, the package files corresponding to each first-level dependency item in the cache directory may be copied to the corresponding folder under the service project directory (for example, assuming that the service project is project1, the package files corresponding to each first-level dependency item may be copied to the node _ modules folder under the project1 directory), and then a project packing command (for example, an npm run build command) may be executed to pack the service project, so as to obtain the package files corresponding to the service project.

In the embodiment of the invention, the complex dependency relationship is described through the configuration file, so that the complexity of the dependency relationship does not influence the difficulty of local packaging, and the probability of packaging errors is greatly reduced; furthermore, automatic local packaging can be realized through the steps shown in fig. 2, developers do not need to pay attention to packaging details, the packaging error probability is reduced compared with manual local packaging, and the packaging efficiency is improved.

Fig. 3 is a schematic diagram of an alternative implementation manner of step S206 in the second embodiment of the present invention. As shown in fig. 3, an alternative implementation of step S206 specifically includes the following steps:

step S301, judging whether a secondary dependent item set dependent on the primary dependent item exists in the configuration file.

Illustratively, a query field may be constructed according to the name of the ith primary dependent item to query whether there is a set of secondary dependent items on which the ith primary dependent item depends in the configuration file. If the determination result is yes, step S302 may be executed; in the case where the determination result is no, step S305 may be performed.

And S302, traversing a secondary dependent item set on which the primary dependent item depends.

Wherein, the secondary dependency item set can be expressed in array form. For example, assuming that the ith primary dependency is library file 3 (which may be denoted as "lib 3"), a "lib 3.dependencies array" may be used to represent the set of secondary dependencies on which library file 3 depends, and the "lib 3.dependencies array" specifically includes the following two secondary dependencies: library file 1 (which may be denoted as "lib 1"), library file 2 (which may be denoted as "lib 2").

Step S303, storing the local package corresponding to the second-level dependent item in the cache into a corresponding folder under the first-level dependent item list aiming at each second-level dependent item in the second-level dependent item set.

For example, assume that the set of secondary dependent items on which the primary dependent item lib3 depends specifically includes the following two secondary dependent items: the lib1 and the lib2 may copy the package files corresponding to the lib1 in the cache to a corresponding folder under the lib3 directory (for example, a node _ modules folder under the lib3 directory), and copy the package files corresponding to the lib2 in the cache to a corresponding folder under the lib3 directory (for example, a node _ modules folder under the lib3 directory).

Further, before step S303, the method of the embodiment of the present invention may further include the following steps: judging whether a package file of the secondary dependent item needs to be constructed or not aiming at each secondary dependent item in the secondary dependent item set; and under the condition that the package file corresponding to the secondary dependency item needs to be constructed, constructing the package file corresponding to the secondary dependency item, and caching the package file corresponding to the secondary dependency item.

Step S304, packing the primary dependent item according to the latest code of the primary dependent item on the target branch and the package file of each secondary dependent item on which the primary dependent item depends, so as to obtain the package file corresponding to the primary dependent item.

After the package files of the secondary dependent items on which the primary dependent items depend are stored into the corresponding folders in the primary dependent item directory in step S303, the primary dependent items may be packaged by executing an item packaging command (such as an npm run build command) to obtain the package files corresponding to the primary dependent items. Further, after step S304, step S306 may be performed.

And S305, packaging the primary dependent item according to the latest code of the primary dependent item on the target branch to obtain a package file corresponding to the primary dependent item.

In this step, the primary dependent item may be packaged by executing an item packaging command (such as an npm run built command) to obtain a package file corresponding to the primary dependent item. Further, after step S305, step S306 may be performed.

And S306, extracting the local packet corresponding to the first-level dependency item through a packet extracting command, and decompressing the compressed packet obtained by packet extraction.

Illustratively, the local packet corresponding to the first-level dependency item may be decimated by an npm pack command. npm pack is a pack command which functions to pack the corresponding source code into a compressed pack suffixed with tgz according to a certain rule. And the local package corresponding to the primary dependency item is subjected to package extraction through a package extraction command, so that the package structure of the dependency package obtained by local packaging and the package issued by npm is kept consistent.

And step S307, caching the package file corresponding to the first-level dependency item obtained by decompression.

Specifically, the package file corresponding to the first-level dependency obtained by decompression may be stored in the cache directory, and the information of the cache package may be updated. In this step, the information of the cache package may include a commit id (identification) of the most recently updated level one dependency code. In a specific implementation, the headcommit id may be stored as a field in a package json file in the root directory of each cache package.

In the embodiment of the invention, the automatic local packing of the primary dependency items is realized through the steps, so that developers do not need to pay attention to packing details, the packing error probability is reduced compared with the manual local packing of the primary dependency items, the packing efficiency is improved, and the integral packing efficiency of business engineering is further improved.

Fig. 4 is a schematic main flow chart of a local packaging method according to a third embodiment of the present invention. As shown in fig. 4, the local packaging method in the embodiment of the present invention includes:

step S401, obtaining the configuration file and loading the configuration file into the memory.

In the embodiment of the invention, the configuration file is used for describing the dependency relationship between the business engineering and all self-research dependent items depended on by the business engineering. For example, if the business project1 depends on the self-research dependency 1, the self-research dependency 2, and the third-party dependency 3, the business project1 and the dependency relationship between the self-research dependency 1 and the self-research dependency 2 may be described in the configuration file.

Further, before step S401, the method of the embodiment of the present invention may further include the following steps: a configuration file is created under a root directory of a business project for describing dependency relationships between the business project and dependent items. For example, for the business project1, a configuration file named build.

Wherein project represents the description information of the business engineering, and dependencies represents the self-research dependency list of the items; name represents a project name (e.g., name under project represents the name of a business project); branch represents the target branch name; and the lib represents whether the lib is an identifier of a dependent library, represents that the lib is a business project when the value of the lib is false, and represents that the lib is the dependent library when the value of the lib is true.

Further, after creating the configuration file under the root directory of the business project, the method of the embodiment of the present invention may further include the following steps: creating a script for implementing the local packaging method of the present invention, configuring the bin field in the associated package json file and other necessary settings, making the script an executable file, and then publishing it as npm package (npm package can be understood as an executable program in node js environment); then, a target branch (such as the dev1 branch) of the service engineering is entered, the npm packet is installed, and a relevant command, such as "lc-built": eld-built-config./built-config. js ", is added to a script field in a package json file; then, the console executes the command "npm run lc-built" under the root directory of the service project, which triggers the local packaging process shown in fig. 4.

Step S402, creating a cache directory.

The cache directory may be a folder newly created in a root directory of a local project space of the computer. By creating the cache directory, the subsequent caching of the locally packaged dependent packages, such as the package files corresponding to the first-level dependent items, is facilitated.

Step S403, traversing a primary dependency item set of business engineering dependency in the configuration file; and taking each primary dependent item in the primary dependent item set as an entry parameter, calling a pullAndPulish method and executing to obtain a package file corresponding to each primary dependent item.

Wherein, the primary dependency item set can be expressed in array form. For example, a "config.dependences array" may be adopted to represent a set of primary dependencies that a business engineering depends on, and specifically includes the following three primary dependencies: lib1, lib2 and lib3. When traversing the "config.dependences array", firstly taking lib1 in the "config.dependences array" as an input reference to call a pullandpush method and executing the method to obtain and cache a package file corresponding to lib1, then taking lib2 as an input reference to call a pullandpush method and executing the method to obtain and cache a package file corresponding to lib2, and then taking lib3 as an input reference to call a pullandpush method and executing the method to obtain and cache a package file corresponding to lib3.

In the embodiment of the invention, the pullAndPulish method is used for realizing the packing of the dependent items and also used for realizing the packing of the business engineering. Illustratively, when the entries are first-level self-research dependencies, the processing flow of the pullandpush method mainly includes: step a1 to step a 9.

And step A1, splicing a complete item path according to the name field of the primary self-research dependent item, and entering the root directory of the dependent item.

Step A2, switching to the corresponding git branch according to the branch (target branch) field of the first-level self-research dependency.

Step A3, pull the latest code of the first level self-grinding dependency.

And step A4, judging whether the package file of the first-level self-research dependent item needs to be constructed.

If the judgment result of the step A4 is that construction is not needed, the execution is finished; if the judgment result of the step A4 is that construction is needed, the following steps are continued.

And step A5, installing a second-level third-party dependency of the first-level self-research dependency.

Step A6, traversing the secondary self-research dependency item array of the primary self-research dependency item; and for each second-level self-research dependent item in the second-level self-research dependent item array, copying the package file corresponding to the second-level self-research dependent item in the cache to a corresponding folder below the business engineering. For example, if the first-level self-research dependency item is lib1, the second-level self-research dependency item on which the first-level self-research dependency item depends is copied to the folder corresponding to lib1 under the business engineering directory.

And step A7, packaging the first-level self-research dependent item through an npm run built command to obtain a package file corresponding to the first-level self-research dependent item.

And step A8, performing packet extraction on the packet files corresponding to the first-level self-research dependent items through an npm pack packet extraction command.

And step A9, decompressing the compressed packet obtained by packet extraction into a cache directory, and updating the information of the cache packet.

S404, acquiring a business project field in the configuration file; and taking the field of the service project as an input parameter, calling a pullAndPublish method and executing to obtain a package file corresponding to the service project.

Illustratively, when the entry is a business engineering field, the processing flow of the pullandpush method mainly includes: step B1 to step B6.

And step B1, splicing a complete project path according to the name field of the business project, and entering the root directory of the business project.

And step B2, switching to the corresponding git branch according to the branch (target branch) field of the traffic engineering.

And step B3, pulling the latest code of the business project.

And step B4, installing the first-level third-party dependence of the business engineering item dependence.

B5, traversing the first-level self-research dependency item array of the business engineering dependency; and for each first-level self-research dependency item in the first-level self-research dependency item array, copying a package file corresponding to the first-level self-research dependency item in the cache to a corresponding folder below a business project.

And step B6, packaging the business engineering through the npm run build command to obtain a package file corresponding to the business engineering.

Fig. 5 is a schematic diagram of main blocks of a local packaging apparatus according to a fourth embodiment of the present invention. As shown in fig. 5, the local packaging apparatus 500 in the embodiment of the present invention includes: the system comprises an acquisition module 501, a first packing module 502 and a second packing module 503.

An obtaining module 501, configured to obtain a configuration file and load the configuration file into a memory.

Specifically, after the local packaging apparatus is triggered, the obtaining module 501 may first obtain the configuration file from the file path where the configuration file is located, and load the configuration file into the memory. Typically, the configuration file loaded into memory is a JSON (JSON is a lightweight data exchange format) data object.

A first packing module 502, configured to traverse a first-level dependency item set that is relied on by the business engineering in the configuration file; the first packing module 502 is further configured to, for each primary dependency item in the primary dependency item set, under the condition that it is determined that a package file corresponding to the primary dependency item needs to be constructed, construct a package file corresponding to the primary dependency item, and cache the package file corresponding to the primary dependency item.

A second packing module 503, configured to pull the latest code of the service engineering on the target branch; the second packing module 503 is further configured to construct a package file corresponding to the business project according to the latest code of the business project on the target branch and the package file corresponding to each level-one dependency of the business project.

For example, the second packaging module 503 may pull the latest code of the business project on the target branch according to the description information of the business project in the configuration file. For example, the second packaging module 503 may splice a complete service engineering path according to the name field of the service engineering contained in the configuration file, and enter the root directory of the service engineering; the second packaging module 503 then switches to the target branch according to the target branch field of the traffic engineering contained in the configuration file and pulls the latest code on the target branch through a command such as git pull.

After obtaining the package file corresponding to each first-level dependency item of the business engineering and the latest code of the business engineering on the target branch, the second packaging module 503 may copy the package file corresponding to each first-level dependency item in the cache to a corresponding folder under the business engineering directory, and then package the business engineering by executing an item packaging command (such as an npm run built command) to obtain the package file corresponding to the business engineering.

In the device of the embodiment of the invention, the complex dependency relationship is described through the configuration file, so that the complexity of the dependency relationship does not influence the difficulty of local packaging, and the probability of packaging errors is greatly reduced; automatic local packing can be realized through the acquisition module, the first packing module and the second packing module, so that developers do not need to pay attention to packing details, packing error probability is reduced compared with manual local packing, and packing efficiency is improved.

Fig. 6 illustrates an exemplary system architecture 600 of a local packaging method or local packaging apparatus to which embodiments of the invention may be applied.

As shown in fig. 6, the system architecture 600 may include

terminal devices

601, 602, 603, a network 604, and a server 605. The network 604 serves to provide a medium for communication links between the

terminal devices

601, 602, 603 and the server 605. Network 604 may include various types of connections, such as wire, wireless communication links, or fiber optic cables, to name a few.

A user may use the

terminal devices

601, 602, 603 to interact with the server 605 via the network 604 to receive or send messages or the like. Various communication client applications, such as a software development application, a shopping application, a web browser application, a search application, an instant messaging tool, a mailbox client, social platform software, and the like, may be installed on the

terminal devices

601, 602, and 603.

The

terminal devices

601, 602, 603 may be various electronic devices having a display screen and supporting web browsing, including but not limited to smart phones, tablet computers, laptop portable computers, desktop computers, and the like.

The server 605 may be a server providing various services, such as a background management server providing support for local packaged commands issued by users using the

terminal devices

601, 602, 603. The background management server can analyze and process the received data such as the product information inquiry request and feed back the processing result to the terminal equipment.

It should be noted that the local packaging method provided by the embodiment of the present invention is generally executed by the server 605, and accordingly, the local packaging apparatus is generally disposed in the server 605.

It should be understood that the number of terminal devices, networks, and servers in fig. 6 is merely illustrative. There may be any number of terminal devices, networks, and servers, as desired for implementation.

Referring now to FIG. 7, shown is a block diagram of a computer system 700 suitable for use with the electronic device implementing an embodiment of the present invention. The computer system illustrated in FIG. 7 is only an example and should not impose any limitations on the scope of use or functionality of embodiments of the invention.

As shown in fig. 7, the computer system 700 includes a Central Processing Unit (CPU)701, which can perform various appropriate actions and processes in accordance with a program stored in a Read Only Memory (ROM)702 or a program loaded from a storage section 708 into a Random Access Memory (RAM) 703. In the RAM 703, various programs and data necessary for the operation of the system 700 are also stored. The CPU 701, the ROM 702, and the RAM 703 are connected to each other via a bus 704. An input/output (I/O) interface 705 is also connected to bus 704.

The following components are connected to the I/O interface 705: an input portion 706 including a keyboard, a mouse, and the like; an output section 707 including a display such as a Cathode Ray Tube (CRT), a Liquid Crystal Display (LCD), and the like, and a speaker; a storage section 708 including a hard disk and the like; and a communication section 709 including a network interface card such as a LAN card, a modem, or the like. The communication section 709 performs communication processing via a network such as the internet. A drive 710 is also connected to the I/O interface 705 as needed. A removable medium 711 such as a magnetic disk, an optical disk, a magneto-optical disk, a semiconductor memory, or the like is mounted on the drive 710 as necessary, so that a computer program read out therefrom is mounted into the storage section 708 as necessary.

In particular, according to the embodiments of the present disclosure, the processes described above with reference to the flowcharts may be implemented as computer software programs. For example, embodiments of the present disclosure include a computer program product comprising a computer program embodied on a computer readable medium, the computer program comprising program code for performing the method illustrated in the flow chart. In such an embodiment, the computer program can be downloaded and installed from a network through the communication section 709, and/or installed from the removable medium 711. The computer program performs the above-described functions defined in the system of the present invention when executed by the Central Processing Unit (CPU) 701.

It should be noted that the computer readable medium shown in the present invention can be a computer readable signal medium or a computer readable storage medium or any combination of the two. A computer readable storage medium may be, for example, but not limited to, an electronic, magnetic, optical, electromagnetic, infrared, or semiconductor system, apparatus, or device, or any combination of the foregoing. More specific examples of the computer readable storage medium may include, but are not limited to: an electrical connection having one or more wires, a portable computer diskette, a hard disk, a Random Access Memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM or flash memory), an optical fiber, a portable compact disc read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the foregoing. In the present invention, a computer readable storage medium may be any tangible medium that can contain, or store a program for use by or in connection with an instruction execution system, apparatus, or device. In the present invention, however, a computer readable signal medium may include a propagated data signal with computer readable program code embodied therein, for example, in baseband or as part of a carrier wave. Such a propagated data signal may take many forms, including, but not limited to, electro-magnetic, optical, or any suitable combination thereof. A computer readable signal medium may also be any computer readable medium that is not a computer readable storage medium and that can communicate, propagate, or transport a program for use by or in connection with an instruction execution system, apparatus, or device. Program code embodied on a computer readable medium may be transmitted using any appropriate medium, including but not limited to: wireless, wire, fiber optic cable, RF, etc., or any suitable combination of the foregoing.

The flowchart 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 flowchart or block diagrams may represent a module, segment, or portion of code, which comprises one or more executable instructions for implementing the specified logical function(s). It should also be noted that, in some alternative implementations, the functions noted in the block may occur out of the order noted in the figures. For example, two blocks shown in succession may, in fact, be executed substantially concurrently, or the blocks may sometimes be executed in the reverse order, depending upon the functionality involved. It will also be noted that each block of the block diagrams or flowchart illustration, and combinations of blocks in the block diagrams or flowchart illustration, can be implemented by special purpose hardware-based systems which perform the specified functions or acts, or combinations of special purpose hardware and computer instructions.

The modules described in the embodiments of the present invention may be implemented by software or hardware. The described modules may also be provided in a processor, which may be described as: a processor comprises an obtaining module, a first packing module and a second packing module. The names of the modules do not form a limitation on the modules themselves in some cases, for example, the acquiring module may also be described as a module that acquires a configuration file and loads the configuration file into a memory.

As another aspect, the present invention also provides a computer-readable medium that may be contained in the apparatus described in the above embodiments; or may be separate and not incorporated into the device. The computer readable medium carries one or more programs which, when executed by a device, cause the device to perform the following: acquiring a configuration file and loading the configuration file into a memory; the configuration file is used for describing the dependency relationship between the business engineering and the dependent items; traversing a first-level dependency item set of business engineering dependencies in the configuration file; for each primary dependent item in the primary dependent item set, under the condition that the package file corresponding to the primary dependent item needs to be constructed, constructing the package file corresponding to the primary dependent item, and caching the package file corresponding to the primary dependent item; pulling the latest code of the business engineering on the target branch; and packaging the latest codes of the business engineering on the target branch and the package files corresponding to the primary dependent items of the business engineering to obtain the package files corresponding to the business engineering.

The above-described embodiments should not be construed as limiting the scope of the invention. Those skilled in the art will appreciate that various modifications, combinations, sub-combinations, and substitutions can occur, depending on design requirements and other factors. Any modification, equivalent replacement, and improvement made within the spirit and principle of the present invention should be included in the protection scope of the present invention.

Claims

1. A local packaging method, the method comprising:

acquiring a configuration file and loading the configuration file into a memory; the configuration file is used for describing the dependency relationship between the business engineering and the dependent items;

traversing a first-level dependency item set of business engineering dependencies in the configuration file; for each primary dependent item in the primary dependent item set, under the condition that the package file corresponding to the primary dependent item needs to be constructed, constructing the package file corresponding to the primary dependent item, and caching the package file corresponding to the primary dependent item;

pulling the latest code of the business engineering on the target branch; and constructing a package file corresponding to the business project according to the latest code of the business project on the target branch and the package file corresponding to each primary dependent item of the business project.

2. The method of claim 1, further comprising:

before the packet file corresponding to the first-level dependent item is constructed and cached, pulling the latest code of the first-level dependent item on a target branch; and confirming that the package file corresponding to the first-level dependent item needs to be constructed under the condition that the latest code of the first-level dependent item on the target branch is updated or the package file corresponding to the first-level dependent item does not exist in the cache.

3. The method of claim 2, further comprising:

and confirming that the package file corresponding to the first-level dependent item is not required to be constructed under the condition that the latest code of the first-level dependent item on the target branch is not updated and the package file corresponding to the first-level dependent item exists in the cache.

4. The method according to claim 1, wherein the constructing and caching the package files corresponding to the level-one dependencies comprises:

traversing a secondary dependency item set on which the primary dependency item depends in the configuration file; for each secondary dependent item in the secondary dependent item set, storing a package file corresponding to the secondary dependent item in a cache into a corresponding folder under the primary dependent item record; and packing the first-level dependent item according to the latest code of the first-level dependent item on the target branch and the package file of each second-level dependent item on which the first-level dependent item depends to obtain the package file corresponding to the first-level dependent item, and then caching the package file corresponding to the first-level dependent item.

5. The method of claim 4, wherein the constructing and caching the package files corresponding to the level-one dependencies further comprises:

and under the condition that the first-level dependent item does not have a dependent second-level dependent item, packing the first-level dependent item according to the latest code of the first-level dependent item on the target branch to obtain a package file corresponding to the first-level dependent item, and then caching the package file corresponding to the first-level dependent item.

6. The method of claim 5, further comprising:

before the step of caching the packet files corresponding to the first-level dependency items, packet extraction is carried out on the packet files corresponding to the first-level dependency items through a packet extraction command, and then the compressed packets obtained through packet extraction are decompressed.

7. The method of claim 1, wherein the primary dependencies in the configuration file are self-developed primary dependencies and the secondary dependencies in the configuration file are self-developed secondary dependencies; the method further comprises the following steps:

installing a third-party primary dependent item which is dependent on the business engineering before the step of constructing a package file corresponding to the business engineering according to the latest code of the business engineering on the target branch and the package file corresponding to each primary dependent item of the business engineering;

and installing a third-party secondary dependent item on which the primary dependent item depends before the step of packaging the primary dependent item according to the latest code of the primary dependent item on the target branch and each secondary dependent item on which the primary dependent item depends.

8. A local packaging apparatus, comprising:

the acquisition module is used for acquiring the configuration file and loading the configuration file into the memory; the configuration file is used for describing the dependency relationship between the business engineering and the dependent items;

the first packing module is used for traversing a first-level dependency item set depended on by the business engineering in the configuration file; the first packing module is further used for establishing a package file corresponding to the first-level dependent item and caching the package file corresponding to the first-level dependent item under the condition that the package file corresponding to the first-level dependent item needs to be established for each first-level dependent item in the first-level dependent item set;

the second packing module is used for pulling the latest codes of the business engineering on the target branch; and the second packaging module is also used for constructing a package file corresponding to the business project according to the latest code of the business project on the target branch and the package file corresponding to each level of dependency item of the business project.

9. An electronic device, comprising:

one or more processors;

a storage device for storing one or more programs,

when executed by the one or more processors, cause the one or more processors to implement the method of any one of claims 1-7.

10. A computer-readable medium, on which a computer program is stored, which program, when being executed by a processor, is adapted to carry out the method of any one of claims 1 to 7.