CN112114859A - File processing method and device and storage medium - Google Patents
File processing method and device and storage medium Download PDFInfo
- Publication number
- CN112114859A CN112114859A CN202010978967.2A CN202010978967A CN112114859A CN 112114859 A CN112114859 A CN 112114859A CN 202010978967 A CN202010978967 A CN 202010978967A CN 112114859 A CN112114859 A CN 112114859A
- Authority
- CN
- China
- Prior art keywords
- job
- jobs
- gitlab
- runner
- submitted
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Pending
Links
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
Landscapes
- Engineering & Computer Science (AREA)
- Software Systems (AREA)
- General Engineering & Computer Science (AREA)
- Theoretical Computer Science (AREA)
- Physics & Mathematics (AREA)
- General Physics & Mathematics (AREA)
- Information Retrieval, Db Structures And Fs Structures Therefor (AREA)
Abstract
The invention discloses a file processing method, a file processing device and a storage medium, wherein the file processing method comprises the following steps: after the project warehouse is submitted by the user, task submission is carried out on the GitLab-Runner by taking jobs as a unit; and after receiving the task submission, the GitLab-Runner executes the submitted job and synchronizes to the corresponding service. The adoption of the invention can invade each stage of the commit action.
Description
Technical Field
The present invention relates to the field of computer technologies, and in particular, to a file processing method, an apparatus, and a storage medium.
Background
The project configuration is managed by the GitLab CI at the present stage using YAML files (. GitLab-ci.yml). This file is stored in the root directory of the project repository and contains descriptive statements of how the project was compiled/published.
YAML uses the agreed formatting pipeline to trigger how to execute the tasks defined in the file. Stage identifiers are mainly used for carrying out Stage division on the Job (operation), and the Stage classifies the contained Job according to the sequence of definition. When the project commit action is triggered, Pipeline performs Job execution completion according to the Stage order, such as: unit testing, code quality detection, project compiling, static resource release and the like.
The prior art is not enough to completely invade the execution stage of Job to each stage of commit action.
Disclosure of Invention
The invention provides a file processing method, a file processing device and a storage medium, which are used for solving the problem that the execution Stage of a Job cannot completely invade each Stage of commit action in the process of carrying out Stage division on the Job by using a Stage identifier for a YAML file.
The embodiment of the invention provides the following technical scheme:
a method of file processing, comprising:
after the project warehouse is submitted by the user, task submission is carried out on the GitLab-Runner by taking jobs as a unit;
and after receiving the task submission, the GitLab-Runner executes the submitted job and synchronizes to the corresponding service.
In the implementation, when the task is submitted to the GitLab-Runner by taking the jobs as a unit, the task is embedded into the integrated file in a unique url mode, wherein the unique url is used for combining all the jobs;
or after the YAML file modularization combination capability is given by integrating the local files in the form of relative paths, modules are divided by using job as a unit.
In an implementation, the method further comprises the following steps:
the execution order of Job is arranged by the link between Job.
In an implementation, the method further comprises the following steps:
and identifying the cache in the jobs, and extracting the cache in each job according to the identification.
In an implementation, the method further comprises the following steps:
and expanding the script of the Job into a script type with a weight identifier, wherein the script is used for being defined by a user and combined into a new execution flow.
A document processing apparatus comprising:
a processor for reading the program in the memory, performing the following processes:
after the project warehouse is submitted by a user, task submission is carried out on the GitLab-Runner by taking jobs as a unit;
after receiving task submission, the GitLab-Runner executes the submitted job and synchronizes to the corresponding service;
a transceiver for receiving and transmitting data under the control of the processor.
In the implementation, when the task is submitted to the GitLab-Runner by taking the jobs as a unit, the task is embedded into the integrated file in a unique url mode, wherein the unique url is used for combining all the jobs;
or after the YAML file modularization combination capability is given by integrating the local files in the form of relative paths, modules are divided by using job as a unit.
In an implementation, the method further comprises the following steps:
the execution order of Job is arranged by the link between Job.
In an implementation, the method further comprises the following steps:
and identifying the cache in the jobs, and extracting the cache in each job according to the identification.
In an implementation, the method further comprises the following steps:
and expanding the script of the Job into a script type with a weight identifier, wherein the script is used for being defined by a user and combined into a new execution flow.
A document processing apparatus comprising:
the submission module is used for submitting the tasks to the GitLab-Runner by using the jobs as a unit after the project warehouse is submitted by the user;
and the execution module is used for executing the submitted job and synchronizing to the corresponding service after the GitLab-Runner receives the task submission.
In implementation, the submission module is further configured to embed a unique url into the integrated file when the job is submitted to the GitLab-Runner in the unit of jobs, where the unique url is used to combine the jobs;
or after the YAML file modularization combination capability is given by integrating the local files in the form of relative paths, modules are divided by using job as a unit.
In an implementation, the execution module is further configured to arrange the execution order of Job according to the relation between jobs.
In implementation, the execution module is further configured to identify the cache in the jobs, and extract the cache in each job according to the identification.
In implementation, the execution module is further configured to expand the script of the Job into a script type with a weight identifier, so as to allow a user to define the script and combine the script into a new execution flow.
A computer-readable storage medium storing a computer program for executing the above-described file processing method.
The invention has the following beneficial effects:
in the technical scheme provided by the embodiment of the invention, because the task is submitted to the GitLab-Runner by taking the Job as a unit, the GitLab-Runner executes the submitted Job and synchronizes to the corresponding service, and because the original scheme of planning the execution sequence of the Job by Stage is abandoned by taking the Job as a unit, the Job is directly taken as a basic unit for control, and the method can invade to each Stage of commit action.
Furthermore, because the caches in the jobs are identified and extracted according to the identifications in each jobs, the caches are identified by adding a form such as id (identification) or name (name) during definition, access is carried out according to needs in each Job execution stage, and the configuration of logout Cache is provided to achieve optimization of performance, thereby overcoming the problem that the Cache cannot be dispersedly managed and can only be centrally defined.
Furthermore, because the execution sequence of the Job is arranged according to the relation between the jobs and the execution sequence of the Job is arranged through the relation between the Job, the problems that the execution actions of the Job can only be executed according to the writing sequence and cannot invade in the task inheritance process and only can be redefined are solved.
Drawings
The accompanying drawings, which are included to provide a further understanding of the invention and are incorporated in and constitute a part of this specification, illustrate embodiments of the invention and together with the description serve to explain the invention and not to limit the invention. In the drawings:
FIG. 1 is a schematic view of a flowchart 1 of a file processing method according to an embodiment of the present invention;
FIG. 2 is a schematic view of a flowchart of a file processing method according to an embodiment of the present invention;
FIG. 3 is a diagram illustrating file merging according to an embodiment of the present invention;
FIG. 4 is a schematic diagram of a document processing apparatus 1 according to an embodiment of the present invention;
FIG. 5 is a diagram of a document processing apparatus 2 according to an embodiment of the present invention.
Detailed Description
The inventor notices in the process of invention that:
the YAML file uses the Stage identification to Stage the Job, and the Stage classifies the contained Job according to the order of definition. And after the project commit action is triggered, the Pipeline executes Job according to the Stage sequence to complete the task. Job, as a minimal execution unit task, has some fields agreed to limit whether and how Job needs to execute at the current time. However, the problem is that the process is designed by combining the execution order of Job with the concept of stage, which causes at least one of the following problems:
1) job's execution phase cannot completely break into the phases of commit actions, such as: the first or last commit stage before merging of the new branch cannot be fully controlled.
2) The distributed management of the Cache cannot be realized, and only centralized definition can be realized, such as: the flow of local caches generated by different Job and the custom management of the whole declaration period can not be processed.
3) Job's execution actions can only be executed in written order, and cannot invade during task inheritance and only can be redefined in a covering manner.
Based on this, in the technical solution provided in the embodiment of the present invention, the original design of combining the execution sequence of the Job by the stage concept is removed, and a design solution for centrally and uniformly managing a plurality of items CI/CD (continuous integration/continuous delivery) flows is provided, so that a more concise control flow can be realized in a manner of modifying, fully updating, and redefining or inheriting and embedding through synonymy. By defining a more perfect appointed configuration design scheme, the controllability of Job execution is enhanced, and a more detailed management strategy is cached.
The following describes embodiments of the present invention with reference to the drawings.
Fig. 1 is a schematic flow chart 1 of an implementation process of a file processing method, as shown in the figure, the implementation process may include:
and 102, after receiving the task submission, executing the submitted job and synchronizing to the corresponding service by the GitLab-Runner.
Fig. 2 is a schematic flow chart 2 of an implementation of a file processing method, as shown in the figure, the implementation may include:
the user submits commit to the project warehouse;
after the project warehouse is submitted by a user, task submission is carried out on a GitLab-Runner (GitLab-Runner) by taking jobs as a unit;
after receiving the task submission, the GitLab-Runner executes the submitted jobs in the cache;
the GitLab-Runner synchronizes to the corresponding service.
This process continues until the last commit before merging.
In the implementation, when the task is submitted to the GitLab-Runner by taking the jobs as a unit, the task is embedded into the integrated file in a unique url mode, wherein the unique url is used for combining all the jobs;
or after the YAML file modularization combination capability is given by integrating the local files in the form of relative paths, modules are divided by using job as a unit.
Specifically, url is used to indicate the location of other job sets, so as to find other job sets scattered elsewhere, and the job has a name or id.
That is, the original agreed format in the YAML file is broken up with Job as the minimum unit, and the YAML file can be embedded and integrated in a unique url (Uniform Resource Locator) manner, and the YAML file modular combination capability can also be given in a manner of integrating local files in a relative path manner. Fig. 3 is a schematic diagram of file merging, and a manner of integrating local files in a form of relative paths is shown in the figure.
In the implementation, the method can further comprise the following steps:
the execution order of Job is arranged by the link between Job.
That is, by discarding the original scheme of planning the execution sequence of the Job by Stage, directly using the Job itself as the basic unit of control, and arranging the execution sequence of the Job through the connection between the Job, by defining a shape as: field names of dependencies, support: job names, Job names + execution state arrays and other forms of marking states, wherein Job and states to be depended on are triggering basis for arranging the execution flow of Job.
In the implementation, the method can further comprise the following steps:
and identifying the cache in the jobs, and extracting the cache in each job according to the identification.
That is, the cache (cache memory) is identified by adding a form such as id (identification) or name (name) during definition, performs on-demand access at each Job execution stage, and provides a configuration for canceling cache to achieve optimization in performance.
In the implementation, the method can further comprise the following steps:
and expanding the script of the Job into a script type with a weight identifier, wherein the script is used for being defined by a user and combined into a new execution flow.
That is, the script (script) of the expanded Job is expanded from the original covering scheme to the script type with the weight identification, so that the original Job can be covered in the task inheritance process, and the original script can be reserved and invaded.
Specifically, in the technical solution provided by the embodiment of the present invention, a capability of combining YAML configuration files is provided, and the original agreed format in the YAML files is broken up with Job as the minimum unit, and the YAML configuration files can be embedded and integrated in a unique url manner, or can be given a modular combination capability in a manner of integrating local files in a relative path manner. The execution sequence of the Job is programmed through the contact between the Job by directly taking the Job as a basic unit of control by discarding the original scheme of planning the execution sequence of the Job through Stage, and by defining a form as follows: field names of dependencies, support: job names, Job names + execution state arrays and other forms of marking states, wherein Job and states to be depended on are triggering basis for arranging the execution flow of Job. The cache is marked by adding a form such as id or name during definition, accesses are carried out according to needs in each Job execution stage, and configuration of cache cancellation is provided to achieve optimization on performance. The script of the expanded Job is expanded from the original covering scheme to a script type with a weight identifier, so that the original Job can be covered in the task inheritance process, and the original script can be reserved and invaded.
In the existing scheme, because the architectural design is defective, the identification mark and the processing flow are not reserved, and the execution phase cannot be completely invaded, so variables such as $ BRANCH _ FIRST _ COMMIT and $ BRANCH _ LAST _ COMMIT can be provided to identify the place where the COMMIT is located, so that a developer can directionally execute some actions in the starting and ending phase to perfect the original flow.
The technical scheme provided by the embodiment of the invention provides a set of more atomization (the original design combining the execution sequence of the Job by the stage concept is removed) on the original design idea, directly designs and arranges the design scheme of the Job, and provides more flexible flow design. And a better cache sharing scheme is provided, the original scheme that only one cache exists in the whole situation is changed into a plurality of cache strategies with id marks, so that the cache is controlled more flexibly in a Job stage, the limitation that only one cache must be extracted at a time is optimized, the given cache can be extracted according to the requirement, and the performance is improved.
The technical solution provided by the embodiment of the present invention is not limited to the implementation details of the YAML format process control process, and any implementation solution similar to that described in the present solution belongs to the scope of protection of the present patent, such as process control, cache control, and configuration mode.
Based on the same inventive concept, the embodiment of the present invention further provides a file processing apparatus and a computer-readable storage medium, and because the principles of these devices for solving the problems are similar to the file processing method, the implementation of these devices can refer to the implementation of the method, and repeated details are not repeated.
When the technical scheme provided by the embodiment of the invention is implemented, the implementation can be carried out as follows.
Fig. 4 is a schematic diagram of a document processing apparatus 1, as shown, including:
the processor 400, which is used to read the program in the memory 420, executes the following processes:
after the project warehouse is submitted by a user, task submission is carried out on the GitLab-Runner by taking jobs as a unit;
after receiving task submission, the GitLab-Runner executes the submitted job and synchronizes to the corresponding service;
a transceiver 410 for receiving and transmitting data under the control of the processor 400.
In the implementation, when the task is submitted to the GitLab-Runner by taking the jobs as a unit, the task is embedded into the integrated file in a unique url mode, wherein the unique url is used for combining all the jobs;
or after the YAML file modularization combination capability is given by integrating the local files in the form of relative paths, modules are divided by using job as a unit.
In an implementation, the method further comprises the following steps:
the execution order of Job is arranged by the link between Job.
In an implementation, the method further comprises the following steps:
and identifying the cache in the jobs, and extracting the cache in each job according to the identification.
In an implementation, the method further comprises the following steps:
and expanding the script of the Job into a script type with a weight identifier, wherein the script is used for being defined by a user and combined into a new execution flow.
Where in fig. 4, the bus architecture may include any number of interconnected buses and bridges, with various circuits of one or more processors, represented by processor 400, and memory, represented by memory 420, being linked together. The bus architecture may also link together various other circuits such as peripherals, voltage regulators, power management circuits, and the like, which are well known in the art, and therefore, will not be described any further herein. The bus interface provides an interface. The transceiver 410 may be a number of elements including a transmitter and a receiver that provide a means for communicating with various other apparatus over a transmission medium. The processor 400 is responsible for managing the bus architecture and general processing, and the memory 420 may store data used by the processor 400 in performing operations.
FIG. 5 is a schematic diagram of a document processing apparatus 2, as shown, including:
a submission module 501, configured to submit a task to the GitLab-Runner in a jobb unit after the project warehouse is submitted by the user;
and the execution module 502 is used for executing the submitted job and synchronizing to the corresponding service after the GitLab-Runner receives the task submission.
In implementation, the submission module is further configured to embed a unique url into the integrated file when the job is submitted to the GitLab-Runner in the unit of jobs, where the unique url is used to combine the jobs;
or after the YAML file modularization combination capability is given by integrating the local files in the form of relative paths, modules are divided by using job as a unit.
In an implementation, the execution module is further configured to arrange the execution order of Job according to the relation between jobs.
In implementation, the execution module is further configured to identify the cache in the jobs, and extract the cache in each job according to the identification.
In implementation, the execution module is further configured to expand the script of the Job into a script type with a weight identifier, so as to allow a user to define the script and combine the script into a new execution flow.
For convenience of description, each part of the above-described apparatus is separately described as being functionally divided into various modules or units. Of course, the functionality of the various modules or units may be implemented in the same one or more pieces of software or hardware in practicing the invention.
A computer-readable storage medium storing a computer program for executing the above-described file processing method.
See in particular the implementation of the document processing method.
In summary, the embodiments of the present invention actually provide a design scheme for a control flow in a CI/CD process, and provide a more controllable execution flow policy to implement accurate task arrangement flow control by modularly configuring YAML files, which is not limited to the implementation manner described in the technical solution. Therefore, 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.
As will be appreciated by one skilled in the art, embodiments of the present invention may be provided as a method, system, or computer program product. Accordingly, the present invention may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present invention may take the form of a computer program product embodied on one or more computer-usable storage media (including, but not limited to, disk storage, optical storage, and the like) having computer-usable program code embodied therein.
The present invention is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems), and computer program products according to embodiments of the invention. It will be understood that each flow and/or block of the flow diagrams and/or block diagrams, and combinations of flows and/or blocks in the flow diagrams and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.
These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.
It will be apparent to those skilled in the art that various changes and modifications may be made in the present invention without departing from the spirit and scope of the invention. Thus, if such modifications and variations of the present invention fall within the scope of the claims of the present invention and their equivalents, the present invention is also intended to include such modifications and variations.
Claims (10)
1. A file processing method, comprising:
after the project warehouse is submitted by a user, task submission is carried out on a GitLab-Runner by taking job jobs as a unit;
and after receiving the task submission, the GitLab-Runner executes the submitted job and synchronizes to the corresponding service.
2. The method of claim 1, wherein upon task submission to the GitLab-Runner in jobs units, the integrated file is embedded by way of a unique uniform resource locator url, wherein the unique url is used to combine the jobs;
or after the YAML file modularization combination capability is given by integrating the local files in the form of relative paths, modules are divided by using job as a unit.
3. The method of claim 1, further comprising:
the execution order of Job is arranged by the link between Job.
4. The method of claim 1, further comprising:
and identifying cache in the cache of the jobs, and extracting the cache in each job according to the identification.
5. The method of claim 1, further comprising:
and expanding the script of the Job into a script type with a weight identifier, wherein the script type is used for the user to define and combine into a new execution flow.
6. A document processing apparatus, characterized by comprising:
a processor for reading the program in the memory, performing the following processes:
after the project warehouse is submitted by a user, task submission is carried out on the GitLab-Runner by taking jobs as a unit;
after receiving task submission, the GitLab-Runner executes the submitted job and synchronizes to the corresponding service;
a transceiver for receiving and transmitting data under the control of the processor.
7. The apparatus of claim 6, further comprising:
and identifying the cache in the jobs, and extracting the cache in each job according to the identification.
8. The apparatus of claim 6, further comprising:
and expanding the script of the Job into a script type with a weight identifier, wherein the script is used for being defined by a user and combined into a new execution flow.
9. A document processing apparatus, characterized by comprising:
the submission module is used for submitting the tasks to the GitLab-Runner by using the jobs as a unit after the project warehouse is submitted by the user;
and the execution module is used for executing the submitted job and synchronizing to the corresponding service after the GitLab-Runner receives the task submission.
10. A computer-readable storage medium, characterized in that the computer-readable storage medium stores a computer program for executing the method of any one of claims 1 to 5.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010978967.2A CN112114859A (en) | 2020-09-17 | 2020-09-17 | File processing method and device and storage medium |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202010978967.2A CN112114859A (en) | 2020-09-17 | 2020-09-17 | File processing method and device and storage medium |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN112114859A true CN112114859A (en) | 2020-12-22 |
Family
ID=73799760
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202010978967.2A Pending CN112114859A (en) | 2020-09-17 | 2020-09-17 | File processing method and device and storage medium |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112114859A (en) |
Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN109086071A (en) * | 2018-08-22 | 2018-12-25 | 平安普惠企业管理有限公司 | A kind of method and server of management software version information |
| CN110213333A (en) * | 2019-04-30 | 2019-09-06 | 北京奇艺世纪科技有限公司 | Task processing method, device, electronic equipment and computer-readable medium |
| CN110225082A (en) * | 2019-04-30 | 2019-09-10 | 北京奇艺世纪科技有限公司 | Task processing method, device, electronic equipment and computer-readable medium |
| KR20190109638A (en) * | 2018-03-05 | 2019-09-26 | 울산과학기술원 | Method for scheduling task in big data analysis platform based on distributed file system, program and computer readable storage medium therefor |
| CN111414302A (en) * | 2020-02-28 | 2020-07-14 | 天津车之家数据信息技术有限公司 | Static code quality analysis method and computing device for continuous integration process |
| CN111488136A (en) * | 2020-04-07 | 2020-08-04 | 携程旅游网络技术（上海）有限公司 | Continuous integration and continuous delivery method, system, device and storage medium |
-
2020
- 2020-09-17 CN CN202010978967.2A patent/CN112114859A/en active Pending
Patent Citations (6)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| KR20190109638A (en) * | 2018-03-05 | 2019-09-26 | 울산과학기술원 | Method for scheduling task in big data analysis platform based on distributed file system, program and computer readable storage medium therefor |
| CN109086071A (en) * | 2018-08-22 | 2018-12-25 | 平安普惠企业管理有限公司 | A kind of method and server of management software version information |
| CN110213333A (en) * | 2019-04-30 | 2019-09-06 | 北京奇艺世纪科技有限公司 | Task processing method, device, electronic equipment and computer-readable medium |
| CN110225082A (en) * | 2019-04-30 | 2019-09-10 | 北京奇艺世纪科技有限公司 | Task processing method, device, electronic equipment and computer-readable medium |
| CN111414302A (en) * | 2020-02-28 | 2020-07-14 | 天津车之家数据信息技术有限公司 | Static code quality analysis method and computing device for continuous integration process |
| CN111488136A (en) * | 2020-04-07 | 2020-08-04 | 携程旅游网络技术（上海）有限公司 | Continuous integration and continuous delivery method, system, device and storage medium |
Non-Patent Citations (1)
| Title |
|---|
| WEIYIGEEK: ""持续集成gitlab-ci.yml配置文档基础"", Retrieved from the Internet <URL:https://mp.weixin.qq.com/s/RpSr5yAG0OfN Xd5R1mFn1w> * |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN109522025B (en) | Code issuing system based on git | |
| CN106708740B (en) | Script testing method and device | |
| CN103714287B (en) | Method and device for obtaining temporary Root authority | |
| CN105630557B (en) | Hot patch method and apparatus | |
| CN104699453B (en) | For changing the method and computer system of the software in the memory of control unit | |
| CN101673374B (en) | Bill processing method and device | |
| US20150248301A1 (en) | Global feature library useable with continuous delivery | |
| CN102193812A (en) | Code compiling method, host computer and system | |
| CN107797819A (en) | Delta package generation method, computer-readable recording medium and server | |
| CN110764839A (en) | Business processing flow configuration method, business request processing method and device | |
| CN104166570B (en) | A kind of method, equipment and the system of online updating file | |
| US11983519B2 (en) | Abort installation of firmware bundles | |
| US9037539B2 (en) | Data synchronization | |
| CN114780138A (en) | Flow field simulation software code version management method and device and storage medium | |
| CN107621963A (en) | A kind of software deployment method, software deployment system and electronic equipment | |
| CN112114859A (en) | File processing method and device and storage medium | |
| Macher et al. | Filling the gap between automotive systems, safety, and software engineering. | |
| CN108334333A (en) | A kind of source code library update method and device | |
| CN110308914B (en) | Upgrade processing method, device, equipment, system and computer readable storage medium | |
| US20150033213A1 (en) | Compiling method, storage medium and compiling apparatus | |
| CN105302604B (en) | The method for updating edition and device of application program | |
| CN111475684B (en) | Data processing network system and calculation chart generation method thereof | |
| CN111078258B (en) | Version upgrading method and device | |
| CN109358868A (en) | A kind of method and system of acquisition terminal software upgrade package life cycle management | |
| CN110737429A (en) | modular compiling method and device utilizing Makefile self-dependent relationship |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination |