CN116610330A - Method and system for quickly constructing iOS development third-party dependence - Google Patents
Method and system for quickly constructing iOS development third-party dependence Download PDFInfo
- Publication number
- CN116610330A CN116610330A CN202211512199.7A CN202211512199A CN116610330A CN 116610330 A CN116610330 A CN 116610330A CN 202211512199 A CN202211512199 A CN 202211512199A CN 116610330 A CN116610330 A CN 116610330A
- Authority
- CN
- China
- Prior art keywords
- container
- host
- party
- file
- party dependent
- 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
- 238000011161 development Methods 0.000 title claims abstract description 41
- 238000000034 method Methods 0.000 title claims abstract description 30
- 230000001419 dependent effect Effects 0.000 claims abstract description 83
- 238000013515 script Methods 0.000 claims abstract description 33
- 239000010437 gem Substances 0.000 claims description 17
- 229910001751 gemstone Inorganic materials 0.000 claims description 17
- 239000010979 ruby Substances 0.000 claims description 16
- 229910001750 ruby Inorganic materials 0.000 claims description 16
- 238000012546 transfer Methods 0.000 claims description 6
- 238000012544 monitoring process Methods 0.000 claims description 5
- 238000010276 construction Methods 0.000 claims description 3
- 238000013507 mapping Methods 0.000 claims description 2
- 238000005516 engineering process Methods 0.000 abstract description 4
- 238000006467 substitution reaction Methods 0.000 abstract description 3
- 238000009434 installation Methods 0.000 description 14
- 238000010586 diagram Methods 0.000 description 9
- 230000009286 beneficial effect Effects 0.000 description 1
- 238000004590 computer program Methods 0.000 description 1
- 230000007547 defect Effects 0.000 description 1
- 230000007812 deficiency Effects 0.000 description 1
- 230000006870 function Effects 0.000 description 1
- 230000015654 memory Effects 0.000 description 1
- 230000004044 response Effects 0.000 description 1
- 238000012552 review Methods 0.000 description 1
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/60—Software deployment
- G06F8/61—Installation
- G06F8/63—Image based installation; Cloning; Build to order
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/60—Software deployment
- G06F8/65—Updates
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/70—Software maintenance or management
- G06F8/71—Version control; Configuration management
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal 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)
- Computer Security & Cryptography (AREA)
- Stored Programmes (AREA)
Abstract
The invention discloses a method and a system for quickly constructing dependence of an iOS development third party. In the scenario of building an iOS development environment for cooapeds, a containerized third party dependent deployment environment is provided through dock technology. And the third-party dependence is updated in real time through the Gitlab Runner, so that the substitution code script can be quickly pulled on the development machine under the condition that the third-party dependence environment is not deployed.
Description
Technical Field
The present invention relates to information technology, and more particularly to application development on mobile devices.
Background
In the iOS software development process, some open source codes or third-party dependencies provided in a library manner are often used, for example, an afnetwork requests basic service classes, and WeChat sharing SDKs provided by WeChat are used. These third party dependencies can reduce the workload of the developer and some are what the development must rely on. In summary, developers need to manage these third party libraries. In iOS development, management tools such as Cocoapods, carthage and Swift Package Manager, which are dependent by third parties, are being created.
By way of example, the use of Cocoaps to manage third-party dependent projects, the Cocoaps to uniformly manage third-party dependent source code or libraries, and developers need to install numerous related software packages on their own development machines before using the Cocoaps. The relevant software is: ruby, homebrew, rvm, gem, cocoapods. Before using Cocoapods to manage third party dependencies, it is also necessary to pull all of the contents of the remote index repository repo of Cocoapods onto the development machine, which is a very slow operation. After the whole process is completed, the development environment is built.
Accordingly, there is a need for methods and systems that ameliorate the deficiencies of the prior art.
Disclosure of Invention
This summary is provided to introduce a selection of concepts in a simplified form that are further described below in the detailed description. This summary is not intended to identify key features or essential features of the claimed subject matter, nor is it intended to be used as an aid in determining the scope of the claimed subject matter.
Aiming at the technical problems in the prior art, the technical scheme in the disclosure provides a containerized third-party dependent deployment environment through a dock technology under the scene of building an iOS development environment aiming at Cocoamps. And the third-party dependence is updated in real time through the Gitlab Runner, so that the substitution code script can be pulled quickly under the condition that the third-party dependence environment is not deployed.
Therefore, the technical scheme of the invention can improve the environment construction speed of the Cocoaps third party dependence, uniformly manage the software and the software version required by the Cocoaps third party dependence, and provide the Cocoaps third party dependence environment capable of being transplanted rapidly.
Specifically, in one embodiment of the present invention, a method for quickly building an iOS development third party dependency is provided, the method comprising:
establishing a mirror image containing a third party dependent file based on a docker;
installing the mirror at the host and starting the mirrored container;
installing a gitlabrunner on the host to update the third party dependent files in the container in real time by concatenating the gitlab code bins; and
and deploying the engineering files containing the latest third-party dependent files in the host machine to the development machine through updating scripts.
In one embodiment of the invention, the image has the following environment: ruby, rvm, gem, cocoapods, git, homebrew, and building an image containing the third party dependent file further comprises:
downloading Ubuntu images in a docker official image market;
a container for starting the Ubuntu image;
installing ruby, rvm, gem, cocoapods, git, homebrew in the container;
exporting a container having third party dependent files installed for startup at the host; and
and generating an image file with the third party dependent file installed.
In one embodiment of the invention, installing the mirror at the host and starting the mirrored container further comprises:
setting up a dock running environment; and
executing the docker execution command to build the host map project catalog and the container project catalog.
In one embodiment of the invention, updating the third party dependent file in the container in real time is accomplished by:
recording a runner URL and a token in the gitlab CI setting of the gitlab code bin for the host to register for real-time updating;
configuring a gitlabrunner at the host to register real-time update snooping for the gitlabcode bin;
monitoring the Podfile and the Podfile.lock file changes in the third-party dependent file in the engineering warehouse of the gitlab code bin by using the gitlabrunner; and
adding a gitlab-ci.yml under the engineering root directory of the gitlab code bin for executing a script for updating the third party dependent file after the host monitors the engineering file update.
In one embodiment of the invention, the update script is a file transfer command.
In one embodiment of the invention, further comprising on another developer needing to update the third party dependent file:
installing the mirror image;
starting the container; and
third party dependent environments are managed uniformly through the container.
In another embodiment of the present invention, there is provided a system for quick build of iOS development third party dependencies, the system comprising:
a mirror module configured to build a mirror comprising a third party dependent file based on a docker;
a gitlab code bin configured to synchronize the third party dependent file with the host;
a host, comprising:
a container module configured to enable the mirrored container by installing the mirrored container at the host
A third party dependent software environment for iOS development is deployed by the server;
a dock module configured to provide an operating environment for the container by:
setting up a dock running environment; and
executing a docker execution command to construct a host mapping project directory and a container project directory;
a gitlabrunner module configured to install a gitlabrunner on the host to update the third party dependent files in the container in real time by concatenating the gitlabcode bins; and
an update script module configured to enable deployment of an engineering file in the host machine containing the most current third party dependent file onto the developer machine by updating the script.
In one embodiment of the invention, the image has the following environment: ruby, rvm, gem, cocoapods, git, homebrew, and the mirroring module is further configured to build a mirror comprising third party dependent files by:
downloading Ubuntu images in a docker official image market;
a container for starting the Ubuntu image;
installing ruby, rvm, gem, cocoapods, git, homebrew in the container;
exporting a container having third party dependent files installed for startup at the host; and
and generating an image file with the third party dependent file installed.
In one embodiment of the invention, the gitlabrunner module is further configured to update the third party dependent file in the container in real time by:
recording a runner URL and a token in the gitlab CI setting of the gitlab code bin for the host to register for real-time updating;
configuring a gitlabrunner at the host to register real-time update snooping for the gitlabcode bin;
monitoring the Podfile and the Podfile.lock file changes in the third-party dependent file in the engineering warehouse of the gitlab code bin by using the gitlabrunner; and
adding a gitlab-ci.yml under the engineering root directory of the gitlab code bin for executing a script for updating the third party dependent file after the host monitors the engineering file update.
In one embodiment of the invention, the container includes the mirror image and the container engineering catalog.
In yet another embodiment of the present invention, a computer-readable medium storing computer-executable instructions is provided, the instructions comprising:
instructions for building a mirror image comprising a third party dependent file based on a docker;
instructions for installing the mirror at the host and starting a container of the mirror;
instructions for installing a gitlabrunner on the host to update the third party dependent files in the container in real time by concatenating the gitlabcode bins; and
instructions for deploying an engineering file in the host machine containing the latest third party dependent file to the developer by updating the script.
Other aspects, features and embodiments of the present invention will become apparent to those ordinarily skilled in the art upon review of the following description of specific exemplary embodiments of the invention in conjunction with the accompanying figures. Although features of the invention may be discussed below with respect to certain embodiments and figures, all embodiments of the invention may include one or more of the advantageous features discussed herein. In other words, while one or more embodiments may be discussed as having certain advantageous features, one or more of such features may also be used in accordance with the various embodiments of the invention discussed herein. In a similar manner, although exemplary embodiments may be discussed below as device, system, or method embodiments, it should be appreciated that such exemplary embodiments may be implemented in a variety of devices, systems, and methods.
Drawings
So that the manner in which the above recited features of the present disclosure can be understood in detail, a more particular description of the invention, briefly summarized above, may be had by reference to aspects, some of which are illustrated in the appended drawings. It is to be noted, however, that the appended drawings illustrate only certain typical aspects of this disclosure and are therefore not to be considered limiting of its scope, for the description may admit to other equally effective aspects.
FIG. 1 illustrates a schematic block diagram of an implementation environment of a system for quick build of iOS development third party dependencies, according to one embodiment of the disclosure.
FIG. 2 shows a schematic block diagram of a docker mirror according to one embodiment of the present disclosure.
FIG. 3 illustrates a detailed block diagram of a system for quick build of iOS development third party dependencies, according to one embodiment of the disclosure.
FIG. 4 illustrates a flow chart of a method for quick build-up of iOS development third party dependencies, according to one embodiment of the disclosure.
Detailed Description
Various embodiments will be described in greater detail below with reference to the accompanying drawings, which form a part hereof, and which illustrate specific exemplary embodiments. Embodiments may, however, be embodied in many different forms and should not be construed as limited to the embodiments set forth herein; rather, these embodiments are provided so that this disclosure will be thorough and complete, and will fully convey the scope of these embodiments to those skilled in the art. Embodiments may be implemented in a method, system, or apparatus. Accordingly, the embodiments may take the form of a hardware implementation, an entirely software implementation, or an implementation combining software and hardware aspects. The following detailed description is, therefore, not to be taken in a limiting sense.
The steps in the flowcharts may be performed by hardware (e.g., processors, engines, memories, circuits), software (e.g., operating systems, applications, drivers, machine/processor executable instructions), or a combination thereof. As will be appreciated by one of ordinary skill in the art, the methods involved in the various embodiments may include more or fewer steps than shown.
Aiming at the defects in the prior art, the technical scheme of the invention puts the environment on which the Cocoaps third party depends into a dock container through the dock container technology, synchronizes the change of the Cocoaps third party dependence through the Gitleb Runner, updates the Cocoaps third party dependence in real time, and finally pulls the built Cocoaps third party dependence from the container through a script. Through a combination of the above operations. The method can achieve the beneficial effects of improving the environment construction speed of the Cocoaps third party dependence, centrally managing the software and the software version required by the Cocoaps third party dependence and providing the Cocoaps third party dependence environment capable of being transplanted quickly.
Aspects of the present disclosure are described in greater detail below with respect to block diagrams and method flowcharts.
FIG. 1 illustrates a schematic block diagram of an implementation environment of a system for quick build of iOS development third party dependencies, according to one embodiment of the disclosure.
As shown in FIG. 1, a system for quickly building third party dependencies for iOS development according to one embodiment of the invention may include a mirroring module 102, a host 104, an update script module 106, and a gitlab code store 108. In this implementation environment, two development machines are also included, namely development machine A116 and development machine B118, that interact with the system for quick build of iOS development third party dependencies.
In one embodiment of the invention, the mirroring module 102 may be configured to build a mirror containing third party dependent files based on a docker. In this embodiment of the invention, the mirror may be a docker mirror, or any other suitable mirror.
FIG. 2 shows a schematic block diagram of a docker mirror according to one embodiment of the present disclosure. As shown in fig. 2, the following third party dependent environments are included in the dock mirror image: ruby, rvm, gem, cocoapods, git, homebrew. As will be appreciated by those skilled in the art, the image may include any other suitable third party dependent environment in addition to the environments described above.
Returning to FIG. 1, the mirroring module 102 may be further configured to build a mirror containing third party dependent files by: downloading the mirror image; the mirrored container is started and entered, ruby, rvm, gem, cocoapods, git, homebrew is installed in the container, and then the container and mirrored file are exported for installation on host 104.
In one embodiment of the invention, host 104 may include a container module 110, a docker module 112, and a gitlabrunner module 114. The container module 110 may be configured to deploy a third party dependent software environment for iOS development by installing a mirror at the host 104 and launching a container of the mirror, thereby providing a containerized third party dependent deployment environment.
In one embodiment of the invention, the docker module 112 may be configured to provide the runtime environment of the container by building a docker runtime environment and running the docker execution commands.
In one embodiment of the invention, the gitlabrunner module 114 may be configured to install a gitlabrunner on the host 104 to update the third party dependent files in the container in real time by concatenating the gitlabcode bins 108. Thus, the host 104 can synchronize changes in the Cocoaps third party dependencies with the gitlab code store 108, thereby enabling real-time updates to the Cocoaps third party dependencies file.
In one embodiment of the invention, the gitlab code store 108 may be configured to synchronize third party dependent files with hosts 1-4.
In another embodiment of the present invention, the gitlabrunner module 114 may be further configured to update the third party dependent files in the container in real time by: recording a runner URL and a token in a gitlab CI setting of the gitlab code bin 108 for registration by the host 104 for real-time updating, configuring a gitlabrunner at the host 104 to register for real-time update listening to the gitlab code bin 108, listening to changes in Podfile and podfile.lock files in a third party dependent file in an engineering repository of the gitlab code bin 108 using the gitlabrunner, and adding a gitlab-ci.yml under an engineering root directory of the gitlab code bin for executing a script for updating the third party dependent file after the host 104 listens to the engineering file update.
In one embodiment of the invention, the update script module 106 may be configured to enable the deployment of engineering files in the host 104 containing the latest third party dependent files onto the developer A116 via the update script. Thus, developer A116 can develop by pulling the engineering file containing the latest third party dependencies updated in real time on the host by the update script.
In another embodiment of the present invention, developer B118, which needs to update the third party dependencies, may install the image, launch the container, and manage the third party dependencies through the cobaaps in the dock.
In one embodiment of the present invention, after the container is deployed at host 104, developer A116 updates the project file from the dock container using the update script module, only consuming the time of file network transfer, with an overall time deployment time of less than 5 minutes. Development machine B118, which needs to manage third party dependencies, also only needs to start the dock mirror at the development machine, install and start the dock mirror and the container for 1 hour overall, while the time to directly deploy the third party environment is two workdays.
FIG. 3 illustrates a detailed block diagram of a system for quick build of iOS development third party dependencies, according to one embodiment of the disclosure. How the third party dependencies for iOS development are quickly built by the system of the present invention will be described in detail below in the form of an operational flow.
First, a mirror image of a third party dependent file based on a dock is built. As shown in fig. 2, there are the following environments in the dock mirror: ruby, rvm, gem, cocoapods, git, homebrew. The machines used to build the image may include, but are not limited to, computers of the Windows, linux system, mac OS system.
Specifically, the Ubuntu-functional network image may be downloaded at the docker official image market, the container of the Ubuntu image started, and entered into the container. Subsequently, in order to install the respective environments, the following operations may be performed:
ruby is installed, taking the Ubuntu system of Linux as an example, the installation manner may be, but is not limited to, the following manner:
the following command installations are run at the Ubuntu terminal:
sudo apt-get install ruby；
as an example of the Linux Ubuntu system, the installation rvm may be, but is not limited to, the following:
the following command installations are respectively operated at the Ubuntu terminal:
1.curl-L get.rvm.io|bash-s stable
2.gpg2--recv-keys 409B6B1796C275462A1703113804BB82D39DC0E3
3.curl-L get.rvm.io|bash-s stable
4.source/usr/local/rvm/scripts/rvm
5.rvm list known；
the gem is installed, taking the Ubuntu system of Linux system as an example, the installation mode can be, but is not limited to, the following modes:
the following command installations are respectively operated at the Ubuntu terminal:
sudo apt-get install rubygems；
installing the cobaaps, taking the Ubuntu system of Linux as an example, the installation mode may be, but is not limited to, the following modes:
the following command installations are run at the Ubuntu terminal:
sudo apt-get install build-essential patch ruby-dev zlib1g-dev liblzma-dev
gem install nokogiri
sudo gem install cocoapods；
mounting git, taking the Ubuntu system of Linux system as an example, the mounting mode can be but is not limited to the following modes:
the following command installations are run at the Ubuntu terminal:
sudo apt-get install git；
the homebrew is installed, taking the Ubuntu system of Linux as an example, the installation method can be, but is not limited to, the following ways:
the following command installations are respectively operated at the Ubuntu terminal:
1.sudo/bin/bash-c"$(curl-fsSLhttps://raw.githubusercontent.com/Homebrew/install/master/install.sh)"
2.echo'eval"$(/home/linuxbrew/.linuxbrew/bin/brew shellenv)"'>>
/home/sherlma/.profile
3.eval"$(/home/linuxbrew/.linuxbrew/bin/brew shellenv)"
4.sudo apt-get install build-essential
5.sudo apt install linuxbrew-wrapper
after these environments are installed, the container with the third party dependent file installed can be exported, and the image file with the third party dependent file installed can be generated and exported for installation of the image on the host and for starting of the container.
Next, a host for deploying the third party dependent environment is built and a docker container is started. The host may include, but is not limited to, a computer of Windows, linux, mac OS system. As shown in FIG. 3, the host installs the built mirror image, and starts the container comprising the mirror image and the engineering catalog, so that the Cocoaps third party dependent environment can be uniformly managed through the dock container of the host. Specifically, the steps include building a dock runtime environment, which may include, but is not limited to, installing from https:// download. The container that executes the built image and initiates the image may include, but is not limited to, the following:
executing a docker execution command at the Ubuntu terminal to construct a host map project directory and a container project directory: dock run-itd- -restart=always- -privileged=true- -name response-p 3022:22-p 3080:80-p 3043:443-p 3081:3081-v [ host map engineering catalog ]: [ container engineering catalog ] response 0.0.1.
Then, a gitlabrunner module is built in the host machine, as shown in fig. 3, for example, by using the gitlabrunner to monitor the change of Podfile and Podfile.lock files in the third-party dependence in the engineering warehouse, the cooapeds third-party dependence environment in the dock container can be updated in real time by using the gitlabrunner script. Specifically, in one embodiment of the present invention, to achieve the above operation, installing the gitlabrunner on the host may include, but is not limited to, the following ways:
the following command installations are run at the Ubuntu terminal:
1.curl-L--output/usr/local/bin/gitlab-runner
https://gitlab-runner-downloads.s3.amazonaws.com/latest/binaries/gitlab-runner-lin ux-amd64
2.chmod+x/usr/local/bin/gitlab-runner
3.useradd--comment'GitLab Runner'--create-home 4.gitlab-runner--shell
/bin/bash
5.gitlab-runner install--user＝gitlab-runner
--working-directory＝/home/gitlab-runner
starting the gitlabrunner by a gitlab-runner start and recording a runner URL and token in the gitlabci setting of the gitlabcode bin for registration by the host for real-time update, configuring the gitlabrunner at the host 104 to register for real-time update listening to the gitlabcode bin 108 may include, but is not limited to, the following:
the following commands are run at the Ubuntu terminal:
the method comprises the steps of adding a gitlab-runner register-URL-registration-token under the engineering root directory of the gitlab code bin for executing a script for updating a third party dependent file after the host 104 listens to the engineering file update. The following is an example of a gitlab-ci.yml document:
stages:
-build
build_job:
statge:build
script:docker exec espod bash-c"cd/home/workspaces/[project name]&&pod install"。
after the host machine is built, an update script module can be built. As shown in FIG. 3, the engineering file may be updated to the development machine by writing an update script on the development machine. The update script may include, but is not limited to, a file transfer command, scp, rsync, wget, etc., to transfer the host file to the development machine, the following are script examples:
if[x"$1"＝x]；
then
echo"will deploy in"`pwd`
scp-P3022-r [ host user name ] @ [ host IP ]: [ host machine working path ]/[ project name ]/' pwd ]
else
echo"will deploy in"$1
scp-P3022-r [ host user name ] @ [ host IP ]: host machine working path ]/[ project name ]/$1
fi
Finally, as shown in fig. 3, there is a development machine that needs to update the third-party dependence, and the development machine can be installed on the mirror image built on the host, and the container is started, and the cooapods third-party dependence environment is uniformly managed through the dock container of the host.
FIG. 4 illustrates a flow diagram of a method 400 for quick build-up of iOS development third party dependencies, according to one embodiment of the disclosure.
As shown in FIG. 4, method 400 begins at step 402 by building a mirror image containing a third party dependent file based on a docker. In one embodiment of the invention, the image has the following environment: ruby, rvm, gem, cocoapods, git, homebrew, and building an image containing the third party dependent file further comprises: downloading Ubuntu images in a docker official image market; a container for starting the Ubuntu image; installing ruby, rvm, gem, cocoapods, git, homebrew in the container; exporting a container having third party dependent files installed for startup at the host; and generating an image file with the third party dependent file installed.
Subsequently, the method 400 continues to step 404 where the mirrored container is installed and started at the host. In one embodiment of the invention, installing the mirror at the host and starting the mirrored container further comprises: setting up a dock running environment; and running a docker execution command to build a host map project directory and a container project directory.
The method 400 then continues to step 406 where a gitlabrunner is installed on the host to update the third party dependent files in the container in real time by concatenating the gitlabcode bins. In one embodiment of the invention, updating the third party dependent file in the container in real time is accomplished by: recording a runner URL and a token in the gitlab CI setting of the gitlab code bin for the host to register for real-time updating; configuring a gitlabrunner at the host to register real-time update snooping for the gitlabcode bin; monitoring the Podfile and the Podfile.lock file changes in the third-party dependent file in the engineering warehouse of the gitlab code bin by using the gitlabrunner; and adding a gitlab-ci.yml under the engineering root directory of the gitlab code bin for executing a script for updating the third party dependent file after the host monitors the engineering file update.
Finally, the method continues to step 408 where the engineering file in the host machine containing the latest third party dependent file is deployed to the developer by updating the script. In one embodiment of the invention, the update script is a file transfer command. In one embodiment of the invention, further comprising on another developer needing to update the third party dependent file: installing the mirror image; starting the container; and uniformly managing the third party dependent environment through the container.
In summary, the technical scheme of the invention realizes the purpose of rapidly deploying the coupes third-party dependent environment and uniformly managing the third-party dependent software version number by constructing an iOS development environment based on the third-party dependence of the dockers and the coupes.
Embodiments of the present invention have been described above with reference to block diagrams and/or operational illustrations of methods, systems, and computer program products according to embodiments of the invention. The various functions/acts noted in the blocks may occur out of the order noted in the flowcharts. 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/acts involved.
The present invention is not limited to the above-mentioned embodiments, and any changes or substitutions that can be easily understood by those skilled in the art within the technical scope of the present invention are intended to be included in the scope of the present invention. Therefore, the protection scope of the present invention should be subject to the protection scope of the claims.
Claims (10)
1. A method for quick construction of iOS development third party dependencies, the method comprising:
establishing a mirror image containing a third party dependent file based on a docker;
installing the mirror at the host and starting the mirrored container;
installing a gitlabrunner on the host to update the third party dependent files in the container in real time by concatenating a gitlab code bin; and
and deploying the engineering files containing the latest third-party dependent files in the host machine to the development machine through updating scripts.
2. The method of claim 1, wherein the mirror has the following environment: ruby, rvm, gem, cocoapods, git, homebrew, and building an image containing the third party dependent file further comprises:
downloading Ubuntu images in a docker official image market;
starting the container of the Ubuntu mirror image;
installing ruby, rvm, gem, cocoapods, git, homebrew in the container;
exporting the container with the third party dependent file installed for startup at the host; and
and generating an image file with the third party dependent file installed.
3. The method of claim 1, wherein installing the mirror at a host and starting the mirrored container further comprises:
setting up a dock running environment; and
executing the docker execution command to build the host map project catalog and the container project catalog.
4. The method of claim 1, wherein updating the third party dependent file in the container in real time is accomplished by:
recording a runner URL and a token in the gitlab CI setting of the gitlab code bin for the host to register and update in real time;
configuring a gitlabrunner at the host to register real-time update snooping of the gitlabcode bin;
monitoring the change of Podfile and Podfile.lock files in a third-party dependent file in an engineering warehouse of the gitlab code bin by using the gitlabrunner; and
and adding a gitlab-ci.yml under the engineering root directory of the gitlab code bin for executing a script for updating the third party dependent file after the host monitors the engineering file update.
5. The method of claim 1, wherein the update script is a file transfer command.
6. The method of claim 1, further comprising, on another developer that needs to update the third party dependent file:
installing the mirror image;
starting the container; and
and uniformly managing the third party dependent environment through the container.
7. A system for quick build-up of iOS development third party dependencies, the system comprising:
a mirror module configured to build a mirror comprising a third party dependent file based on a docker;
a gitlab code bin configured to synchronize the third party dependent file with the host;
a host, comprising:
a container module configured to deploy a third party dependent software environment for iOS development by installing the mirror at the host and launching a container of the mirror;
a dock module configured to provide a running environment for the container by:
setting up a dock running environment; and
executing a docker execution command to construct a host mapping project directory and a container project directory;
a gitlabrunner module configured to install a gitlabrunner on the host
To update the third party dependent file in the container in real time by concatenating the gitlab code bins; and
an update script module configured to enable deployment of engineering files in the host machine containing the most up-to-date third party dependent files onto a developer through the update script.
8. The system of claim 7, wherein the mirror has the following environment: ruby, rvm, gem, cocoapods, git, homebrew, and the mirroring module is further configured to build the mirror containing the third party dependent file by:
downloading Ubuntu images in a docker official image market;
starting the container of the Ubuntu mirror image;
installing ruby, rvm, gem, cocoapods, git, homebrew in the container;
exporting the container with the third party dependent file installed for startup at the host; and
and generating an image file on which the third-party dependent file is installed.
9. The system of claim 7, wherein the gitlabrunner module is further configured to update the third party dependent files in the container in real time by:
recording a runner URL and a token in the gitlab CI setting of the gitlab code bin for the host to register and update in real time;
configuring a gitlabrunner at the host to register real-time update snooping of the gitlabcode bin;
monitoring the change of Podfile and Podfile.lock files in a third-party dependent file in an engineering warehouse of the gitlab code bin by using the gitlabrunner; and
and adding a gitlab-ci.yml under the engineering root directory of the gitlab code bin for executing a script for updating the third party dependent file after the host monitors the engineering file update.
10. The system of claim 7, wherein the container comprises the mirror image and the container engineering catalog.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211512199.7A CN116610330A (en) | 2022-11-29 | 2022-11-29 | Method and system for quickly constructing iOS development third-party dependence |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN202211512199.7A CN116610330A (en) | 2022-11-29 | 2022-11-29 | Method and system for quickly constructing iOS development third-party dependence |
Publications (1)
| Publication Number | Publication Date |
|---|---|
| CN116610330A true CN116610330A (en) | 2023-08-18 |
Family
ID=87675208
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN202211512199.7A Pending CN116610330A (en) | 2022-11-29 | 2022-11-29 | Method and system for quickly constructing iOS development third-party dependence |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN116610330A (en) |
Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN109981351A (en) * | 2019-03-06 | 2019-07-05 | 浪潮通用软件有限公司 | A kind of private clound dispositions method |
| CN111061487A (en) * | 2019-12-16 | 2020-04-24 | 厦门市美亚柏科信息股份有限公司 | Container-based load balancing distributed compiling system and method |
| US20200293354A1 (en) * | 2018-02-12 | 2020-09-17 | Genetalks Bio-Tech (Changsha) Co., Ltd. | Container dockerfile and container mirror image quick generation methods and systems |
-
2022
- 2022-11-29 CN CN202211512199.7A patent/CN116610330A/en active Pending
Patent Citations (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20200293354A1 (en) * | 2018-02-12 | 2020-09-17 | Genetalks Bio-Tech (Changsha) Co., Ltd. | Container dockerfile and container mirror image quick generation methods and systems |
| CN109981351A (en) * | 2019-03-06 | 2019-07-05 | 浪潮通用软件有限公司 | A kind of private clound dispositions method |
| CN111061487A (en) * | 2019-12-16 | 2020-04-24 | 厦门市美亚柏科信息股份有限公司 | Container-based load balancing distributed compiling system and method |
Non-Patent Citations (1)
| Title |
|---|
| ╰つ栺尖篴夢ゞ: "iOS之深入解析CocoaPods的GitLab CI与组件自动化构建与发布", pages 196 - 202, Retrieved from the Internet <URL:https://blog.csdn.net/Forever_wj/article/details/124024658> * |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| KR100952251B1 (en) | Servicing a component base software product | |
| US7814476B2 (en) | Systems and methods for updating software | |
| US8010504B2 (en) | Increasing application availability during automated enterprise deployments | |
| US8392906B2 (en) | Enabling parallel websphere runtime versions | |
| US9250672B2 (en) | Cloning target machines in a software provisioning environment | |
| US8352916B2 (en) | Facilitating the automated testing of daily builds of software | |
| US20120144391A1 (en) | Provisioning a virtual machine | |
| US10673944B2 (en) | Synchronization of components in heterogeneous systems | |
| US10715594B2 (en) | Systems and methods for update propagation between nodes in a distributed system | |
| CN111966423B (en) | Method and equipment for realizing memory operating system | |
| US20090089778A1 (en) | User-specified install locations | |
| US20120239975A1 (en) | Reducing Application Downtime During Failover | |
| CN115421740A (en) | Deployment method and device of cloud native application | |
| US8630982B2 (en) | Individual object restore | |
| US11385923B2 (en) | Container-based virtualization system extending kernel functionality using kernel modules compiled by a compiling container and loaded by an application container | |
| CN112379934B (en) | Deployment method and device of cloud computing platform and storage medium | |
| US20180225105A1 (en) | Mechanism for customizing multiple computing devices | |
| US20060206458A1 (en) | Serving program elements through a unified interface | |
| CN116610330A (en) | Method and system for quickly constructing iOS development third-party dependence | |
| US20140282527A1 (en) | Applying or Removing Appropriate File Overlays During Live Application Mobility | |
| US10185574B2 (en) | Live imaging of a device | |
| CN115495279A (en) | Method, electronic device and computer program product for data protection | |
| CN109542467A (en) | The configuration method in the source yum under a kind of linux system | |
| Kövi et al. | OpenSAF Virtual Machine for ISAS 2008 |
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 |