Method, system and equipment for integrating Windows XP node with Gitlab CI

Abstract

The invention relates to a method, a system and equipment for integrating a Windows XP node with Gitlab CI. The method comprises the following steps of: installing a client tool of a Jenkins command line interface on a gitlab run node; the method comprises the following steps of: adding a Jenkins node of which the operating system is Windows XP on a Jenkins server, and establishing a connection between the node and the Jenkins server; the method comprises the following steps of: configuring a credential of a gitlab account number in a Jenkins server, and creating a Jenkins assembly line; and creating an assembly line in the gilab CI, and calling the Jenkins assembly line of which the operating system is Windows XP by the gilab run node through the Jenkins command line interface. Compared with the prior art, the method has the advantages that the GitLab CI is integrated with the windows XP node, the software development efficiency is improved and the like.

Description

Technical Field

[0001] The present invention relates to the technical field of software development, and in particular to a method, system and device for integrating Windows XP nodes with GitLab CI. Background Art

[0002] In today's software development field, Continuous Integration (CI) and Continuous Deployment (CD) have become key practices for improving development efficiency and ensuring software quality. Continuous Integration is a software development practice that requires development team members to frequently merge their code changes into a shared code repository, usually multiple times a day. After each merge, a series of build and test processes are automatically triggered. GitLab CI is a continuous integration service provided by GitLab, which executes various build, test and deployment tasks by installing GitLab runners in nodes. However, the current common problem is that GitLab runner is developed based on the Go language, and its own architecture and dependencies determine that it does not support the Windows XP operating system.

[0003] The Gitflow workflow is a management, development, maintenance, and release workflow for teams using Git as a source code management tool. It defines a rigorous branch management model for project release maintenance and provides a robust management framework for large projects. The Gitflow workflow defines strict functional roles for each specified branch, defines clear tasks for each branch, specifies when to execute pipeline tasks, and the Gitflow workflow will use independent branches to be responsible for maintenance, development, release, etc. Although, another mainstream continuous integration tool, Jenkins, supports integrating Windows XP nodes into the pipeline, it cannot be directly integrated with GitLab CI and meet the Gitflow workflow.

[0004] Due to the above reasons, for projects that still use the Windows XP operating system for software development, integrating Windows XP with GitLab CI is still a difficult point.

[0005] After retrieval, Chinese Invention Application Publication No. CN119225741A discloses a pipeline release method and system based on agile development to support multiple deployment modes. When deploying, the application program is built into a Docker image and the image is deployed to a K8S cluster to shield the differences in operating systems. This existing invention application does not involve the GitLab pipeline and does not solve the problem of integrating Windows XP nodes with GitLab CI.

[0006] How to implement Gitlab CI integration with Windows XP nodes has become a technical problem to be solved. Summary of the Invention

[0007] The purpose of the present invention is to overcome the defects existing in the above-mentioned prior art and provide a method, system and device for Gitlab CI to integrate Windows XP nodes.

[0008] The purpose of the present invention can be achieved by the following technical solutions:

[0009] According to one aspect of the present invention, a method for Gitlab CI to integrate Windows XP nodes is provided, and the method includes:

[0010] Install the client tool of the Jenkins command line interface on the gitlab runner node;

[0011] Add a Jenkins node with the operating system of Windows XP to the Jenkins Server and establish a connection between this node and the Jenkins server;

[0012] Configure the credentials of the gitlab account in the Jenkins server and create a Jenkins pipeline;

[0013] And create a pipeline in Gitlab CI, and the gitlab runner node calls the Jenkins pipeline with the operating system of Windows XP through the Jenkins command line interface.

[0014] Preferably, the windows operating system of the gitlab runner node is different from the operating system of the Jenkins node; the operating system of the gitlab runner node is windows 10.

[0015] More preferably, the method further includes installing gitlab runner on the gitlab runner node and registering the gitlab runner to the gitlab server; and installing JDK on the gitlab runner node.

[0016] Preferably, the Jenkins node installs JDK.

[0017] More preferably, the JDK version is jdk 8.

[0018] Preferably, a pipeline is created using a pipeline script in the Jenkins server.

[0019] Preferably, the Jenkins pipeline is invoked through the Jenkins command-line interface based on the configured gitlab-ci.yml file, including invoking the Jenkins pipeline in the build phase and the scan phase.

[0020] More preferably, the configuration of the gitlab-ci.yml file includes setting the IP address of the Jenkins node and the directory of the network shared folder of the Jenkins node.

[0021] More preferably, the network shared folder is used for the gitlab runner node to obtain the output files or reports of compilation or code scanning from the Jenkins node in the form of shared files.

[0022] According to another aspect of the present invention, a system for integrating a Windows XP node into a gitlab CI pipeline is provided. The system includes a gitlab CI server, a gitlab runner node, a Jenkins Server, and a Jenkins node;

[0023] The gitlab CI server is used to install gitlab and invoke the Jenkins pipeline through the Jenkins command-line interface;

[0024] The gitlab runner node is used to install the gitlab runner and the client tool of the Jenkins command-line interface;

[0025] The Jenkins Server is used to install Jenkins, configure the credentials of the gitlab account, and create a Jenkins pipeline;

[0026] The operating system of the Jenkins node is Windows XP, which is used to install slave-agent.jnlp and connect to the Jenkins Server.

[0027] Preferably, the gitlab runner node invokes the Jenkins pipeline with the operating system of Windows XP through the Jenkins command-line interface;

[0028] The Jenkins node server is provided with a network shared folder for the gitlab runner node to obtain compilation or code scanning output files or reports from the Jenkins node in the form of shared files.

[0029] According to a third aspect of the present invention, there is provided an electronic device including a memory and a processor, wherein a computer program is stored on the memory, and when the processor executes the program, the method described above is implemented.

[0030] Compared with the prior art, the present invention has the following beneficial effects:

[0031] 1) The present invention solves the difficulties in integrating the windows XP node in gitLab CI by installing a client tool for the Jenkins command line interface on the gitlab runner node, configuring the credentials of the gitlab account in the Jenkins server, creating a Jenkins pipeline, and creating a pipeline in gitlab CI and invoking the Jenkins pipeline with the operating system of Windows XP through the Jenkins command line interface.

[0032] 2) Through the parameterized design of the gitLab CI and Jenkins pipeline scripts and based on the calling method of JenkinsCLI, the present invention enables the users of gitLab CI to meet the gitflow workflow when using the nodes deployed on the window XP operating system, improving the efficiency of software development. BRIEF DESCRIPTION OF THE DRAWINGS

[0033] Figure 1 is a schematic flow chart of the method of the present invention;

[0034] Figure 2 is a schematic structural diagram of the system of the present invention. DETAILED DESCRIPTION OF THE EMBODIMENTS

[0035] The technical solutions in the embodiments of the present invention will be clearly and completely described below with reference to the accompanying drawings in the embodiments of the present invention. Obviously, the described embodiments are some, but not all, of the embodiments of the present invention. All other embodiments obtained by those of ordinary skill in the art based on the embodiments of the present invention without creative efforts shall fall within the protection scope of the present invention.

[0036] This embodiment relates to a method for integrating a Windows XP node in gitLab CI, as Figure 1 , including the following steps:

[0037] Step 1) InFigure 2 Install GitLab Runner on the GitLab Runner node (operating system: Windows 10) as shown in the figure and register it with the GitLab server. The detailed steps are as follows:

[0038] 1-1. Download the Git installation package (64-bit Git for Windows Setup) from the official Git website. Double-click the installation file and complete the Git installation according to the prompts of the installation wizard;

[0039] 1-2. Download the GitLab Runner executable file for the Windows version (gitlab-runner-windows-amd64.exe) from the GitLab official website, and place this file in c:\gitlab_runner and rename it to gitlab_runner.exe;

[0040] 1-3. Open the command line CMD or PowerShell and switch to the directory where the GitLab Runner folder is located;

[0041] 1-4. Run the gitlab-runner.exe install command as an administrator to install GitLab Runner as a Windows service;

[0042] 1-5. In the command line CMD or PowerShell, use the gitlab-runner.exe register command and add the --url and --token parameters to register the runner to the GitLab instance;

[0043] 1-6. Run the gitlab-runner.exe start command to start the GitLab Runner service;

[0044] Step 2) Install JDK (Java Development Kit) on the GitLab Runner node (operating system: Windows 10) as shown in the figure. Since we need to integrate the Windows XP node, it is recommended to use JDK 8. The specific steps are as follows: Figure 2 2-1. Download the installer jdk-8u131-windows-i586_8.0.1310.11.exe, double-click to run it, and complete the JDK installation with the default settings according to the installation wizard;

[0045] 2-1. Download the installer jdk-8u131-windows-i586_8.0.1310.11.exe, double-click to run it, and complete the JDK installation with the default settings according to the installation wizard;

[0046] 2-2. Configure the environment variable "JAVA_HOME". Right-click on "This PC" on the desktop and select "Properties". In the window that pops up, click on "Advanced system settings" on the left side, and switch to the "Advanced" tab page. Then click the "Environment Variables" button. In the "System Variables" area, click "New". Enter "JAVA_HOME" as the variable name and fill in the installation path of the JDK, such as C:\Java\jdk8, and then click "OK" to save.

[0047] 2-3. Configure the environment variable "Path". Locate the "Path" variable in the "System Variables", click "Edit". In the pop-up edit window, click "New", enter %JAVA_HOME%\bin, then click "New" again and enter %JAVA_HOME%\jre\bin. After that, click "OK" in sequence to close each window.

[0048] Step 3) On the gitlab runner node (operating system Windows 10) as shown in Figure 2 , log in to the Jenkins server ([[]]Jenkins Server in Figure 1 ), using the administrator account) with the Chrome browser, and click the link to download the jenkins-cli.jar file in the Jenkins CLI under the System Management page. Among them, jenkins-cli.jar is the client tool of the Jenkins Command Line Interface (CL). The Jenkins CLI allows users to perform Jenkins operations from the command line or scripts, such as creating new jobs, listing all jobs, managing plugins, restarting Jenkins, etc., which is suitable for automated tasks and batch operations.

[0049] Step 4) Add a node of Jenkins node (Windows XP) to the Jenkins Server as shown in Figure 1 . The specific steps are as follows:

[0050] 4-1. Log in to the Jenkins server and log in to the Web management interface of Jenkins using the administrator account.

[0051] 4-2. Enter the node management page. On the Jenkins main interface, click "Manage Jenkins" in the left menu. In the expanded menu, select "Manage Nodes and Clouds", and then you will enter the node management page.

[0052] 4-3. Create a new node. On the node management page, click the "New Node" button. A configuration page for creating a new node will pop up. Enter the node name, which is used to uniquely identify the node in the Jenkins system. After completion, click "OK".

[0053] 4-4. Configure the node. Connection method: Select "Launch agent via Java Web Start".

[0054] Step 5) Connect the Jenkins node (Windows XP) to the Jenkins server. The specific steps are as follows:

[0055] 5-1. Install the jdk environment on this node. It is recommended to use jdk 8. The specific steps are the same as the operations on the gitlab runner node.

[0056] 5-2. Open the Chrome browser on this node. Log in to the Web management interface of the Jenkins server with an administrator account. Download the node startup link on the new node configuration page. Its format is: http: / / <Jenkinsserver IP>:<port> / computer / <new node name> / slave-agent.jnlp.

[0057] 5-3. Double-click the jnlp program. If a security prompt pops up, allow the relevant operations. Subsequently, the system will download and run the Jenkins slave agent program to establish a connection with the Jenkins server.

[0058] Step 6) Configure the credentials of the gitlab account in the Jenkins server. The specific steps are as follows:

[0059] 6-1. Log in to the Jenkins server. Log in to the Web management interface of the Jenkins with an administrator account.

[0060] 6-2. Enter the credentials management page. Click "Manage Jenkins" in the left menu bar. In the expanded drop-down menu, select "Manage Credentials". The system will enter the credentials management page.

[0061] 6-3. Add new credentials. On the credentials management page, find and click the "AddCredentials" button corresponding to the "(global)" area to open the credentials addition page.

[0062] 6-4. Select the credential type and fill in the information. In the pop-up "Add Credentials" dialog box, select "Username and Password" from the "Kind" drop-down list. Add the account and password used to log in to GitLab in the dialog box, and finally click Save.

[0063] Step 7) Create a pipeline using the pipeline script in the Jenkins server. The specific steps are as follows:

[0064] 7-1. Create a new task. Log in to the Jenkins server, click the "New Item" button on the left side of the home page, enter the project name, select the "Pipeline" type, and then click "OK".

[0065] 7-2. Configure the pipeline script. Enter the configuration page of the new project. Under the "Pipeline" tab, select "pipeline script".

[0066] 7-3. In the text box, enter the pipeline script of Jenkins. The following example script defines two key stages: the Build stage, which determines whether to execute the build based on the parameter and pulls the specified branch for code compilation according to the parameter; the Scan stage, which determines whether to execute the scan based on the parameter and pulls the specified branch for code scanning according to the parameter.

[0067] pipeline{

[0068] agent{node{label'master'}} / / Specify the node as the master node

[0069] parameters{ / / Define three parameters, namely the boolean type build and scan, and the string type branchname

[0070] boolean(name:'build',defaultValue:true,description:'build boolean parameter') / / Define the build parameter

[0071] boolean(name:'scan',defaultValue:false,description:'scan boolean parameter') / / Define the scan parameter

[0072] string(name:'branchname',defaultValue:'defaultValue',description:”branch name”) / / Define the string-type parameter branchname

[0073] }

[0074] stages{

[0075] stage('build'){ / / Configure the script for the build stage

[0076] agent{node{label'tornado2.2'}} / / Specify the node as tornado2.2

[0077] when{

[0078] expression{params.build} / / The condition for executing this script segment is that the build parameter is true

[0079] }

[0080] steps{

[0081] echo'get build' / / Print 'get build'

[0082] deleteDir() / / Clear the files in the current directory

[0083] git branch:params.branchname,credentialsId:'f415ae91-5887-4768-b23f-3cf54cd47367',url:'http: / / 192.100.168.2 / xxx / xxx.git' / / Invoke the Jenkins pipeline

[0084] bat'build.bat' / / Compile

[0085] }

[0086] }

[0087] stage('scan'){ / / Configure the script for the scan stage

[0088] agent{node{label'tornado2.2'}} / / Specify the node as tornado2.2

[0089] when{

[0090] expression{params.scan} / / The condition for executing this script segment is that the scan parameter is true

[0091] }

[0092] steps{

[0093] echo 'get scan' / / Print 'get scan'

[0094] git branch:params.branchname,credentialsId:'f415ae91-5887-4768-b23f-3cf54cd47367',url:'http: / / 192.100.168.2 / xxx / xxx.git' / / Call the Jenkins pipeline

[0095] bat'scan.bat' / / Compile

[0096] }

[0097] }

[0098] }

[0099] Step 8) Create a network shared folder on the Jenkins node (Windows XP) for the GitLab runner node to copy the output files or reports of compilation or code scanning from this node (Jenkins node) through file sharing.

[0100] Step 9) Create a pipeline in GitLab CI and call the Jenkins pipeline through the Jenkins CLI. The specific steps are as follows:

[0101] 9-1, Create or edit a.gitlab-ci.yml file in the project root directory. An example of the key statement for calling the Jenkins pipeline in the build stage of the pipeline is as follows. Among them, 192.168.100.3 is the IP address of the Jenkins node (Windows XP), and workspace is the shared directory created in the previous step.

[0102] build-job: / / Call statement in the build stage

[0103] stage:build

[0104] tags:

[0105] -gitlab_runner_win10 / / Specify the node as gitlab_runner_win10

[0106] rules: / / Define the conditions for calling the build stage script

[0107] -if: "$CI_MERGE_REQUEST_TARGET_BRANCH_NAME =~ / develop / "

[0108] -if: "$CI_MERGE_REQUEST_TARGET_BRANCH_NAME =~ / release / "

[0109] allow_failure: false

[0110] script:

[0111] -echo "================build================="

[0112] -java -jar jenkins-cli.jar -s http: / / 192.100.168.2:8080 / -remoting buildxxxx -p build=true -p branchname=%CI_MERGE_REQUEST_SOURCE_BRANCH_NAME% -s -v

[0113] -copy \\192.100.168.3\workspace\xxx\vxworks vxworks

[0114] artifacts: / / Transfer the contents of the current directory of the gitlab runner node to the gitlab CI pipeline

[0115] name: vxworks

[0116] paths:

[0117] -vxworks

[0118] Statement: java-jar jenkins-cli.jar -s http: / / 192.100.168.2:8080 / -remoting build xxx -p build=true -p branchname=%CI_MERGE_REQUEST_SOURCE_BRANCH_NAME% -s -v. This is to call the Jenkins pipeline and specify the execution parameters. build is true and branchname is the source branch name of the merge request. -s is to wait for the command to complete, and -v is to display the command line output in the pipeline. Therefore, in the GitLab CI pipeline, it will wait for the Jenkins pipeline to complete and display the execution log of the Jenkins pipeline on the GitLab CI pipeline page.

[0119] Statement: copy \\192.100.168.3\workspace\xxx\vxworks vxworks. After the GitLab runner calls the Jenkins pipeline through the Jenkins CLI and waits for the pipeline to complete, it copies the compiled output file from the Jenkins node (Windows XP) to the GitLab runner node as the artifact of the pipeline.

[0120] 9-2. An example of the key statement for calling the Jenkins pipeline in the scan stage of the pipeline is as follows:

[0121]

[0122] This embodiment also relates to a system for integrating a Windows XP node in a GitLab CI pipeline, as Figure 2 , including a GitLab CI server, a GitLab runner node, a Jenkins Server, and a Jenkins node;

[0123] The GitLab CI server is used to install GitLab and call the Jenkins pipeline through the Jenkins command line interface;

[0124] The GitLab runner node is used to install the GitLab runner and the client tool of the Jenkins command line interface;

[0125] The Jenkins Server is used to install Jenkins, configure the credentials of the GitLab account, and create the Jenkins pipeline;

[0126] The operating system of the Jenkins node is Windows XP, which is used to install slave-agent.jnlp and connect to the Jenkins Server.

[0127] The operating system of the GitLab runner node is different from that of the Jenkins node.

[0128] The operating system of the GitLab runner node is Windows 10.

[0129] A network shared folder is set up on the Jenkins node, which is used for the GitLab runner node to obtain the output files or reports of compilation or code scanning from the Jenkins node through shared files.

[0130] Such as Figure 2 , this system is a ThinkSystem SR860 7X69 server, the operating system of which is ESXi 6.5, and its main configurations are shown in Table 1.

[0131] Table 1

[0132]

[0133] The virtual machines running in this server are shown in Table 2.

[0134] Table 2

[0135]

[0136] The electronic device of the present invention includes a central processing unit (CPU), which can execute various appropriate actions and processes according to the computer program instructions stored in the read-only memory (ROM) or the computer program instructions loaded from the storage unit into the random access memory (RAM). In the RAM, various programs and data required for device operation can also be stored. The CPU, ROM, and RAM are connected to each other through a bus. The input / output (I / O) interface is also connected to the bus.

[0137] Multiple components in the device are connected to the I / O interface, including: an input unit, such as a keyboard, a mouse, etc.; an output unit, such as various types of displays, speakers, etc.; a storage unit, such as a disk, an optical disc, etc.; and a communication unit, such as a network card, a modem, a wireless communication transceiver, etc. The communication unit allows the device to exchange information / data with other devices through a computer network such as the Internet and / or various telecommunication networks.

[0138] The processing unit executes the various methods and processes described above. For example, in some embodiments, the method may be implemented as a computer software program tangibly embodied in a machine-readable medium, such as a storage unit. In some embodiments, part or all of the computer program may be loaded and / or installed onto the device via the ROM and / or the communication unit. When the computer program is loaded into the RAM and executed by the CPU, one or more steps of the methods described above may be performed. Alternatively, in other embodiments, the CPU may be configured to execute the method by any other suitable means (e.g., by means of firmware).

[0139] The functions described above herein may be performed at least in part by one or more hardware logic components. By way of example and not limitation, the types of hardware logic components that may be used include: field programmable gate arrays (FPGAs), application specific integrated circuits (ASICs), application specific standard products (ASSPs), systems on a chip (SOCs), complex programmable logic devices (CPLDs), and the like.

[0140] The program code for implementing the method of the present invention may be written in any combination of one or more programming languages. These program codes may be provided to a processor or controller of a general purpose computer, a special purpose computer, or other programmable data processing apparatus, such that the program codes, when executed by the processor or controller, cause the functions / operations specified in the flowcharts and / or block diagrams to be implemented. The program code may be executed entirely on the machine, partly on the machine, as a stand-alone software package partly on the machine and partly on a remote machine, or entirely on the remote machine or server.

[0141] In the context of the present invention, a machine-readable medium may be a tangible medium that can contain or store a program for use by or in connection with an instruction execution system, apparatus, or device. A machine-readable medium may be a machine-readable signal medium or a machine-readable storage medium. A machine-readable medium may include, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination of the foregoing. More specific examples of a machine-readable storage medium would include an electrical connection based on 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.

[0142] As described above, it is only the specific implementation manner of the present invention, but the protection scope of the present invention is not limited thereto. Any person skilled in the art within the technical scope disclosed by the present invention can easily think of various equivalent modifications or substitutions, and these modifications or substitutions should all be covered within the protection scope of the present invention. Therefore, the protection scope of the present invention shall be subject to the protection scope of the claims.

Claims

1. A method for integrating gitlab CI with Windows XP nodes, characterized in that: The method includes: Install the Jenkins command line interface client tool on the gitlab runner node; Add a Jenkins node with Windows XP operating system to the Jenkins Server and establish a connection between the node and the Jenkins server; Configure the credentials of the gitlab account in the Jenkins server and create a Jenkins pipeline; And create a pipeline in gitlab CI. The gitlab runner node calls the Jenkins pipeline whose operating system is Windows XP through the Jenkins command line interface.

2. A method for integrating a gitlab CI with a Windows XP node according to claim 1, characterized in that: The windows operating system of the gitlab runner node is different from the operating system of the Jenkins node; the operating system of the gitlab runner node is windows 10.

3. A method for integrating a gitlab CI with a Windows XP node according to claim 2, characterized in that: The method further includes installing a gitlab runner on a gitlab runner node and registering the gitlab runner to a gitlab server; and installing a JDK on the gitlab runner node.

4. A method for integrating a gitlab CI with a Windows XP node according to claim 1, characterized in that: The Jenkins node node has JDK installed.

5. A method for integrating a gitlab CI with a Windows XP node according to claim 3, characterized in that: The JDK version is jdk 8.

6. A method for integrating a gitlab CI with a Windows XP node according to claim 1, characterized in that: Use the pipeline script to create a pipeline in the Jenkins server.

7. A method for integrating a gitlab CI with a Windows XP node according to claim 1, characterized in that: Calling the Jenkins pipeline through the Jenkins command line interface is based on the configuration of the gitlab-ci.yml file, including calling the Jenkins pipeline in the build phase and calling the Jenkins pipeline in the scan phase.

8. A method for integrating a gitlab CI with a Windows XP node according to claim 7, characterized in that: Configuring the gitlab-ci.yml file includes setting the IP address of the Jenkins node and the directory of the Jenkins node network shared folder.

9. A method for integrating a gitlab CI with a Windows XP node according to claim 8, characterized in that: The network shared folder is used for the gitlab runner node to obtain the output files or reports of compilation or code scanning from the Jenkins node node through the shared file method.

10. A system using the method for integrating Windows XP nodes with gitlab CI as described in any one of claims 1 to 9, characterized in that: The system includes gitlab CI server, gitlab runner node, Jenkins Server and Jenkins node; The gitlab CI server is used to install gitlab and call the Jenkins pipeline through the Jenkins command line interface; The gitlab runner node is used to install the client tools of the gitlab runner and the Jenkins command line interface; The Jenkins Server is used to install Jenkins, configure the credentials of the gitlab account, and create the Jenkins pipeline; The operating system of the Jenkins node is Windows XP, which is used to install slave-agent.jnlp and connect to the Jenkins Server.

11. The system according to claim 10, characterized in that The gitlab runner node calls the Jenkins pipeline whose operating system is Windows XP through the Jenkins command line interface; The Jenkins node server is provided with a network shared folder, which is used for the gitlab runner node to obtain the compilation or code scanning output file or report from the Jenkins node node through the shared file.

12. An electronic device comprising a memory and a processor, wherein a computer program is stored in the memory, wherein: When the processor executes the program, the method according to any one of claims 1 to 9 is implemented.

Images