CN115061702B

CN115061702B - IDE management method and electronic equipment

Info

Publication number: CN115061702B
Application number: CN202210995914.0A
Authority: CN
Inventors: 熊浩
Original assignee: Honor Device Co Ltd
Current assignee: Honor Device Co Ltd
Priority date: 2022-08-19
Filing date: 2022-08-19
Publication date: 2024-06-14
Anticipated expiration: 2042-08-19
Also published as: CN115061702A

Abstract

The application provides an IDE management method and electronic equipment, and relates to the technical field of computers. The problem of low man-machine interaction efficiency in managing IDE examples is solved. The specific scheme is as follows: when the system time reaches a first time point, a first instance corresponding to the first item is created, wherein the first time point is a system time point at which the first instance is estimated to be started; receiving an access request sent by second equipment; responding to the access request, sending first page data to the second equipment, wherein the first page data indicates the second equipment to display first prompt information, and the first prompt information indicates the first instance to be in an operation state; when the system time reaches a second time point, the first instance is destroyed, and the second time point is the system time point when the first instance is estimated to be closed.

Description

IDE management method and electronic equipment

Technical Field

The present application relates to the field of computer technologies, and in particular, to an IDE management method and an electronic device.

Background

With the development of computer technology, tools for assisting developers in software development are also generated. Wherein at least one of a code editor, a compiler, a debugger, and a graphical user interface is integrated, and an application for providing a program development environment is called an integrated development environment (INTEGRATED DEVELOPMENT ENVIRONMENT, IDE). The IDE is distributed on the cloud (such as a server), so that a developer can establish connection with the IDE instance of the cloud through a terminal device (such as a host, a tablet computer or a mobile phone) at any place and time, and development activities such as coding and debugging are performed in a browser.

The operation of the IDE instance requires resources of the cloud, such as computing resources, storage resources, etc. However, cloud resources are limited, as are the number of IDE instances that can be created during the same period. In the related art, a user of the terminal device is required to actively instruct the cloud to create an IDE instance or destroy the IDE instance. Obviously, before the user uses the IDE instance, the user needs to wait for the creation process of the IDE instance, and in addition, when the user does not timely instruct to destroy the unused IDE instance, the idle IDE instance also can occupy cloud resources for a long time.

Disclosure of Invention

The embodiment of the application provides an IDE management method and electronic equipment, which intelligently create and destroy IDE examples by predicting the starting time and the ending time of using the IDE examples by terminal equipment, so that man-machine interaction for managing the IDE examples is reduced.

In order to achieve the above purpose, the embodiment of the present application adopts the following technical scheme:

in a first aspect, an embodiment of the present application provides an IDE management method, applied to a first device, where the method includes: when the system time reaches a first time point, a first instance corresponding to a first item is created, wherein the first time point is a system time point at which the first instance is estimated to be started; receiving an access request sent by second equipment; responding to the access request, sending first page data to the second equipment, wherein the first page data indicates the second equipment to display first prompt information, and the first prompt information indicates the first instance to be in a running state; destroying the first instance when the system time reaches a second time point, wherein the second time point is a system time point when the first instance is estimated to be closed.

The first item is a work item created in the first device. The first instance is an IDE instance corresponding to the first item. In the above embodiment, the first device may intelligently identify the creation time and the destruction time of the IDE instance corresponding to each work item. In this way, the first device can start to create the IDE instance before the second device requests to use the IDE instance, so that the time period for the user of the second device to wait for the creation of the IDE instance can be effectively reduced. In addition, the first device can automatically destroy the corresponding IDE instance when the system time reaches the destruction time point, so that the idle IDE instance is prevented from occupying system resources for a long time.

In some possible embodiments, a first model is configured in the first device, where the first model is used to predict a start-stop time of a user using an instance corresponding to each item, and the method further includes: determining, using the first model, the first time and second time of a first instance; the first model is a neural network model trained by using first sample data, wherein the first sample data comprises time records of user indication for creating or destroying various examples and attendance data of the user.

In the above embodiment, the first model may identify, according to information such as user habits, a time point when the IDE instance is accurately created or destroyed, thereby improving the degree of intellectualization of automatically creating the IDE instance.

In some possible embodiments, the method further comprises: receiving first login information sent by the second device, wherein the first login information comprises a first address of a first code bin; after the first login information passes authentication, accessing the first code bin according to the first address; determining a first class of programming languages based on code data in the first code bin; determining a first image file matched with the first type of programming language, wherein the first image file is used for creating a first container, the first container is used for deploying a second instance, and the second instance is used for compiling the first type of programming language; the second instance is created based on the first image file.

In the above embodiment, during the period that the second device accesses the code bin, if the first device is jumped to, the first device can intelligently create the IDE instance suitable for compiling the code data in the code bin, the user does not need to manually instruct to create the IDE instance, and does not need to configure a development tool and a development environment for creating the IDE instance, so that the man-machine interaction efficiency of creating the IDE instance is improved.

In some possible embodiments, the first code bin includes first code data and second code data, and the determining a first type of programming language based on the code data in the first code bin includes: determining a first duty ratio corresponding to the first code data and a second duty ratio corresponding to the second code data, wherein the first duty ratio is the ratio between the first code data and all code data in the first code bin, and the second duty ratio is the ratio between the second code data and all code data in the first code bin; and when the first duty ratio is larger than the second duty ratio, determining the type of the program language corresponding to the first code data as the first type of the program language.

In some possible embodiments, the creating the first instance corresponding to the first item includes: querying a second image file matched with the first project in a plurality of preconfigured image files, wherein the second image file is used for creating a container for deploying a first instance and comprises an executable file of a first tool and a program file for constructing a first development environment, the first tool is a basic tool in the first instance, and the first development environment is a running environment required by the first instance; and generating the first instance according to the second image file.

In some possible embodiments, before destroying the first instance, the method further comprises: acquiring a second executable file corresponding to a second tool, wherein the second tool is a program tool installed in the first instance during the operation of the first instance; acquiring a first system parameter, wherein the first system parameter is changed in the first instance during the operation of the first instance; and packaging the second executable file, the first system parameters and the second image file to obtain a third image file, and associating the third image file with the first project, wherein the third image file is used for creating a container for deploying the first instance.

In some possible embodiments, first creation information sent by the second device is received, where the first creation information includes a first identifier corresponding to the first item; determining that the third image file associated with the first item exists; the first instance is created based on the third image file, wherein the first instance comprises the second tool and the first system parameter.

In the above embodiment, even if the IDE instance is destroyed by the first device, the IDE instance is backed up, so that backtracking is facilitated. In addition, the IDE example is backed up by encapsulating the newly installed executable file and the newly changed system parameters into the corresponding image files to obtain backup image files, so that the storage space required by backup can be reduced.

In a second aspect, embodiments of the present application provide an electronic device including one or more processors and memory; the memory is coupled to the processor, the memory for storing computer program code comprising computer instructions that, when executed by the one or more processors, operate to:

When the system time reaches a first time point, a first instance corresponding to a first item is created, wherein the first time point is a system time point at which the first instance is estimated to be started; receiving an access request sent by second equipment; responding to the access request, sending first page data to the second equipment, wherein the first page data indicates the second equipment to display first prompt information, and the first prompt information indicates the first instance to be in a running state; destroying the first instance when the system time reaches a second time point, wherein the second time point is a system time point when the first instance is estimated to be closed.

In some possible embodiments, a first model is configured within the first device, the first model being configured to predict a start-stop time of a user using an instance corresponding to each item, the one or more processors being further configured to: determining, using the first model, the first time and second time of a first instance; the first model is a neural network model trained by using first sample data, wherein the first sample data comprises time records of user indication for creating or destroying various examples and attendance data of the user.

In some possible embodiments, the one or more processors are further configured to: receiving first login information sent by the second device, wherein the first login information comprises a first address of a first code bin; after the first login information passes authentication, accessing the first code bin according to the first address; determining a first class of programming languages based on code data in the first code bin; determining a first image file matched with the first type of programming language, wherein the first image file is used for creating a first container, the first container is used for deploying a second instance, and the second instance is used for compiling the first type of programming language; the second instance is created based on the first image file.

In some possible embodiments, the first code bin includes first code data and second code data, and the one or more processors are further configured to: determining a first duty ratio corresponding to the first code data and a second duty ratio corresponding to the second code data, wherein the first duty ratio is the ratio between the first code data and all code data in the first code bin, and the second duty ratio is the ratio between the second code data and all code data in the first code bin; and when the first duty ratio is larger than the second duty ratio, determining the type of the program language corresponding to the first code data as the first type of the program language.

In some possible embodiments, the one or more processors are further configured to: querying a second image file matched with the first project in a plurality of preconfigured image files, wherein the second image file is used for creating a container for deploying a first instance and comprises an executable file of a first tool and a program file for constructing a first development environment, the first tool is a basic tool in the first instance, and the first development environment is a running environment required by the first instance; and generating the first instance according to the second image file.

In some possible embodiments, the one or more processors are further configured to, prior to destroying the first instance: acquiring a second executable file corresponding to a second tool, wherein the second tool is a program tool installed in the first instance during the operation of the first instance; acquiring a first system parameter, wherein the first system parameter is changed in the first instance during the operation of the first instance; and packaging the second executable file, the first system parameters and the second image file to obtain a third image file, and associating the third image file with the first project, wherein the third image file is used for creating a container for deploying the first instance.

In some possible embodiments, the one or more processors are further configured to: receiving first creation information sent by the second device, wherein the first creation information comprises a first identifier corresponding to the first item; determining that the third image file associated with the first item exists; the first instance is created based on the third image file, wherein the first instance comprises the second tool and the first system parameter.

In a third aspect, an embodiment of the present application provides a computer storage medium, including computer instructions, which when executed on an electronic device, cause the electronic device to perform the method described in the first aspect and possible embodiments thereof.

In a fourth aspect, the application provides a computer program product for causing an electronic device to carry out the method as described in the first aspect and possible embodiments thereof, when the computer program product is run on the electronic device.

It will be appreciated that the electronic device, the computer storage medium and the computer program product described above are applied to the corresponding methods provided above, and thus, the advantages achieved by the electronic device, the computer storage medium and the computer program product are referred to the advantages of the corresponding methods provided above, and are not repeated herein.

Drawings

FIG. 1 is a schematic diagram of a development system according to an embodiment of the present application;

fig. 2 is a schematic structural diagram of a user terminal according to an embodiment of the present application;

fig. 3 is a schematic software structure of a server according to an embodiment of the present application;

Fig. 4 is a schematic diagram of a user interface of a user terminal according to an embodiment of the present application;

FIG. 5 is a signaling diagram of an IDE instance management method according to an embodiment of the present application;

FIG. 6 is a second signaling diagram illustrating an embodiment of a method for managing IDE instances;

FIG. 7 is a third signaling diagram illustrating an embodiment of a method for managing IDE instances;

fig. 8 is a schematic diagram of a system on chip according to an embodiment of the present application.

Detailed Description

The terms "first" and "second" are used below for descriptive purposes only and are not to be construed as indicating or implying relative importance or implicitly indicating the number of technical features indicated. Thus, a feature defining "a first" or "a second" may explicitly or implicitly include one or more such feature. In the description of the present embodiment, unless otherwise specified, the meaning of "plurality" is two or more.

The embodiment of the application provides a development system, as shown in fig. 1, which may include a server 1 and at least one user terminal.

In some embodiments, the server 1 described above may provide an integrated development environment (INTEGRATED DEVELOPMENT ENVIRONMENT, IDE).

It is understood that the IDE refers to an operating environment capable of executing code and program development. The IDE includes at least one component, which is understood to refer to a simple encapsulation of data and methods, and in some programming language architectures, components may also be referred to as parts, controls, etc.

In some embodiments, the components of the IDE may be separated into front-end components and back-end components according to the functionality of the components. Illustratively, the front-end component has functionality for interacting with a user, e.g., for receiving user input data, for displaying user request data, etc. In addition, the back-end component has a function of processing data, for example, for processing received data according to set logic or for acquiring data from a database.

For example, the IDE may include at least one of a code editor, compiler, debugger, and graphical user interface. The IDE front end components may include components related to graphical user interfaces and the IDE back end components may include components related to compilers, debuggers, and the like, divided by component functionality.

By way of example, the user terminal in the development system may be a desktop computer, a tablet computer, a smart watch, a desktop computer, a laptop computer, a handheld computer, a notebook computer, an ultra-mobile personal computer (UMPC), a netbook, a Personal Digital Assistant (PDA) DIGITAL ASSISTANT, an Augmented Reality (AR) Virtual Reality (VR) device, etc., and the embodiment of the present application is not limited to the specific form of the user terminal.

Referring to fig. 2, a schematic structure diagram of a user terminal 100 according to an embodiment of the present application is shown. As shown in fig. 2, the user terminal 100 may include: processor 110, external memory interface 120, internal memory 121, universal serial bus (universal serial bus, USB) interface 130, charge management module 140, power management module 141, battery 142, antenna 1, antenna 2, mobile communication module 150, wireless communication module 160, audio module 170, speaker 170A, receiver 170B, microphone 170C, headset interface 170D, sensor module 180, keys 190, motor 191, indicator 192, camera 193, display 194, and subscriber identity module (subscriber identification module, SIM) card interface 195, etc.

The sensor module 180 may include a pressure sensor, a gyroscope sensor, a barometric sensor, a magnetic sensor, an acceleration sensor, a distance sensor, a proximity sensor, a fingerprint sensor, a temperature sensor, a touch sensor, an ambient light sensor, a bone conduction sensor, and the like.

It should be understood that the configuration illustrated in this embodiment does not constitute a specific limitation on the user terminal 100. In other embodiments, the user terminal 100 may include more or less components than illustrated, or certain components may be combined, or certain components may be split, or different arrangements of components. The illustrated components may be implemented in hardware, software, or a combination of software and hardware.

The processor 110 may include one or more processing units, such as: the processor 110 may include an application processor (application processor, AP), a modem processor, a graphics processor (graphics processing unit, GPU), an image signal processor (IMAGE SIGNAL processor, ISP), a controller, a memory, a video codec, a digital signal processor (DIGITAL SIGNAL processor, DSP), a baseband processor, and/or a neural Network Processor (NPU), etc. Wherein the different processing units may be separate devices or may be integrated in one or more processors.

The controller may be a neural hub and a command center of the user terminal 100. The controller can generate operation control signals according to the instruction operation codes and the time sequence signals to finish the control of instruction fetching and instruction execution.

A memory may also be provided in the processor 110 for storing instructions and data. In some embodiments, the memory in the processor 110 is a cache memory. The memory may hold instructions or data that the processor 110 has just used or recycled. If the processor 110 needs to reuse the instruction or data, it can be called directly from the memory. Repeated accesses are avoided and the latency of the processor 110 is reduced, thereby improving the efficiency of the system.

In some embodiments, the processor 110 may include one or more interfaces. The interfaces may include an integrated circuit (inter-INTEGRATED CIRCUIT, I2C) interface, an integrated circuit built-in audio (inter-INTEGRATED CIRCUIT SOUND, I2S) interface, a pulse code modulation (pulse code modulation, PCM) interface, a universal asynchronous receiver transmitter (universal asynchronous receiver/transmitter, UART) interface, a mobile industry processor interface (mobile industry processor interface, MIPI), a general-purpose input/output (GPIO) interface, a subscriber identity module (subscriber identity module, SIM) interface, and/or a universal serial bus (universal serial bus, USB) interface, among others.

It should be understood that the interfacing relationship between the modules illustrated in the present embodiment is only illustrative, and does not limit the structure of the user terminal 100. In other embodiments, the user terminal 100 may also use different interfacing manners in the above embodiments, or a combination of multiple interfacing manners.

The user terminal 100 implements display functions through a GPU, a display screen 194, an application processor, and the like. The GPU is a microprocessor for image processing, and is connected to the display 194 and the application processor. The GPU is used to perform mathematical and geometric calculations for graphics rendering. Processor 110 may include one or more GPUs that execute program instructions to generate or change display information.

The display screen 194 is used to display images, videos, and the like. The display 194 includes a display panel. The display panel may employ a Liquid Crystal Display (LCD) CRYSTAL DISPLAY, an organic light-emitting diode (OLED), an active-matrix organic LIGHT EMITTING diode (AMOLED), a flexible light-emitting diode (FLED), miniled, microLed, micro-oLed, a quantum dot LIGHT EMITTING diode (QLED), or the like.

The user terminal 100 may implement a photographing function through an ISP, a camera 193, a video codec, a GPU, a display screen 194, an application processor, and the like.

The ISP is used to process data fed back by the camera 193. For example, when photographing, the shutter is opened, light is transmitted to the camera photosensitive element through the lens, the optical signal is converted into an electric signal, and the camera photosensitive element transmits the electric signal to the ISP for processing and is converted into an image visible to naked eyes. ISP can also optimize the noise, brightness and skin color of the image. The ISP can also optimize parameters such as exposure, color temperature and the like of a shooting scene. In some embodiments, the ISP may be provided in the camera 193.

The camera 193 is used to capture still images or video. The object generates an optical image through the lens and projects the optical image onto the photosensitive element. The photosensitive element may be a charge coupled device (charge coupled device, CCD) or a Complementary Metal Oxide Semiconductor (CMOS) phototransistor. The photosensitive element converts the optical signal into an electrical signal, which is then transferred to the ISP to be converted into a digital image signal. The ISP outputs the digital image signal to the DSP for processing. The DSP converts the digital image signal into an image signal in a standard RGB, YUV, or the like format. In some embodiments, the user terminal 100 may include N cameras 193, N being a positive integer greater than 1.

The digital signal processor is used for processing digital signals, and can process other digital signals besides digital image signals. For example, when the user terminal 100 selects a frequency bin, the digital signal processor is used to fourier transform the frequency bin energy, etc.

Video codecs are used to compress or decompress digital video. The user terminal 100 may support one or more video codecs. In this way, the user terminal 100 may play or record video in a plurality of encoding formats, for example: dynamic picture experts group (moving picture experts group, MPEG) 1, MPEG2, MPEG3, MPEG4, etc.

The NPU is a neural-network (NN) computing processor, and can rapidly process input information by referencing a biological neural network structure, for example, referencing a transmission mode between human brain neurons, and can also continuously perform self-learning. Applications such as intelligent awareness of the user terminal 100 may be implemented by the NPU, for example: image recognition, face recognition, speech recognition, text understanding, etc.

In some embodiments, the user terminal having the above-described hardware structure may access the development system, i.e., establish a communication connection with the server 1, in response to an operation of the user.

Illustratively, a client, such as an IDE application, corresponding to the server 1 is installed in the user terminal. A communication connection is established with the server 1 at the user terminal in response to a user operation of the IDE application. Then, the user terminal displays the IDE service interface corresponding to the server 1.

In addition, before the user terminal displays the IDE service interface, the server 1 can also check the authority of the user terminal, and authentication is short for short. In case it is determined that the user terminal has the authority, the server 1 may instruct the user terminal to display a corresponding IDE service interface. For example, the user terminal sends the service account number and the password configured by the user to the server 1, and the server 1 determines whether the user terminal has the access right according to the service account number and the password. Illustratively, it is determined whether the service account provided by the user terminal is a registered account in the server 1. After determining that the service account is a registered account in the server 1, it is continued to determine whether the password provided by the user terminal matches the service account. Under the scene that the password is matched with the service account, the user terminal can be determined to have the access right.

Also illustratively, the user terminal has a browser application installed therein. The designated code bin may be accessed in response to a user operation during the time that the user terminal is enabling the browser application. The code bin is a server for storing published code data. In the case of successful access to the code bin, the browser application may display the service interface 1 corresponding to the code bin. The service interface 1 includes a control 1 indicating the jump server 1. After the user terminal receives the selection operation of the control 1 by the user, the user terminal skips to access the server 1, for example, the user terminal sends first login information to the server 1, where the first login information includes a first address, and the first address is a code bin accessed by the user terminal before adjustment, for example, is called a first code bin. In this way, the user terminal establishes a communication connection with the server 1. Also, after the user terminal establishes a connection with the server 1, if the user terminal passes the authentication of the server 1, that is, it is determined that the user terminal has an access authentication according to the first login information, the user terminal displays an IDE service interface provided by the server 1.

Still further exemplary, the user terminal may display an inquiry alert in a scene where the user terminal checks specified code data using a Quality Control (QC) tool in response to an operation of the user. The inquiry alert is used to inquire of the user whether to jump to access the server 1. For example, the inquiry alert may be the word "whether code data is open in IDE". When the user terminal receives operation 1, the user terminal accesses the server 1. The above operation 1 may be an operation in which the user confirms that the code data is opened in the IDE. In this way, the user terminal establishes a communication connection with the server 1. Also, after the user terminal establishes a connection with the server 1, if the user terminal passes the authentication of the server 1, the user terminal displays an IDE service interface provided by the server 1.

After displaying the IDE service interface, the user terminal may acquire the IDE service from the server 1. It is understood that the IDE services may include code editing, compiling, debugging, etc.

Before the server 1 provides the IDE service, the server 1 needs to run the components corresponding to the IDE, and create the corresponding IDE instance. An instance is a program in a running state, i.e., an IDE in a running state may also be referred to as an IDE instance. Creating an IDE instance requires deploying a corresponding IDE kernel, specifically a code file for forming the IDE instance, on the available resources. The code file includes code fragments corresponding to the IDE front-end component and the IDE back-end component. The code file of course also includes code fragments corresponding to script generators of the IDE front-end component and the IDE back-end component.

In addition, the resources for deploying the IDE kernel may be available resources of the user terminal itself or available resources provided by the server 1. It will be appreciated that resources may also be divided into physical or virtual resources based on type. Wherein, the physical resource refers to a physically isolated computing resource, storage resource, communication resource, etc., such as a stand-alone server, storage device, communication device, etc. The virtual resource is a computing resource, a storage resource, a communication resource, or the like isolated from the level of an operating system, a process, or the like, and is, for example, a plurality of Virtual Machines (VMs) or a plurality of containers (contents) deployed on one server.

In some embodiments, the process of deploying an IDE kernel may include: the code files are generated into executable files, such as generating a software package (e.g., npm package), and then the executable files are configured into containers that enable the executable files to execute.

In some embodiments, multiple user terminals may be accessed in a development system. Multiple user terminals may request IDE services from the server 1, and the server 1 may need to create multiple IDE instances accordingly. In addition, the same user terminal may also request the server 1 to create a plurality of different IDE instances for writing code programs of different items, or different types of code programs. However, the IDE instance may occupy the resources of the server 1, and even if the amount of resources available to the server 1 is large, the resources may still be limited. In the case where the number of IDE instances in the server 1 is excessive, a problem of insufficient available resources may also occur.

In some embodiments, the IDE instance in the server 1 may be managed by a user terminal in the development system. For example, the user terminal may instruct the creation of an IDE instance (which may occupy resources). Wherein, the IDE instance created by the user terminal indication can also be called as the IDE instance corresponding to the user terminal. For another example, the user terminal may also instruct the server 1 to destroy the corresponding IDE instance (which may release the occupied resources).

Obviously, in the above embodiment, if the idle IDE instance is not destroyed in time, the resources in the server 1 are occupied by long-term invalidation. In addition, in the above embodiment, after the user terminal instructs the server 1 to create the corresponding IDE instance in response to the user operation, it is necessary to wait for the server 1 to schedule the resource and create the instance. Obviously, after indicating to create an IDE instance, the user needs to wait a period of time before the desired IDE instance can be used. In summary, the development system in some embodiments has a problem of low intelligentization.

In order to solve the above problems, the embodiments of the present application provide an IDE management method, which intelligently destroys IDE instances or creates IDE instances in advance by predicting the start and stop time of a user using the IDE instances. Thus, the problem of resources being inefficiently occupied and the need to wait a longer time after the user instructs to create an IDE instance is ameliorated.

In some embodiments, the IDE management method may be applied to the aforementioned development system. Wherein fig. 3 shows a software architecture involving the IDE part in the server 1 of the development system. As shown in fig. 3, the server 1 includes an API gateway service module, a work area management service module, a queue, and a resource management service module.

The API gateway service module is illustratively used for authenticating the authority of the user terminal (e.g., the device requesting to establish a communication connection with the server 1) accessing the development system. For example, the API gateway service module may receive the service account and the password sent by the user terminal, and check whether the service account matches the password, whether the service account itself has the authority to access the server 1, and so on.

In addition, the API gateway service module is also used for receiving a user terminal sending request, data, instructions and the like.

Also illustratively, the workspace management service module is configured to manage the work items created by the user and instruct the authenticated user terminal to display the created work items, e.g., may instruct the user terminal to display the created work items in an IDE service interface (interface 401 shown in fig. 4). The interface 401 includes a workspace, such as workspace 402. The workspace includes at least one work item, such as item 403. Wherein each work item may indicate an IDE instance, which may be an instance that has not yet been created, or an instance that has been created and is running.

In the above example, the work items may include item name information, creator information, a type of tool required, a type of development environment required, and the like. The project name information can be customized by a user, and the creator information can be determined according to a service account number which the user logs in. Thus, by means of the project name information and creator information, the user can quickly locate a work project associated with the IDE instance to be used from the workspace. The type of tool required and the type of development environment required may determine the type of resources required, the tool and operating system to be installed, etc. when creating the corresponding IDE instance. For example, the tool types may include Java development class tools, python development class tools, and (visual studio code, VScode) development class tools, and the like. The Java, python and VScode are all types of programming languages, and in the following embodiments, python may be called a first programming language, and VScode may be called a second programming language.

In addition, in the workspace 402, at least one operational control is displayed on each work item, such as at least one of a control indicating start, a control indicating delete, a control indicating open, a control indicating stop, a control indicating configure the workspace. Different operation controls can trigger the user terminal to send different control instructions to the workspace management service module, so as to instruct the workspace management service module to perform corresponding management on the work items and the corresponding IDE instances, such as deleting the work items, creating the IDE instances, destroying the IDE instances, and the like.

Illustratively, the above-described indication-actuated control is used to trigger creation of a work item corresponding IDE instance. The control for indicating deletion is used for triggering the destruction of the work item and the corresponding IDE instance. The control indicating to be opened can trigger the user terminal to display the compiling interface corresponding to the IDE instance, and the IDE instance is required to be in a running state before the compiling interface corresponding to the IDE instance is displayed. The control for indicating stop is used for triggering the destruction of the corresponding IDE instance of the work item. And the control for indicating the configuration work area is used for triggering and modifying the corresponding name of the work item, the corresponding IDE tool type, the required development environment type and the like. During the execution of an IDE instance, the corresponding IDE tool type or the required development environment type is changed, the server 1 can execute the IDE instance, and create a new IDE instance. In interface 401, a control, such as control 404, is also included that indicates the creation of a new work item. The control 404 is used to trigger a new work item. That is, the user terminal may receive an operation by the user indicating to create a work item, such as an operation for control 404. In this way, the user terminal can instruct the server 1 to create a new work item in response to the above operation. Thereafter, the workspace management service module may instruct the user terminal to display the newly added work item in the workspace 402.

In summary, during the display of the IDE service interface by the user terminal, the user terminal may send control instructions to the server 1 in response to a user operation, for example, instructions indicating to create a corresponding IDE instance, for example, instructions indicating to destroy the IDE instance, for example, and for example, instructions indicating to modify a development environment or a required development tool corresponding to the work item. In this scenario, the workspace management service module may perform corresponding management on the IDE instance according to the received control instruction.

When it is determined that an IDE instance needs to be created, the workspace management service module may create a corresponding instance creation task and place it in a queue for queuing. The instance creation task may instruct the resource management service module to perform resource scheduling.

When determining that the IDE instance needs to be destroyed, the work area management service module can also create a corresponding instance destruction task and put the corresponding instance destruction task into a queue for queuing. The instance destruction task may instruct the resource management service module to perform the release of resources.

The resource management service module is used for acquiring an instance creation task or an instance destruction task from the queue, and executing scheduling of resources or release of resources according to the acquired task. The resource management service module can sequentially process the tasks according to the sequence of the tasks entering the queue. The server 1 is enabled to support multi-user high concurrency management IDE instances through application of queuing techniques.

In addition, the server 1 may determine when to create an IDE instance or when to destroy an IDE instance by analyzing the habit of the user to use the IDE instance corresponding to each work item, in addition to determining whether to create an IDE instance or destroy an IDE instance in response to a control instruction transmitted from the user terminal. Thus, resources are prevented from being inefficiently occupied, and the length of time that a user waits to create an IDE instance is reduced.

In the embodiment of the present application, as shown in fig. 3, the server 1 further includes: the system comprises an intelligent start-stop module, a creation instance module and a destruction instance module.

Illustratively, the intelligent start-stop module is configured to predict a creation time point and a destruction time point of the IDE instance indicated by each work item.

In some embodiments, the intelligent start-stop module described above may include a neural network model for prediction, such as referred to as model 1. The model 1 may be a predictive classification model trained using attendance data, code submission time, historical use time of each work item, and the like. The model 1 can be the creation time and destruction time of the IDE instance corresponding to each work item. For example, a real-time system time is input to model 1, and if model 1 outputs the name of the work item and the identification of the characterization creation, the real-time system time is indicated as the creation time of the IDE instance to which the work item corresponds. If the model 1 outputs the name of the work item and the identification representing the destruction, the real-time system time is indicated as the destruction time of the IDE instance corresponding to the work item. If model 1 does not output the name of the work item, then it indicates that the real-time system time does not need to create an IDE instance, nor does it need to destroy the IDE instance.

The attendance data comprise card punching working time and card punching working time of the service account corresponding to the user. The code submission time may be a time indicating when code data was submitted during the writing of the code data by the user using the IDE instance. The historical usage time may be a historical creation time and a historical destruction time of the IDE instance to which the work item corresponds.

Taking as an example for work item a, the server 1 may take as a creation time sample, also referred to as first sample data, the time of work hours punched-out (i.e., attendance data), the historical creation time of the IDE instance a indicated by work item a (i.e., the time record when the user indicated creation or destruction of each instance). Then, using the creation time sample, model 1 is trained so that model 1 has the function of predicting the creation time of IDE instance a. In addition, the server 1 may also use the time of the card punch-out and the historical destruction time of the IDE instance a indicated by the work item a as a destruction time sample. In addition, code submission time can be used as a sample of destruction prohibition time. Then, training the model 1 by using the destroying time sample and the destroying time prohibiting sample respectively, so that the model 1 has a function of predicting the destroying time of the IDE instance a.

In addition, the process of training the model 1 using various types of samples can be referred to the related art. Illustratively, the same class of samples is split into two parts, e.g., 80% of the samples in the time of creation sample are used as training samples and 20% of the samples in the time of creation sample are used as test samples. Then, the model parameters of model 1 are iterated using the training samples. Then, the classification accuracy of the model 1 was checked using the test sample. The above model 1 may also be referred to as a first model.

In some embodiments, when the IDE instance a occupies the resources, the server 1 may input the real-time system time into the intelligent start-stop module, and identify whether the input real-time system time is a point of time when the IDE instance a needs to be destroyed. If the input real-time system time is determined to be the time point when the IDE instance a needs to be destroyed, the destruction instance module is notified. And generating an instance destroying task by using the destroying instance module, and placing the instance destroying task into a queue for queuing.

When the IDE instance a does not occupy resources, the server 1 may input the real-time system time into the intelligent start-stop module, and identify whether the input real-time system time is a time point when the IDE instance a needs to be created. If the entered real-time system time is determined to be the point in time at which IDE instance a is to be created, then the create instance module is notified. And generating an instance creation task by the instance creation module, and placing the instance creation task into a queue for queuing. In some embodiments, the intelligent start-stop module may determine a point in time when the first instance needs to be created, referred to as a first point in time. The first instance is an IDE instance corresponding to a first item, and the first item is a work item, for example, the work item 1 is a first item. Thus, when a user sends an access request to the server 1 (such as a first device) through a user terminal (such as a second device), first page data is sent to the second device in response to the access request, the first page data indicates that the second device displays first prompt information, and the first prompt information indicates that the first instance is in an operation state.

In addition, the time point when the intelligent start-stop module determines that the first instance needs to be destroyed may be referred to as a second time point.

In some embodiments, the resource management service module needs to cooperate with a network attached storage (network attached storage, NAS) management module, a container call module, a mirror management module, and the like in the server 1 in the process of executing an instance creation task or an instance destruction task.

The NAS management module is used for managing NAS space, for example, when the IDE instance is created, the NAS space is allocated for the IDE instance, and when the IDE instance is destroyed, the NAS space occupied by the IDE instance is recovered. And the image management module is used for determining matched image files for the IDE instance to be created. And the container calling module is used for running the matched image file, creating a container corresponding to the IDE instance on the resource provided by the server 1, and the container can provide a system environment required by the running of the IDE instance.

For example, a plurality of types of image files, such as a Java image file, a Python image file, and a general image file, may be stored in the server 1 in advance.

It will be appreciated that an image file is a static program file, such as the underlying file system on which an IDE instance depends. There are differences in the required operating environments for writing IDE instances of different classes of programming language (e.g., IDE instances known as different classes). There may also be differences in the underlying file systems on which the different classes of IDE instances depend.

Thus, the image files that match the different classes of IDE instances may also be different, e.g., the program files corresponding to Java image files may create a container suitable for writing Java, which may deploy a first class of IDE instances that may be used to write Java class code data. For another example, a program file corresponding to a Python image file may create a container suitable for writing Python, which may deploy a second type of IDE instance that may be used to write Python type code data.

In some embodiments, the image management module may determine the matching image file according to the required tool type and the required development environment corresponding to the work item. For example, the tool type required for work item a is a Java development class tool, and then the matching image file may be a Java image file that includes the underlying file system corresponding to the development environment required for work item a. For example, the matching second image file may be determined based on a desired tool type (e.g., first tool) of the first project, a desired development environment (e.g., first development environment). The second image file includes an executable file of the first tool and a program file for building the first development environment.

Taking the resource management service module as an example, the instance creation task a is executed. The instance creation task a is used for indicating to create the IDE instance a corresponding to the work item a. In this way, the resource management service module may instruct the NAS management module to allocate a usable NAS space for the IDE instance a, and then instruct the image management module to determine the matched image file according to the required tool type and the development environment corresponding to the work item a. In this way, the container scheduling module may run the matched image file in the NAS space corresponding to the IDE instance a, and create a container suitable for deploying the IDE instance a. In some embodiments, the matching image file may further include an IDE kernel corresponding to IDE instance a, such that, after the container is created, IDE instance a is deployed in the container.

In summary, in the above embodiment, when the user operates the user terminal to create a work item, the tool type and development environment corresponding to the work item have been selected. Thus, whether the server 1 autonomously identifies the IDE instance of the work item to be created or the server 1 determines the IDE instance of the work item to be created in response to the user operation, the image management module may determine the matched image file directly according to the tool type and the development environment configured by the user. The container call module then runs the matching image file creating a container for deploying the IDE instance.

In other embodiments, in the scenario where the user terminal accesses the code compartment, and jumps to access the server 1, after authentication of the user terminal by the server 1, the server 1 may create an IDE instance corresponding to the code compartment, which may be used to process code data stored in the code compartment, e.g. to modify the code data of the code compartment, or to continue writing on the code data of the code compartment.

In addition, in the process of creating the IDE instance corresponding to the code bin, the code bin access module and the intelligent analysis module in the server 1 need to be matched.

Illustratively, the code bin access module is configured to access a designated code bin and query code data stored in the code bin, such as code data 1. In addition, the code bin specified above may be a code bin accessed by the user terminal before the jump.

Also, for example, the above-mentioned intelligent analysis module is configured to identify the type of the program language corresponding to each piece of code data 1, and count the duty ratio of each type of the program language, for example, referred to as duty ratio data. For example, 10 pieces of code data 1,6 pieces of code data written in Java and 4 pieces of code data written in Python are stored in a specified code bin. Thus, the intelligent analysis module can determine that the programming language type corresponding to the code data 1 comprises two types of Java and Python, and the proportion data comprises 60% corresponding to Java and 40% corresponding to Python. For example, the first code bin includes first code data and second code data, where the first code data and the second code data are codes written in two different types of programming languages, and of course, the first code bin may also include code programs written in other types of programming languages, and here, the first code data and the second code data are exemplified. The server 1 may determine a first duty ratio corresponding to the first code data, and a second duty ratio corresponding to the second code data, where the first duty ratio is a ratio between the first code data and all code data in the first code bin, and the second duty ratio is a ratio between the second code data and all code data in the first code bin. And when the first duty ratio is larger than the second duty ratio, determining the type of the program language corresponding to the first code data as the first type of the program language.

In addition, the intelligent analysis module may further send a notification 1 to the image management module, where the notification 1 includes the duty ratio data corresponding to the code data 1. In this way, the image management module can select the matched image file from the pre-stored image files by combining the duty ratio data carried in the notification 1.

The type of programming language with the highest corresponding duty cycle may be referred to as language type 1, such as the first type of programming language. When only one type of language type belongs to language type 1, an image file matching the language type 1, such as a first image file, is selected, for example, the selected image file can create a container (first container) suitable for deploying the IDE instance b (second instance). In addition, in IDE instance b, language type 1 may be employed for code composition. When the number of the language types 1 is greater than 1, that is, when the plurality of program languages have the same duty ratio, the selected image file is a common image. Wherein the generic mirror image can create a generic container. In this way, the user can instruct the server 1 to deploy various types of IDE instances in a generic container.

In other embodiments, the user terminal may also trigger access to the server 1 when it opens a piece of code data (e.g. called code data 2) using the code QC tool. In this scenario, after the authentication of the user terminal by the server 1, the server 1 may also create an IDE instance corresponding to the code data 2, which IDE instance may be used for processing the code data 2, e.g. modifying on the basis of the code data 2, or continuing writing on the basis of the code data 2, etc.

In some embodiments, the creation of the IDE instance for processing the code data 2 is similar to the principle of creating the IDE instance corresponding to the code bin in the foregoing embodiments, that is, the intelligent analysis module analyzes the program language type of the code data 2, and then the mirror management module determines the mirror file matched with the code data 2, so that the container scheduling module may create the corresponding IDE instance by using the matched mirror file, and the detailed implementation process is not repeated herein.

In some embodiments, the server 1 uses container technology to enable multiple IDE instances to run independently in different containers, with different resources being consumed. For example, IDE instance 1, IDE instance 2, and IDE instance 3 in fig. 3 belong to different containers and occupy NAS space 1, NAS space 2, and NAS space 3, respectively. In this scenario, NAS space 1, NAS space 2, and IDE instance 3 are all marked as occupied.

When the server 1 determines that any IDE instance needs to be destroyed, for example, when the resource management service module obtains an instance destroy task from the queue, the resource management service module can destroy the IDE instance indicated by the instance destroy task and mark the occupied resource as available. For example, the instance destruction task may instruct to destroy IDE instance 1, the resource management service module may destroy IDE instance 1, for example, the resource management service module may also instruct the container scheduling module to destroy the container in which IDE instance 1 is deployed. The resource management service module may then mark the resources occupied by IDE instance 1 as available, e.g., NAS space 1 occupied by IDE instance 1 as available.

During the operation of the IDE instance, a user may install a new tool in the IDE instance via the user terminal or change the system configuration corresponding to the IDE instance (e.g., the operating system parameters corresponding to the container of the IDE instance).

In some embodiments, the server 1 further comprises a user monitoring module and a self-mirror module. The user monitoring module is used for monitoring the behavior of a user indicating an installation tool or changing the system configuration through a user terminal, and the behavior is called behavior 1. For example, the user terminal transmits instruction information 1 to the server 1 in response to a user operation. The instruction information 1 may be an instruction indicating an installation tool, or the instruction information 1 may also be an instruction indicating modification of a system configuration. The user monitoring module may treat the event "receive instruction information 1" as behavior 1.

In addition, the instruction information 1 also carries an instance identifier 1, where the instance identifier 1 may indicate an IDE instance running in the server 1, and in a subsequent embodiment, the IDE instance indicated by the instance identifier 1 may be referred to as an IDE instance c. Thus, when the instruction information 1 is an instruction indicating that the tool is installed, the server 1 can install the tool specified by the user in the IDE instance c in response to the instruction information 1, and the tool identification specified by the user can also be carried in the instruction information 1. When the instruction information 1 is an instruction for modifying the system configuration, the server 1 may change a specified parameter of the operating system where the IDE instance c is located in response to the instruction information 1, and the specified parameter may also be carried in the instruction information 1.

After the user monitoring module monitors behavior 1, if the instruction information 1 is validated, the user monitoring module may instruct the autogenous mirror module to backup the container in which the IDE instance c is located. Illustratively, when instruction information 1 is an instruction indicating an installation tool, the instruction information 1 having been validated means that the installation of the user-specified tool has been completed in the IDE instance c. When the instruction information 1 is an instruction indicating modification of the system configuration, the instruction information 1 having been validated means that the server 1 has completed the change of the specified parameter in the operating system where the IDE instance c is located.

In some embodiments, the autoradiography module performs a backup of the container of IDE instance c after each instruction information 1 has been validated. In the case where the same container is backed up multiple times, the latest backup is saved.

Illustratively, the autogenous mirror module performs a first backup process for the container of IDE instance c: if the instruction information 1 indicates that the tool designated by the user is installed, acquiring an executable file corresponding to the tool, and then merging the executable file corresponding to the tool into the initial image file to obtain the backup image file. Where the initial image file refers to the image file used when creating IDE instance c. If the instruction information 1 indicates an instruction for modifying the system configuration, the modified system configuration is updated to the initial image file to obtain a backup image file, which is also called a backup image file.

Also illustratively, the autogenous mirror module performs the process of the nth backup for the container of IDE instance c: if the instruction information 1 indicates that the tool specified by the user is installed, acquiring an executable file corresponding to the tool, and packaging the executable file corresponding to the tool into the image file of the n-1 th backup. Wherein n is greater than 1. If the instruction information 1 indicates an instruction for modifying the system configuration, the modified system configuration is updated to the image file of the n-1 th backup to obtain the backup image file.

In other embodiments, before destroying an IDE instance, the autogenous mirror module queries, via the user monitoring module, whether the corresponding instruction information 1 was received during the running of the IDE instance. The corresponding instruction information 1 carries an instance identifier of the IDE instance, and the instruction information 1 is validated. Thus, when the corresponding instruction information 1 is determined to be received, the autogenous mirror module backs up the container corresponding to the IDE instance.

Illustratively, the process of backing up the container corresponding to the IDE instance may be: the method comprises the steps of obtaining executable files (such as second executable files) corresponding to all tools (such as second tools) which are indicated to be installed by a user during the operation of the IDE instance, and obtaining changed system configuration (such as first system parameters) during the operation of the IDE instance. And then merging the acquired executable file into the initial image file, and updating the changed system configuration into the initial image file to obtain a backup image file, which is also called a third image file.

In addition, when the backup image file corresponds to a work item, the backup image file may also be stored corresponding to the service account and the corresponding work item. For example, after the user terminal logs into the service account a, the server 1 is instructed to create an IDE instance for the work item d, and then the backup image file of the IDE instance d corresponds to the work item d, and the backup image file of the IDE instance d may be stored corresponding to the work item d and the service account a. In this way, in the case where the user terminal logs in to the service account a, when instructing the server 1 to create an IDE instance corresponding to the work item d, the server 1 can create a container in which the IDE instance is deployed based on the backup image file of the IDE instance d.

That is, in some embodiments, during the process of creating an IDE instance for a work item, the image management module may search whether a corresponding backup image file exists according to the service account number and the work item registered by the user terminal. If a backup image file exists, then the container call module is instructed to create a container with an IDE instance laid out based on the backup image file. If the backup image file does not exist, the image file matched with the work item is obtained from one of the prestored image files, and a container calling module creates a corresponding IDE instance based on the matched image file. That is, if the user terminal transmits first creation information including a first identification (e.g., item name information, creator information) corresponding to the first item, etc., to the server 1. The server 1 may, in response to the first creation information, look for whether a corresponding backup image file exists, i.e. said third image file associated with the first item. In the presence of the backup image file, a first instance is created based on the third image file. Thus, the first example includes the second tool and the first system parameter.

In addition, by the backup of the image file, not only can the backtracking of the IDE instance be realized, but also the occupation of the backup image file on storage resources can be effectively reduced.

In some embodiments, the server 1 may also issue code data written in an IDE instance into a pipeline (also referred to as an issue pipeline) in response to an issue instruction sent by the user terminal. Wherein the issue instruction includes an instance identification indicating an IDE instance and an identification indicating an issue type. The publication types described above include personal-level publications and application-level publications. The user terminal can determine the release type indicated by the release instruction according to the user operation. When the issue instruction instructs the individual stage issue, the server 1 may issue code data written in the IDE instance into the individual stage pipeline. When an issue instruction indicates an application level issue, the server 1 may issue code data written in the IDE instance indicated by the issue instruction into the application level pipeline, such as into a designated code bin.

Taking a development system including the device 1 and the server 1 as an example, a plurality of operation scenarios of the IDE management method provided by the embodiment of the present application will be described.

In some scenarios, as shown in fig. 5, the IDE management method provided by the embodiment of the application includes the following steps:

S101, the intelligent start-stop module determines that the current system time is the creation time point corresponding to the IDE example 4.

In some embodiments, the IDE instance 4 may be an IDE instance corresponding to the preconfigured work item 1. The intelligent start-stop module may predict a creation time point of the IDE instance corresponding to the first type of work item. Wherein the first type of work item is a work item that the corresponding IDE instance has not yet created. The above work item 1 belongs to the first category of work items.

In addition, the method of the intelligent start-stop module predicting the creation time point can refer to the implementation principle of the intelligent start-stop module in the embodiment, and will not be described herein.

In some embodiments, the intelligent start-stop module may acquire the current system time corresponding to the server 1 in real time, and then the intelligent start-stop module may perform classification and identification based on the current system time to determine whether the current system time is a creation time point corresponding to the first type of work item.

S102, the intelligent start-stop module sends notification information 1 to the creation instance module.

Wherein the notification information 1 includes an item identifier 1, and the notification information 1 is used for indicating an instance creation task 1 corresponding to the creation work item 1.

In addition, each item identifier may uniquely indicate a work item, and the item identifier 1 may uniquely indicate the work item 1. The above item identification 1 may be, for example, a serial number of the work item 1 in the server 1. The item identifier 1 may be, for example, item name information of the work item 1, creator information, and a corresponding service account (e.g., service account 1).

S103, the instance creation module creates an instance creation task 1 and puts the instance creation task in a queue.

S104, the resource management service module acquires the instance creation task 1 from the queue.

S105, the resource management service module sends notification information 2 to the mirror image management module.

The notification information 2 also includes an item identifier 1.

S106, the image management module determines the matched image file 1 according to the work item 1 indicated by the notification information 2.

In some embodiments, the image management module may find work item 1 based on item identification 1 in notification information 2. Then, depending on work item 1, a matching image file is determined, such as referred to as image file 1.

Illustratively, the image management module searches the image file 1 from the pre-stored image files according to the required tool type and the required development environment corresponding to the work item 1, that is, the image file matched with the work item 1. The above process of searching the image file 1 refers to the foregoing embodiment, and is not described herein.

Also for example, the image management module may first determine whether work item 1 corresponds to a backup image file. The foregoing backup image file creation process may refer to the description of the foregoing embodiments, and will not be repeated herein. And when the fact that the work item 1 corresponds to the backup image file is determined, the backup image file is taken as the image file 1. When the fact that the image file is not backed up by the work item 1 is determined, the image file 1 is searched out from the prestored image files according to the required tool type and the required development environment corresponding to the work item 1.

S107, the image management module sends the identification of the image file 1 to the container call module.

S108, the container calling module creates a container deployed with the IDE instance 4 based on the image file 1.

In some embodiments, the process of creating a container with an IDE instance deployed on the basis of an image file may refer to the related art, and will not be described in detail herein.

S109, the browser application in the user terminal responds to the operation of the user and sends an access request 1 to an API gateway service module in the server 1.

In some embodiments, service account 1 and the corresponding password are included in access request 1. The access request 1 is used for requesting to access an IDE service interface provided by the server 1.

S110, the API gateway service module responds to the access request 1 to determine that the user terminal passes authentication.

S111, the API gateway service module sends response data 1 to the browser application to instruct the browser application to display an IDE service interface.

Wherein, the response data 1 includes page data for displaying an IDE service interface.

S112, the browser application displays an IDE service interface.

The IDE service interface displays a work item 1, and controls indicating opening and stopping are displayed relative to the work item 1.

S113, the browser application transmits an access request 2 to the API gateway service module in response to an operation of opening the work item 1 instructed by the user.

The access request 2 includes an instance identifier of the IDE instance 4, which is used for requesting to display a compiling interface corresponding to the IDE instance 4.

In some embodiments, the browser application may request a communication connection with the IDE instance 4 by sending an access request 2. After the browser application establishes a connection with the IDE instance 4, the flow proceeds to S114.

S114, the API gateway service module sends response data 2 to the browser application to instruct the browser application to display the compiling interface corresponding to the IDE example 4.

Before access request 2 is received, the IDE instance 4 corresponding to work item 1 has been created and is running. In this way, the API gateway service module can quickly respond to the access request 1, sending response data 2 to the browser application. In addition, the response data 2 includes page data for displaying the compiling interface.

In other embodiments, during the operation of the IDE instance 4, as shown in fig. 6, the IDE management method provided in the embodiment of the application includes the following steps:

s201, the intelligent start-stop module determines that the current system time is the destruction time point corresponding to the IDE example 4.

In some embodiments, the implementation of S201 may refer to S101, and the intelligent start-stop module may be used to predict whether the current system time is the destruction time point corresponding to DE instance 4.

S202, the intelligent start-stop module determines that the browser application has closed the compiling interface of the IDE example 4.

In some embodiments, the intelligent start-stop module may query from the API gateway service module whether the last information sent by the browser application was a message indicating to close the compiling interface. If so, then it is determined that the browser application has closed the compiled interface of IDE instance 4.

S203, the intelligent start-stop module sends notification information 3 to the destruction instance module.

The notification information 3 also includes an item identifier 1 corresponding to the work item 1.

S204, the destroying instance module generates an instance destroying task 1 and puts the instance destroying task 1 into a queue.

In some embodiments, the destruction instance module determines that the IDE instance corresponding to the work item 1, that is, the IDE instance 4, needs to be destroyed according to the item identifier 1 in the notification information 3. Then, an instance destruction task 1 indicating destruction of the IDE instance 4 is generated.

S205, the resource management service module acquires an instance destruction task 1 from the queue, and destroys the IDE instance 4 in response to the instance destruction task 1.

In another scenario (e.g., the user terminal accesses the code bin a and then, in response to a user operation, jumps to access the server 1), as shown in fig. 7, the above IDE management method includes the steps of:

s301, the code bin access module instructs the API gateway service module to send an access request 3 to the code bin a.

Wherein the access request 3 is used to indicate to query the code data 1 in the code bin a. The code bin a establishes a communication connection with the API gateway service module in response to the access request 3. In this way, the code data 1 stored in the code bin a is acquired through the data interaction between the API gateway service module and the code bin a.

S302, the intelligent analysis module identifies the corresponding program language type of each section of code data 1 in the code bin a, and counts corresponding duty ratio data, wherein the duty ratio data are used for indicating the duty ratio among the program language types.

In some embodiments, the implementation of S302 may refer to the implementation principle of the intelligent analysis module, which is not described herein.

S303, the intelligent analysis module sends notification information 4 to the mirror image management module.

In some embodiments, the notification information 4 includes duty cycle data. The notification information 4 may be the notification 1 in the foregoing embodiment.

S304, the mirror image management module determines the matched mirror image file 2 according to the duty ratio data in the notification information 4.

In some embodiments, the implementation details of S304 may refer to the image management module mentioned in the foregoing embodiments to select the matching image file according to notification 1, which is not described herein.

S305, the image management module sends the identification of the image file 2 to the container call module.

S306, the container call module creates a container with the IDE instance 5 deployed based on the image file 2.

In some embodiments, the process of creating a container with an IDE instance deployed on the basis of an image file may refer to the related art, and will not be described in detail herein. In the above IDE example 5, editing of code data can be performed using the program language with the heaviest duty in the code bin 1.

The embodiment of the application also provides a server, which can comprise: a memory and one or more processors. The memory is coupled to the processor. The memory is for storing computer program code, the computer program code comprising computer instructions. The computer instructions, when executed by the processor, cause the server to perform the steps performed by the handset in the embodiments described above. Of course, the server includes, but is not limited to, the memory and one or more processors described above.

The embodiment of the application also provides electronic equipment, which can comprise: a memory and one or more processors. The memory is coupled to the processor. The memory is for storing computer program code, the computer program code comprising computer instructions. The computer instructions, when executed by the processor, cause the electronic device to perform the steps performed by the handset in the embodiments described above. Of course, the electronic device includes, but is not limited to, the memory and the one or more processors described above.

The embodiment of the application also provides a chip system which can be applied to the terminal equipment in the embodiment. As shown in fig. 8, the system-on-chip includes at least one processor 2201 and at least one interface circuit 2202. The processor 2201 may be a processor in an electronic device as described above. The processor 2201 and the interface circuit 2202 may be interconnected by wires. The processor 2201 may receive and execute computer instructions from the memory of the electronic device described above through the interface circuit 2202. The computer instructions, when executed by the processor 2201, cause the electronic device to perform the steps performed by the handset in the embodiments described above. Of course, the system-on-chip may also include other discrete devices, which are not particularly limited in accordance with embodiments of the present application.

In some embodiments, it will be clearly understood by those skilled in the art from the foregoing description of the embodiments, for convenience and brevity of description, only the division of the above functional modules is illustrated, and in practical application, the above functional allocation may be implemented by different functional modules, that is, the internal structure of the apparatus is divided into different functional modules to implement all or part of the functions described above. The specific working processes of the above-described systems, devices and units may refer to the corresponding processes in the foregoing method embodiments, which are not described herein.

The functional units in the embodiments of the present application may be integrated in one processing unit, or each unit may exist alone physically, or two or more units may be integrated in one unit. The integrated units may be implemented in hardware or in software functional units.

The integrated units, if implemented in the form of software functional units and sold or used as stand-alone products, may be stored in a computer readable storage medium. Based on such understanding, the technical solution of the embodiments of the present application may be essentially or a part contributing to the prior art or all or part of the technical solution may be embodied in the form of a software product stored in a storage medium, including several instructions for causing a computer device (which may be a personal computer, a server, or a network device, etc.) or a processor to perform all or part of the steps of the method described in the embodiments of the present application. And the aforementioned storage medium includes: flash memory, removable hard disk, read-only memory, random access memory, magnetic or optical disk, and the like.

The foregoing is merely a specific implementation of the embodiment of the present application, but the protection scope of the embodiment of the present application is not limited to this, and any changes or substitutions within the technical scope disclosed in the embodiment of the present application should be covered in the protection scope of the embodiment of the present application. Therefore, the protection scope of the embodiments of the present application shall be subject to the protection scope of the claims.

Claims

1. An IDE management method, applied to a first device, the method comprising:

When the system time reaches a first time point, a first instance corresponding to a first item is created, wherein the first time point is a system time point at which the first instance is estimated to be started;

receiving an access request sent by second equipment;

Responding to the access request, sending first page data to the second equipment, wherein the first page data indicates the second equipment to display first prompt information, and the first prompt information indicates the first instance to be in a running state;

destroying the first instance when the system time reaches a second point in time, wherein the second point in time is a point in time when the system time is estimated to be closed; the second time point is a destroying time point of the first instance by using a first model, the first model is a neural network model obtained by training first sample data, the first sample data comprises historical destroying time, card punching working time and code submitting time of each instance, the historical destroying time and the card punching working time are destroying time samples, and the code submitting time is destroying prohibition time samples;

after the first instance is destroyed, the second device accesses a first code bin, and under the scene of determining to jump to access the first device, first login information sent by the second device is received, wherein the first login information comprises a first address of the first code bin;

after the first login information passes authentication, accessing the first code bin according to the first address;

determining a first duty ratio according to the number of first code data in the first code bin and the total number of code data in the first code bin; the first code data is a code written by adopting a first type of programming language;

Determining a second duty ratio according to the number of second code data in the first code bin and the total number of code data in the first code bin; wherein the second code data adopts a different type of programming language from the first type of programming language;

Searching a first image file matched with the first type of program language under the condition that the first duty ratio is larger than the second duty ratio, wherein the first image file is used for creating a first container, the first container is used for deploying a second instance, and the second instance is used for compiling the first type of program language;

the second instance is created based on the first image file.

2. The method of claim 1, wherein the first model is further used to predict a start time of a user using the respective instance of the item, the method further comprising:

Determining, with the first model, the first time of a first instance; the first sample data further comprises a time record for creating each instance and a time of punching and working.

3. The method of claim 1, wherein creating the first instance corresponding to the first item comprises:

Querying a second image file matched with the first project in a plurality of preconfigured image files, wherein the second image file is used for creating a container for deploying a first instance and comprises an executable file of a first tool and a program file for constructing a first development environment, the first tool is a basic tool in the first instance, and the first development environment is a running environment required by the first instance;

And generating the first instance according to the second image file.

4. A method according to claim 3, wherein prior to destroying the first instance, the method further comprises:

Acquiring a second executable file corresponding to a second tool, wherein the second tool is a program tool installed in the first instance during the operation of the first instance;

acquiring a first system parameter, wherein the first system parameter is changed in the first instance during the operation of the first instance;

and packaging the second executable file, the first system parameters and the second image file to obtain a third image file, and associating the third image file with the first project, wherein the third image file is used for creating a container for deploying the first instance.

5. The method according to claim 4, wherein the method further comprises:

Receiving first creation information sent by the second device, wherein the first creation information comprises a first identifier corresponding to the first item;

determining that the third image file associated with the first item exists;

The first instance is created based on the third image file, wherein the first instance comprises the second tool and the first system parameter.

6. An electronic device comprising one or more processors and memory; the memory being coupled to a processor, the memory being for storing computer program code comprising computer instructions which, when executed by one or more processors, are for performing the method of any of claims 1-5.

7. A computer storage medium comprising computer instructions which, when run on an electronic device, cause the electronic device to perform the method of any of claims 1-5.

8. A computer program product, characterized in that the computer program product comprises a computer program which, when run on a computer, causes the computer to perform the method according to any of claims 1-5.