CN112732265A - Data processing method and related device - Google Patents
Data processing method and related device Download PDFInfo
- Publication number
- CN112732265A CN112732265A CN201911038478.2A CN201911038478A CN112732265A CN 112732265 A CN112732265 A CN 112732265A CN 201911038478 A CN201911038478 A CN 201911038478A CN 112732265 A CN112732265 A CN 112732265A
- Authority
- CN
- China
- Prior art keywords
- character string
- data packet
- source character
- target source
- target
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
- 238000003672 processing method Methods 0.000 title claims abstract description 14
- 238000012360 testing method Methods 0.000 claims abstract description 162
- 238000011161 development Methods 0.000 claims abstract description 96
- 230000008859 change Effects 0.000 claims abstract description 73
- 238000000034 method Methods 0.000 claims abstract description 69
- 230000010354 integration Effects 0.000 claims description 176
- 230000002085 persistent effect Effects 0.000 claims description 146
- 230000002159 abnormal effect Effects 0.000 claims description 101
- 238000009434 installation Methods 0.000 claims description 77
- 230000001419 dependent effect Effects 0.000 claims description 38
- 230000004044 response Effects 0.000 claims description 29
- 238000012545 processing Methods 0.000 claims description 25
- 230000007246 mechanism Effects 0.000 claims description 17
- 238000001514 detection method Methods 0.000 claims description 12
- 230000003068 static effect Effects 0.000 claims description 10
- 238000004806 packaging method and process Methods 0.000 claims description 9
- 230000007613 environmental effect Effects 0.000 claims description 8
- 238000004458 analytical method Methods 0.000 claims description 7
- 238000004891 communication Methods 0.000 claims description 7
- 238000004590 computer program Methods 0.000 claims description 7
- 238000004088 simulation Methods 0.000 claims description 6
- 230000001502 supplementing effect Effects 0.000 claims description 2
- 239000002699 waste material Substances 0.000 abstract description 8
- 230000000875 corresponding effect Effects 0.000 description 224
- 230000008569 process Effects 0.000 description 32
- 230000003993 interaction Effects 0.000 description 16
- 238000010586 diagram Methods 0.000 description 9
- 230000005856 abnormality Effects 0.000 description 7
- 230000006870 function Effects 0.000 description 7
- 239000013589 supplement Substances 0.000 description 3
- 230000009286 beneficial effect Effects 0.000 description 2
- 238000004364 calculation method Methods 0.000 description 2
- 230000002596 correlated effect Effects 0.000 description 2
- 238000005516 engineering process Methods 0.000 description 2
- 239000000126 substance Substances 0.000 description 2
- 230000001360 synchronised effect Effects 0.000 description 2
- 238000012217 deletion Methods 0.000 description 1
- 230000037430 deletion Effects 0.000 description 1
- 238000012986 modification Methods 0.000 description 1
- 230000004048 modification Effects 0.000 description 1
- 230000003287 optical effect Effects 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
- G06F8/40—Transformation of program code
- G06F8/41—Compilation
- G06F8/48—Incremental compilation
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F11/00—Error detection; Error correction; Monitoring
- G06F11/36—Preventing errors by testing or debugging software
- G06F11/3668—Software testing
- G06F11/3672—Test management
- G06F11/368—Test management for test version control, e.g. updating test cases to a new software version
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y02—TECHNOLOGIES OR APPLICATIONS FOR MITIGATION OR ADAPTATION AGAINST CLIMATE CHANGE
- Y02D—CLIMATE CHANGE MITIGATION TECHNOLOGIES IN INFORMATION AND COMMUNICATION TECHNOLOGIES [ICT], I.E. INFORMATION AND COMMUNICATION TECHNOLOGIES AIMING AT THE REDUCTION OF THEIR OWN ENERGY USE
- Y02D10/00—Energy efficient computing, e.g. low power processors, power management or thermal management
Abstract
The embodiment of the application discloses a data processing method and a related device, wherein the method comprises the following steps: acquiring a target source character string associated with a business management warehouse and increment change attribute information corresponding to the target source character string; the target source character string is determined by the target terminal after being changed aiming at the historical source character string corresponding to the applet associated with the first application; embedding the target source character string into the historical source character string according to the increment change attribute information, and generating a test data packet corresponding to the applet according to the historical source character string embedded with the target source character string; and sending the test data packet to a first service server corresponding to the first application so that the first service server distributes the test data packet to a target test user. By adopting the method and the device, the efficiency of generating the test data packet can be improved, and the waste of development resources can be avoided.
Description
Technical Field
The present application relates to the field of internet technologies, and in particular, to a data processing method and a related apparatus.
Background
In the prior art, a developer can manually compile through a compiling button on a development interface of a development terminal, and manually upload a test data packet successfully compiled for an applet to a wechat server through an uploading button. In other words, the prior art needs to consume long man-machine interaction operations in the process of generating the test data packet, thereby reducing the generation efficiency of the test packet.
In addition, in the current development scene of the applet, each development terminal can be used for code development and code compilation, so that each development terminal can directly push the generated test data packet to the wechat server, that is, in the prior art, each development terminal can directly perform data interaction with the wechat server, and the phenomenon that the wechat server can repeatedly receive the test data packets uploaded by a plurality of development terminals is caused. For example, the WeChat Server may overwrite the previously received test packet with the last received test packet, so that there is a waste of development resources in the current applet development process.
Content of application
The embodiment of the application provides a data processing method and a related device, which can improve the generation efficiency of a test data packet and avoid the waste of development resources.
An aspect of the present embodiment provides a data processing method, where the method is applied to a persistent integration server, and includes:
acquiring a target source character string associated with a business management warehouse and increment change attribute information corresponding to the target source character string; the target source character string is determined by the target terminal after being changed aiming at the historical source character string corresponding to the applet associated with the first application;
embedding the target source character string into the historical source character string according to the increment change attribute information, and generating a test data packet corresponding to the applet according to the historical source character string embedded with the target source character string;
and sending the test data packet to a first service server corresponding to the first application so that the first service server distributes the test data packet to a target test user.
The obtaining of the target source character string associated with the business management repository and the incremental change attribute information corresponding to the target source character string includes:
acquiring service submission notification information which is sent by a service management server corresponding to the service management warehouse aiming at the target source character string; the service submission notification information contains a hash value of version information corresponding to the target source character string;
and pulling the target source character string and the increment change attribute information corresponding to the target character string from the service management warehouse according to the hash value.
The obtaining of the target source character string associated with the business management repository and the incremental change attribute information corresponding to the target source character string includes:
when the current time length reaches the timing pulling time length, a source code pulling instruction aiming at the target source character string is obtained;
and pulling the target source character string and the increment change attribute information corresponding to the target character string from the service management warehouse according to the source code pulling instruction.
The business management warehouse is a code database used for data sharing in a business management server; the code database contains service code data uploaded by at least one terminal associated with the applet; the service code data comprises the target source character string uploaded by a target terminal in the at least one terminal and increment change attribute information corresponding to the target source character string; the service management server is used for performing distributed storage on the target source character string uploaded by the target terminal and performing version management on the version information of the target source character string.
The embedding the target source character string into the historical source character string according to the increment change attribute information, and generating the test data packet corresponding to the applet according to the historical source character string in which the target source character string is embedded, includes:
embedding the target source character string into the historical source character string according to the increment change attribute information, and generating a data packet to be compiled corresponding to the applet according to the historical source character string embedded with the target source character string;
and compiling the data packet to be compiled according to the dependent data file corresponding to the small program, and obtaining a test data packet corresponding to the small program when the compiling state of the data packet to be compiled is a successful state.
The embedding the target source character string into the historical source character string according to the increment change attribute information, and generating a data packet to be compiled corresponding to the applet according to the historical source character string in which the target source character string is embedded, includes:
carrying out anomaly detection on the target source character string;
when detecting that the target source character string does not meet the abnormal pulling condition, determining the position information of the target source character string in the historical source character string according to the increment change attribute information;
and embedding the target source character string into the historical source character string based on the position information, and taking the historical source character string embedded with the target source character string as a data packet to be compiled corresponding to the small program.
Wherein the content of the first and second substances,
the method further comprises the following steps:
when the target source character string is detected to meet the abnormal pulling condition, generating abnormal pulling log information corresponding to the target source character string;
generating first abnormal reminding information corresponding to the small program according to at least one abnormal pulling factor in the abnormal pulling log information;
pushing the first abnormal reminding information to a group associated with the small program through a second business server associated with the small program; the group is a group in a second application different from the first application; the group includes at least one development user participating in developing the applet.
The compiling the data packet to be compiled according to the dependent data file corresponding to the applet, and obtaining the test data packet corresponding to the applet when the compiling state of the data packet to be compiled is a success state includes:
acquiring a dependent data packet associated with the data packet to be compiled, and acquiring a dependent data file for compiling the data packet to be compiled when the installation state of the dependent data packet is a successful state;
according to a third-party class library provided in the dependency data file, code compiling is carried out on the data packet to be compiled, and a sub-packaging mechanism corresponding to the small program is obtained;
dividing the data packet to be compiled into N sub packets based on the sub packet mechanism; n is a positive integer; the N sub-packages comprise a first data package associated with a main page of the applet and a second data package associated with a sub-page of the applet;
and when the compiling state of the data packet to be compiled is a success state, obtaining a test data packet corresponding to the small program based on the first data packet and the second data packet.
Wherein the method further comprises:
when the installation state of the dependent data packet is a failure state, generating installation abnormal log information;
generating installation error prompt information based on the installation abnormal factors associated with the installation abnormal log information;
if the installation abnormal factor belongs to an environmental abnormal factor irrelevant to the target source character string, taking the installation error prompt message as a first class of abnormal prompt message corresponding to the small program;
and if the abnormal installation factor belongs to the abnormal code factor related to the target source character string, acquiring a code submission record corresponding to the target source character string and developer information related to the code submission record, supplementing the code submission record and the developer information to the error installation prompt information, and taking the supplemented error installation prompt information as second type abnormal prompt information corresponding to the small program.
Wherein the method further comprises:
when the compiling state of the data packet to be compiled is a failure state, generating compiling error log information corresponding to the data packet to be compiled, and carrying out error analysis on the compiling error log information to obtain a compiling error factor corresponding to the data packet to be compiled; the compiling error factor comprises a static grammar error corresponding to a target source character string in the data packet to be compiled;
generating second abnormal reminding information corresponding to the small program based on the static grammar error;
sending the second abnormal reminding information to a group associated with the small program through a second business server associated with the small program; the group is a group in a second application different from the first application.
Wherein the sending the test data packet to a first service server corresponding to the first application includes:
acquiring a target interface provided by a continuous integration platform on the continuous integration platform corresponding to the applet; the target interface includes an IDE interface associated with the applet;
and calling the IDE interface to upload the test data packet simulation to a first service server corresponding to the first application.
Wherein the method further comprises:
if response text information returned by the first service server for the test data packet is acquired within a response duration, determining that the test data packet is uploaded;
if the response text information returned by the first service server is not acquired within the response duration, generating abnormal uploading log information, generating third abnormal reminding information corresponding to the small program according to abnormal uploading factors in the abnormal uploading log information, and sending the third abnormal reminding information to a group associated with the small program through a second service server associated with the small program; the group is a group in a second application different from the first application.
An aspect of an embodiment of the present application provides a data processing apparatus, where the apparatus is applied to a persistent integration server, and the apparatus includes:
the system comprises a character string acquisition module, a service management warehouse and a service management module, wherein the character string acquisition module is used for acquiring a target source character string associated with the service management warehouse and increment change attribute information corresponding to the target source character string; the target source character string is determined by the target terminal after being changed aiming at the historical source character string corresponding to the applet associated with the first application;
the character string embedding module is used for embedding the target source character string into the historical source character string according to the increment change attribute information and generating a test data packet corresponding to the applet according to the historical source character string embedded with the target source character string;
and the data packet sending module is used for sending the test data packet to a first service server corresponding to the first application so that the first service server can distribute the test data packet to a target test user.
Wherein, the character string obtaining module comprises:
a notification obtaining unit, configured to obtain service submission notification information sent by a service management server corresponding to the service management repository for a target source character string; the service submission notification information contains a hash value of version information corresponding to the target source character string;
and the first obtaining unit is used for pulling the target source character string and the increment change attribute information corresponding to the target character string from the business management warehouse according to the hash value.
Wherein, the character string obtaining module comprises:
the instruction acquisition unit is used for acquiring a source code pulling instruction aiming at a target source character string when the current time length reaches the timing pulling time length;
and the second obtaining unit is used for pulling the target source character string and the increment change attribute information corresponding to the target character string from the service management warehouse according to the source code pulling instruction.
The business management warehouse is a code database used for data sharing in a business management server; the code database contains service code data uploaded by at least one terminal associated with the applet; the service code data comprises the target source character string uploaded by a target terminal in the at least one terminal and increment change attribute information corresponding to the target source character string; the service management server is used for performing distributed storage on the target source character string uploaded by the target terminal and performing version management on the version information of the target source character string.
Wherein the string embedding module includes:
the character embedding unit is used for embedding the target source character string into the historical source character string according to the increment change attribute information and generating a data packet to be compiled corresponding to the applet according to the historical source character string embedded with the target source character string;
and the compiling processing unit is used for compiling the data packet to be convenient according to the dependent data file corresponding to the small program, and obtaining the test data packet corresponding to the small program when the compiling state of the data packet to be compiled is a success state.
Wherein the character embedding unit includes:
an anomaly detection subunit, configured to perform anomaly detection on the target source character string;
the position determining subunit is configured to, when it is detected that the target source string does not satisfy an abnormal pulling condition, determine, according to the incremental change attribute information, position information of the target source string in the history source string;
and the character embedding subunit is used for embedding the target source character string into the historical source character string based on the position information, and taking the historical source character string embedded with the target source character string as a to-be-compiled data packet corresponding to the applet.
Wherein the content of the first and second substances,
the character embedding unit further includes:
the first log generation subunit is configured to generate abnormal pull log information corresponding to the target source string when it is detected that the target source string satisfies the abnormal pull condition;
the first exception reminding subunit is used for generating first exception reminding information corresponding to the applet according to at least one exception pulling factor in the exception pulling log information;
the first reminding pushing subunit is used for pushing the first abnormal reminding information to a group associated with the applet through a second service server associated with the applet; the group is a group in a second application different from the first application; the group includes at least one development user participating in developing the applet.
Wherein the compiling processing unit includes:
the dependency obtaining subunit is configured to obtain a dependency data packet associated with the to-be-compiled data packet, and obtain a dependency data file for compiling the to-be-compiled data packet when the installation state of the dependency data packet is a success state;
the compiling subunit is used for compiling the code of the data packet to be compiled according to the third-party class library provided in the dependency data file and acquiring a sub-packaging mechanism corresponding to the small program;
the sub-packaging subunit is used for dividing the data packet to be compiled into N sub-packages based on the sub-packaging mechanism; n is a positive integer; the N sub-packages comprise a first data package associated with a main page of the applet and a second data package associated with a sub-page of the applet;
and the test packet generation subunit is configured to, when the compiling state of the data packet to be compiled is a success state, obtain, based on the first data packet and the second data packet, a test data packet corresponding to the applet.
Wherein the compiling processing unit further includes:
a second log generating subunit, configured to generate installation exception log information when the installation state of the dependent packet is a failure state;
the installation error subunit is used for generating installation error prompt information based on the installation abnormality factors associated with the installation abnormality log information;
the character irrelevant subunit is used for taking the installation error prompt message as a first class of abnormal prompt message corresponding to the small program if the installation abnormal factor belongs to an environmental abnormal factor irrelevant to the target source character string;
and the character correlation subunit is configured to, if the installation exception factor belongs to a code exception factor correlated with the target source character string, acquire a code submission record corresponding to the target source character string and developer information correlated with the code submission record, supplement the code submission record and the developer information to the installation error prompt information, and use the supplemented installation error prompt information as second-class exception prompt information corresponding to the applet.
Wherein the compiling processing unit further includes:
the compiling error subunit is used for generating compiling error log information corresponding to the data packet to be compiled when the compiling state of the data packet to be compiled is a failure state, and carrying out error analysis on the compiling error log information to obtain a compiling error factor corresponding to the data packet to be compiled; the compiling error factor comprises a static grammar error corresponding to a target source character string in the data packet to be compiled;
the second exception reminding subunit is used for generating second exception reminding information corresponding to the small program based on the static syntax error;
the second reminding pushing subunit is used for sending the second abnormal reminding information to a group associated with the applet through a second service server associated with the applet; the group is a group in a second application different from the first application.
Wherein, the data packet sending module comprises:
the interface acquisition unit is used for acquiring a target interface provided by a continuous integration platform on the continuous integration platform corresponding to the applet; the target interface includes an IDE interface associated with the applet;
and the data packet uploading unit is used for calling the IDE interface to upload the test data packet simulation to a first service server corresponding to the first application.
Wherein the apparatus further comprises:
a response obtaining module, configured to determine that uploading of the test data packet is completed if response text information returned by the first service server for the test data packet is obtained within a response duration;
an exception uploading module, configured to generate exception uploading log information if response text information returned by the first service server is not obtained within the response duration, generate third exception reminding information corresponding to the applet according to an exception uploading factor in the exception uploading log information, and send the third exception reminding information to a group associated with the applet through a second service server associated with the applet; the group is a group in a second application different from the first application.
One aspect of the present application provides a computer device, comprising: a processor, a memory, a network interface;
the processor is connected to a memory and a network interface, wherein the network interface is used for providing a data communication function, the memory is used for storing a computer program, and the processor is used for calling the computer program to execute the method in the above aspect in the embodiment of the present application.
An aspect of the present application provides a computer-readable storage medium storing a computer program comprising program instructions that, when executed by a processor, perform the method of the above-mentioned aspect of the embodiments of the present application.
The method and the device for processing the incremental change attribute information can acquire a target source character string associated with a business management warehouse and the incremental change attribute information corresponding to the target source character string; the target source character string is determined by the target terminal after being changed aiming at the historical source character string corresponding to the applet associated with the first application; embedding the target source character string into the historical source character string according to the increment change attribute information, and generating a test data packet corresponding to the applet according to the historical source character string embedded with the target source character string; and sending the test data packet to a first service server corresponding to the first application so that the first service server distributes the test data packet to a target test user. Therefore, according to the application, a target source character string (for example, a newly uploaded source code) acquired from a business management warehouse can be embedded into a historical source character string through the introduced continuous integration server, the historical source character string can be an existing source code (for example, a last uploaded source code) in the continuous integration server, the continuous integration server can provide continuous integration service to automatically generate the test data packet, so that human-computer interaction can be avoided, and the generation efficiency of the test data packet can be improved without a button. In addition, by automatically generating the test data packet in the persistent integration server, data interaction between the target terminal (i.e., the development terminal) and the first service server (e.g., the WeChat server) can be avoided, so that decoupling cooperation can be fully exerted in the development process of the applet, and waste of development resources is avoided.
Drawings
In order to more clearly illustrate the embodiments of the present application or the technical solutions in the prior art, the drawings used in the description of the embodiments or the prior art will be briefly described below, it is obvious that the drawings in the following description are only some embodiments of the present application, and for those skilled in the art, other drawings can be obtained according to the drawings without creative efforts.
Fig. 1 is a schematic structural diagram of a network architecture according to an embodiment of the present application;
fig. 2 is a schematic flowchart of a data processing method according to an embodiment of the present application;
fig. 3 is a schematic view of a scenario for performing pull-on-demand according to an embodiment of the present application;
FIG. 4 is a flowchart illustrating a process for performing persistent integration tasks according to an embodiment of the present application;
fig. 5 is a schematic view of a scenario for generating installation exception log information according to an embodiment of the present application;
FIG. 6 is a schematic flow chart diagram of another data processing method provided in the embodiments of the present application;
fig. 7 is a schematic view of a scenario for uploading a test data packet according to an embodiment of the present application;
fig. 8 is a scene schematic diagram of collaborative development according to multiple development terminals according to an embodiment of the present application;
fig. 9 is a schematic structural diagram of a data processing apparatus according to an embodiment of the present application;
fig. 10 is a schematic diagram of a computer device according to an embodiment of the present application.
Detailed Description
The technical solutions in the embodiments of the present application will be clearly and completely described below with reference to the drawings in the embodiments of the present application, and it is obvious that the described embodiments are only a part of the embodiments of the present application, and not all of the embodiments. All other embodiments, which can be derived by a person skilled in the art from the embodiments given herein without making any creative effort, shall fall within the protection scope of the present application.
Fig. 1 is a schematic structural diagram of a network architecture according to an embodiment of the present invention. As shown in fig. 1, the network architecture may include a target terminal 7000n, a service management server 6000, a persistent integration server 2000, a first service server 4000, a first user terminal cluster, a second service server 5000 and a second user terminal cluster.
As shown in fig. 1, the first user terminal cluster may include a plurality of user terminals, and the plurality of user terminals may specifically include the user terminals 3000a and … and the user terminal 3000b shown in fig. 1; as shown in fig. 1, the user terminals 3000a, … and 3000b may be respectively in network connection with the first service server 4000, so as to enable data interaction in the first user terminal cluster through the first application server 4000.
Further, the network architecture may further include a second service server 5000 and a second user terminal cluster, where the second user terminal cluster may include a plurality of user terminals, as shown in fig. 1, and specifically may include user terminals 3000c and … and a user terminal 3000 n; as shown in fig. 1, the user terminals 3000c, … and 3000n may be respectively connected to the second application server 5000 via a network, so as to enable data interaction in the second user terminal cluster via the second application server 5000.
The applications installed in each user terminal (for example, the user terminal 3000a) in the first user terminal cluster may include a first application, and the first application may be an instant messaging application. As shown in fig. 1, each user terminal in the first user terminal cluster may implement user data interaction with the first service server 4000 through an instant messaging platform in the first application.
Similarly, as shown in fig. 1, the applications installed in each user terminal (e.g., user terminal 3000c) in the second user terminal cluster may include a second application, and the second application may be understood as an office application, which may be referred to as another instant messaging application; as shown in fig. 1, each user terminal in the second user terminal cluster may implement user data interaction with the second service server 5000 through an instant messaging platform in the second application.
It can be understood that, according to a development framework of a first application (for example, a WeChat application), the embodiment of the present application can provide a set of persistent integration platforms for implementing automatic detection, automatic generation of test data packets, and automatic uploading of test data packets for development of applets.
As shown in fig. 1, the persistent integration server 2000 may be introduced in an applet development scenario to modify a network architecture in developing an applet in the prior art, for example, at this time, a development terminal (e.g., the target terminal 7000n shown in fig. 1) for developing an applet cannot directly perform data interaction with the persistent integration server 2000. Therefore, in the embodiment of the present application, through the network architecture shown in fig. 1, a phenomenon that the first service server 4000 repeatedly receives a plurality of test data packets uploaded by a plurality of development terminals due to data interaction between the plurality of development terminals and the first service server 4000 in the applet development process can be avoided, and further, waste of development resources can be avoided. In addition, the introduced persistent integration server 2000 can automatically compile and generate the test data packet without a button and automatically upload the generated test data packet, so that the generation efficiency of the test data packet can be improved.
Among them, with the development of internet technology, small programs (Mini programs) have come to be used as they are, and they are applications that can be used without downloading and installing them. In order to provide more diversified business services to the user, the developer may develop a corresponding applet for an application of the terminal (e.g., a first application, which may specifically include an instant messaging application, a shopping application, a mail application, etc.), and the applet may be embedded as a sub-application in the application of the terminal (i.e., the first application), and the corresponding business service may be provided to the user by running the sub-application (i.e., the corresponding applet) in the first application.
For convenience of understanding, the embodiment of the present application takes the first application as a wechat application in an instant messaging application as an example to illustrate a specific process of generating a test data packet by the persistent integration server 2000 shown in fig. 1 in the scenario of developing the foregoing applet. In the embodiment of the present application, servers for storing source codes (i.e., source character strings) and for performing version management may be collectively referred to as a git server, and the git server may be the service management server 6000 described in fig. 1. It should be understood that, in the process of performing version management, the business management server 6000 in this embodiment of the application mainly performs hash calculation on the version information of the source code uploaded by the development terminal, so as to uniquely obtain a hash value that can be used for identifying the version information of the source code. It should be understood that there may be a plurality of development terminals in a network connection relationship with the service management server 6000, or there may be one development terminal, and the number of development terminals will not be limited herein.
The git server (i.e., the business management server 6000) may be configured to perform distributed storage on the source code uploaded by each development terminal, so that each development terminal may implement data sharing through a business management repository in the git server (i.e., the business management server 6000). It should be understood that, in the embodiment of the present application, the business management repository on the git server may be referred to as a remote repository. In addition, it can be understood that, in the process of developing a project a created for the same applet, the git server can help a plurality of terminals perform decoupled cooperation (i.e., distributed development), that is, when it is determined that a new source code for the project a of the applet is acquired, the new source code can be synchronized at each development terminal.
In order to distinguish the source codes uploaded by each terminal, the embodiments of the present application may calculate the hash value of the version information corresponding to each source code through the git server, so as to obtain the hash value of the version information uniquely identifying each source code. For example, taking a development terminal a and a development terminal B among a plurality of development terminals as an example, the git server may quickly calculate a hash value (for example, hash value 1) of version information of the source code 1 newly developed by the development terminal a with respect to the project a, or may obtain a hash value (for example, hash value 2) of version information of the source code 2 newly developed by the development terminal B with respect to the project a. It should be understood that, by the persistent integration server according to the embodiment of the present application, integrity of the acquired newly developed source code may be checked through the hash value, so as to ensure integrity of the target source code participating in the persistent integration task.
It can be understood that, in the embodiments of the present application, a source code that is newly developed for a certain project may be referred to as a target source code, and may also be referred to as a target source string. For example, when the current time is time T1, the embodiment of the present application may refer to the source code developed and uploaded by the development terminal a this time as target source code (i.e., target source character string), and refer to the source code developed and uploaded by the development terminal B at time T2 (i.e., last time T1) as historical source code, which may also be referred to as historical source character string. Furthermore, it is understood that the development terminal a may synchronize the source code uploaded by the development terminal B from the aforementioned service management repository (i.e., the remote repository) to the local repository 1 for storage through a source code obtaining instruction in advance, so that a developer may perform change processing on a working file in which the stored historical source character string is located in the development terminal (e.g., may perform a deletion operation of the source code, an addition operation of the source code, and the like).
For convenience of understanding, in the embodiment of the present application, one development terminal of a plurality of development terminals is taken as an example, and the development terminal may be the target terminal 7000n shown in fig. 1. As shown in fig. 1, when a developer (for example, developer a) corresponding to the target terminal 7000n can locally complete a change operation (for example, a delete operation, an add operation, a correct operation, and the like) on a work file to which the history source string belongs, a target source code (that is, the target source string n shown in fig. 1) corresponding to the change operation in the work file can be submitted to the business management repository shown in fig. 1 for storage. It should be understood that when the target source string n submitted by the target terminal 7000n exists in the service management repository, it may be notified that the persistent integration server 2000 shown in fig. 1 performs synchronous update on the target source string n, that is, the persistent integration server may pull the target source string n from the service management repository as needed when acquiring the submission notification (i.e., the service submission notification information).
It is to be appreciated that the persistent integration server 2000 may be operable to provide persistent integration services for applets. In other words, when synchronizing the history source string with the target terminal 7000n, the service management server 6000 may also synchronize the history source strings with the persistent integration server 2000 shown in fig. 1. Therefore, the aforementioned history source string may be stored in the local repository 2 of the persistent integration server 2000 shown in fig. 1. Further, it is understood that when the persistent integration server 2000 pulls the target source string n from the business management repository shown in fig. 1, the incremental change attribute information corresponding to the target source string n may be acquired together. For example, the incremental change attribute information may specifically include: and adding a source code in which line of the working file where the historical source character string is positioned, and deleting specific position information such as the source code in which line.
Further, the persistent integration server 2000 may automatically embed the target source string n into a corresponding position in the historical source string according to the added change attribute information, so that automatic compilation may be performed according to the historical source string embedded with the target source string n to automatically generate the test data packet corresponding to the applet.
As shown in fig. 1, the persistent integration server 2000 may upload the automatically generated test packets to the first traffic server 4000 shown in fig. 1. It should be understood that the first service server 4000 may be a background server corresponding to the aforementioned first application. For convenience of understanding, in the embodiment of the present application, the first application may be the instant messaging application, for example, the instant messaging application may be a wechat application, and in this case, the first service server 4000 shown in fig. 1 may be a wechat server. It can be understood that, when the experience version of the developed applet runs in the user terminal integrated with the WeChat application (here, the test user terminal corresponding to the target test user may be used), the corresponding service may be provided through the experience data packet in the WeChat server.
As shown in fig. 1, when acquiring a test data packet corresponding to the applet, the first service server 4000 may use the test data packet as an experience data packet, store the experience data packet, and then may issue an identification image (e.g., a two-dimensional code) of a part corresponding to the experience data packet to a target test user, so that the target test user may access an experience version of the applet by identifying the two-dimensional code in a test user terminal running a first application (e.g., the above-mentioned WeChat application), and thus may start the experience version of the applet in the first application.
It can be understood that, in the embodiment of the present application, the target test user may be a user corresponding to each of the plurality of user terminals in the first user terminal cluster shown in fig. 1. The plurality of user terminals in the first user terminal cluster may specifically be the user terminals 3000a,. and 3000b shown in fig. 1. In the embodiment of the present application, the user terminal corresponding to the specified user (i.e. the target test user) in the first user terminal cluster may be referred to as a test user terminal. Furthermore, it should be understood that, during the process of starting the applet in the first application, the corresponding test user terminal (for example, the user terminal 3000a shown in fig. 1) may obtain the aforementioned experience data packet from the first service server 4000 to load the source code in the aforementioned test data packet, so as to provide the corresponding service for the target test user. For example, if the applet is a WeChat reading applet in a reading application applet, a reading service for electronic readings in the WeChat reading applet can be provided for a target test user.
As shown in fig. 1, if the persistent integration server 2000 fails to compile during the process of executing the persistent integration task, the task state of the persistent integration task may be set to a failure state, and corresponding abnormal reminding information may be generated when the compiling fails, and then the abnormal reminding information may be pushed to the second service server 5000 shown in fig. 1, so that the second service server 5000 may find a group to which developers participating in the development of the applet belong, so as to perform abnormal reminding in the enterprise WeChat (i.e., the second application), thereby ensuring that corresponding developers in the group in the enterprise WeChat can know the abnormal reminding information. It is to be understood that the second service server 5000 can be the second application (for example, the enterprise wechat application in another instant messaging application) and is not limited herein.
It should be understood that, the subsequent developer may also continue to perform a new change operation on the working file containing the target source code locally in the development terminal, and may further submit a new target source character string corresponding to the new change operation to the aforementioned business management repository. Therefore, when the development terminal in the embodiment of the application completes the development task, the whole work file of the project aiming at the small program does not need to be submitted, and therefore repeated submission of the source code in the development process can be avoided.
The specific processes of acquiring the target source string and the incremental change attribute information corresponding to the target source string, and automatically generating and uploading the test data packet by the persistent integration server 2000 may be as follows with reference to the implementation manners provided by the embodiments corresponding to fig. 2 to 8.
Further, please refer to fig. 2, which is a flowchart illustrating a data processing method according to an embodiment of the present application. The executing agent of the data processing method may be a persistent integration server, which may be the persistent integration server 2000 in the embodiment corresponding to fig. 1. As shown in fig. 2, a method provided in an embodiment of the present application may include:
step S101, acquiring a target source character string associated with a business management warehouse and increment change attribute information corresponding to the target source character string;
specifically, in the development scenario of the applet, the persistent integration server may be implemented in the following two ways: the on-demand pull method and the timed pull method acquire the latest source code (i.e., the target source string) from a service management repository (e.g., the remote repository described in fig. 1 above), and may perform the persistent integration task on the currently acquired target source string in the persistent integration server. It can be understood that, while the persistent integration server obtains the target source character string, the persistent integration server may also obtain the incremental change attribute information corresponding to the target source character string.
The business management repository may be a code database (for example, the git repository) in the business management server for data sharing; the code database may contain service code data uploaded by at least one terminal associated with the applet; the service code data may include the target source character string uploaded by the target terminal of the at least one terminal and the incremental change attribute information corresponding to the target source character string; the service management server may be configured to perform distributed storage on the target source character string uploaded by the target terminal, and perform version management on version information of the target source character string.
The business management repository may be a remote repository in the embodiment corresponding to fig. 1, and the remote repository may be a git repository corresponding to the git server. It is understood that the git repository in the embodiment of the present application may be a storage device independent from the git server, and alternatively, the git repository may be a storage device integrally installed in the git server, which will not be limited herein. It should be understood that the git repository may be configured to uniformly store the development data package uploaded by each development terminal, where the development data package may include the target source character string (i.e., the target source code) uploaded by each development terminal and the incremental change information corresponding to the target source character string. In addition, the git repository may also be used to update the version information of the received data packets, i.e., may be used for version management. For example, the git repository may be used to perform a hash calculation on a hash value of version information corresponding to each received target source string (i.e., target source code), so as to establish an index file for indexing the source code in the git server through the unique hash value.
The index file may record hash values corresponding to source codes submitted to the git repository each time, for example, may record hash values 1 corresponding to target source codes submitted this time (e.g., target source codes submitted at the current time), and may also record hash values 2 corresponding to target source codes submitted historically (e.g., target source codes submitted at the previous time). For example, the index file can quickly acquire the history source character string corresponding to the corresponding version information previously submitted by the target terminal from the git warehouse, and then the version rollback can be performed through the version rollback instruction. In the embodiment of the present application, the target source codes submitted by the history may be collectively referred to as the history source codes, or the history source codes may be referred to as the history source character strings.
In other words, the git warehouse described in the embodiment of the present application may be understood as a hosting tool capable of performing distributed storage on the acquired target source code, and version management and distributed development may be conveniently performed on the source code submitted in the applet development process through the git warehouse. The distributed development refers to that the development terminals having a network connection relationship with the service management server all can realize a data sharing function through a git warehouse, for example, the git warehouse can ensure that each developer can obtain the latest updated source code from the git warehouse according to a source code pull instruction (for example, "fetch command" in git command), so that the distributed development can be performed on the project in the respective development terminals. It is understood that the persistent integration server may also fetch data from a remote repository (i.e., git repository) by calling the "fetch command" that is not available in the local repository of the persistent integration server, so as to fetch the latest updated target source string on the git repository to the local repository (i.e., the local repository of the persistent integration server), and further execute step S102 to execute the persistent integration task in the persistent integration server.
The on-demand pull manner refers to that the persistent integration server may pull, from the git server, the source code (i.e., the target source character string) that is newly uploaded by the developer (e.g., the developer a) when acquiring the service submission notification information actively sent by the service management server (i.e., the git server) corresponding to the service management repository. Specifically, the persistent integration server may obtain service submission notification information, which is sent by the service management server corresponding to the service management repository for the target source character string; the service submission notification information comprises a hash value of version information corresponding to the target source character string; further, the persistent integration server may pull the target source character string and the incremental change attribute information corresponding to the target character string from the business management repository according to the hash value.
For easy understanding, please refer to fig. 3, which is a schematic diagram of a scenario for performing pull-on-demand according to an embodiment of the present application. The service management server shown in fig. 3 may, when detecting that a target source character string in a development data packet newly uploaded by a development terminal (i.e., the target terminal shown in fig. 3) is added in a git repository (i.e., the service management repository shown in fig. 3), generate service submission notification information shown in fig. 3 based on a hash value of version information corresponding to the target source character string (for example, the hash value may be a fixed-length character string, such as a 16-bit character string represented in a 16-ary system), where the service submission notification information is used to notify the persistent integration server shown in fig. 3 to perform pull-on-demand, for example, the persistent integration server may quickly index a target source character string stored in the service management repository shown in fig. 3 based on the hash value of the target source character string and grab the target source character string to a local repository of the persistent integration server, and the continuous integration server can perform hash check, so that when the hash value of the currently captured target source character string is determined to be inconsistent with the hash value of the last captured target source character string (namely the historical source character string), the position information of the target source character string relative to the historical source character string can be determined according to the acquired increment change attribute information. The service submission notification information may include a hash value of version information corresponding to the target source character string; it will be appreciated that this hash value may be used to uniquely identify version information of the target source string stored in the git repository (i.e., the aforementioned git repository). In other words, as shown in fig. 3, the persistent integration server may accurately pull the target source character string from the service management repository according to the hash value corresponding to the target source character string, and acquire the increment change attribute information corresponding to the target character string at the same time as acquiring the target source character string.
It can be understood that, in the embodiment of the present application, the source code in the data packet received by the service management server each time may also be referred to as a source string. In this embodiment of the present application, a source character string uploaded by a target terminal at a current time may be referred to as a target source character string, and the target source character string may be a target source code in the embodiment corresponding to fig. 1. In addition, in the embodiment of the present application, a source string uploaded by a target terminal at a previous time may be referred to as a history source string, and the history source string may be a history source code in the embodiment corresponding to fig. 1.
It should be understood that the timing pull manner is that the persistent integration server may be configured to determine whether the current time reaches the timing pull duration, and may periodically pull the target source string that is newly uploaded by the developer from the git server (i.e., the service management server) when it is determined that the current time reaches the timing pull duration. In other words, when the current duration reaches the timing pulling duration, the persistent integration server obtains a source code pulling instruction for the target source character string (that is, automatically invokes a source code obtaining instruction corresponding to the target source character string, where the source code obtaining instruction may be the git command in the embodiment corresponding to fig. 1); further, the persistent integration server may pull the target source string and the incremental change attribute information corresponding to the target string from the business management repository (e.g., the business management repository in the embodiment corresponding to fig. 3) according to the source code pull instruction.
The applet developed in the embodiment of the present application may be the applet described in the embodiment corresponding to fig. 1. The applet may specifically include at least one applet, such as an e-reading applet, an entertainment application applet, a shopping application applet, etc., which shall not be limited herein. It should be understood that in the development process of the applet, the persistent integration server is introduced to perform automatic compiling, and when the compiling is successful, the test data packet obtained after the automatic compiling is automatically sent to the wechat server, so that the wechat server can use the test data packet as an experience data packet, and further can push the experience data packet to a target test user for experience.
And step S102, embedding the target source character string into the historical source character string according to the increment change attribute information, and generating a test data packet corresponding to the applet according to the historical source character string embedded with the target source character string.
Specifically, the persistent integration server may embed the target source character string into the historical source character string according to the incremental change attribute information, and generate a to-be-compiled data packet corresponding to the applet according to the historical source character string embedded with the target source character string; further, the persistent integration server may compile the data packet to be compiled according to the dependent data file corresponding to the applet, and obtain the test data packet corresponding to the applet when the compiling state of the data packet to be compiled is a successful state.
It can be understood that, as shown in fig. 3, the target source code uploaded to the business management repository by the developer a may be obtained by modifying the working file to which the history source character string belongs by the developer a. For example, the developer a adds several lines of source codes a in the work file to which the historical source character string belongs (for example, the several lines of source codes a may be the target source character string shown in fig. 3), so that the target source codes received by the business management repository shown in fig. 3 may be the several lines of source codes a changed by the developer a, and the unchanged portions (for example, the historical source character string) in the work file are not uploaded. As shown in fig. 3, the development data packet uploaded by the developer a through the target terminal may include the several lines of source code a.
In addition, since the business management repository shown in fig. 3 has a data sharing function, the target source character string pulled from the business management repository by the persistent integration server in the embodiment of the present application may be several lines of source code a newly submitted by the developer a. In addition, in the development scenario of the applet, in order to add the functions of the operation controls corresponding to the several lines of the source code a to the applet of the previous version, the persistent integration server may obtain the newly submitted target source code a from the business management server when the persistent integration service of the applet is started, and may further perform the persistent integration task on the several lines of the source code a (i.e., the target source code). Wherein the persistent integration task may comprise a plurality of subtasks; the plurality of subtasks may specifically include: the method comprises the steps of automatically detecting subtasks, automatically installing subtasks, automatically compiling subtasks and automatically uploading subtasks.
The automatic detection subtask means that the persistent integration server can automatically detect whether the target source character string is successfully pulled in the process of pulling the target source character string. For example, when the hash value of the target source character string pulled from the service management warehouse (i.e., the remote warehouse) is compared with the hash value in the local warehouse, it may be determined that the target source character string is successfully pulled when it is determined that the hash value of the target source character string is different from the hash value in the local warehouse, the pulled target source character string may be embedded into a corresponding position of the history source character string, a to-be-compiled data packet corresponding to the applet is obtained, and the automatic installation subtask may be continuously executed. However, the persistent integration server may also generate abnormal pull log information corresponding to the target source character string when the code pull fails (for example, a network is abnormal or a service management warehouse is abnormal due to a downtime of the service management server), perform log analysis on the abnormal pull log information to determine an abnormal pull factor, and further generate first abnormal prompting information corresponding to the applet based on the determined abnormal pull factor.
The automatic installation subtask means that the continuous integration server can automatically install a third-party dependent package according to configuration information associated with a target source character string in the data package to be compiled when obtaining the data package to be compiled, and obtain a dependent data file for compiling the data package to be compiled when successfully installing the third-party dependent package. At this time, the persistent integration server may use a class library (i.e., a third-party class library, such as a public class library and an application class library) provided by the third party in the dependency data file corresponding to the third-party dependency package to perform code compilation on the data package to be compiled, so that an automatic compilation subtask may be automatically executed subsequently.
The automatic compiling subtask means that the continuous integration server can divide the data packet to be compiled into N sub-packets through a sub-packet mechanism in the process of performing code compiling on the data packet to be compiled. For example, the persistent integration server needs to divide the data packet to be compiled corresponding to the applet into different sub-packets, so that different sub-packets can be obtained when the applet is constructed, and thus, a subsequent user can load the developed applet (for example, an experience version of the applet) as needed when using the developed applet, so as to improve the efficiency of page loading of the applet. It should be understood that, in the embodiment of the present application, the first data package and the second data package obtained based on the packetization mechanism may be collectively referred to as a test data package of the applet, where the first data package may be a main package of the above N packetization packages, and the main package may include a source code for loading a home page of the applet. Wherein N is a positive integer.
It should be understood that when constructing a subcontract item of an applet (referred to as a subcontract), one or more subcontracts can be obtained, and the number of subcontracts is not limited herein. However, one main packet may be included in the N sub-packets constructed based on the sub-packet mechanism in the persistent integration server. It should be understood that the main package in the embodiment of the present application may contain pages associated with the main page of the applet, such as a placement default launch page, a toolbar (TabBar) page, and some sub-packages that all require a common resource/JS script. It can be understood that when the applet is started, the main package is downloaded by default and the page in the main package is started, when the user enters a certain page in the sub-package, the client downloads the corresponding sub-package, and the sub-package is displayed after the downloading is finished.
Wherein the packetization mechanism means that the persistent integration server needs to ensure that all the packetization sizes of the whole applet do not exceed a first threshold (e.g., 8M) and the size of a single packetization or main packet cannot exceed a second threshold (e.g., 2M). For example, the sub-package 1 corresponding to the page a and the sub-package 2 corresponding to the page B may be in the same sub-package (e.g., a main package), and if the total size of the pre-download of the sub-package 1 corresponding to the page a is 0.5M, it may be determined that the total size of the pre-download of the sub-package 2 corresponding to the sub-package B may be less than or equal to 1.5M according to the sub-package mechanism. It should be understood that by sub-packaging the applets, the downloading time of the first start of the applets can be effectively optimized, and decoupling cooperation can be better performed when multiple teams jointly develop the applets.
For easy understanding, please refer to fig. 4, which is a flowchart illustrating a process of performing persistent integration task according to an embodiment of the present application. As shown in fig. 4, the persistent integration server may execute step 10 in two ways (i.e., way a and way B) shown in fig. 4 when starting the persistent integration task, so as to obtain the target source character string newly submitted by the developer from the git repository corresponding to the business management server (i.e., the git server) having a network connection relationship with the persistent integration server.
Specifically, for example, as for the mode a shown in fig. 4, when the persistent integration server is started, the persistent integration server may execute a timed pull task to trigger a timer, so that a timed pull function may be implemented by the timer, in other words, the persistent integration server may determine whether the current time reaches a timed pull duration (for example, 4 hours) by the timer, and if the current time reaches the timed pull duration, may pull the source code newly submitted in the git repository, that is, may pull the latest target source string from the service management repository.
Optionally, for example, as for the mode B shown in fig. 4, the persistent integration server may execute an on-demand pull task when the persistent integration server is started, and at this time, the git server may also generate service submission notification information when acquiring the latest target source character string (i.e., the latest target source code) uploaded by the development terminal, so as to actively notify the persistent integration server to pull the latest target source code. In other words, the git server in the embodiment of the present application may trigger generation of a code submission notification (this code submission notification may be referred to as the above-mentioned service submission notification information) when detecting the latest target source code uploaded by the developer, and send the code submission notification to the persistent integration server, so that the persistent integration server may pull the latest target source code uploaded by the developer from the git repository.
As shown in fig. 4, after the step 10 is executed, the persistent integration server may further execute step 20 to execute the automatic detection subtask to determine whether the latest target source string is successfully pulled, and if it is determined that the latest target source string is pulled, it may be determined that the target string does not satisfy the abnormal pulling condition, and then may execute step 30; otherwise, it is determined that the target source character string satisfies the abnormal pulling condition, for example, the developer does not upload the developed target source character string within the timing pulling duration, so that the persistent integration server cannot acquire the latest target source character string from the git repository when the current time reaches the timing pulling duration, for example, when the target source character string acquired from the git repository still corresponds to the previous version, it may be determined that the pulled target source character string satisfies the abnormal pulling condition. Optionally, when the network between the persistent integration server and the git server is abnormal or the git server is down, the persistent integration server cannot acquire the latest target source character string from the git warehouse, so that it can be determined that the pulled target source character string meets the abnormal pulling condition.
In other words, when the persistent integration server pulls the code, the pulled code may be detected to detect whether the pulled code has a problem (i.e., whether the above-mentioned abnormal pulling condition is satisfied). For another example, if there is a code pull failure, such as: if the code pulling failure is also caused by abnormal pulling factors such as network abnormality or git warehouse abnormality, the step 90 shown in fig. 4 may be skipped to, that is, when it is detected that the target source character string satisfies the abnormal pulling condition, an error log (for example, abnormal pulling log information) may be generated, so that the error cause may be analyzed in the persistent integration server according to the error log (that is, at least one abnormal pulling factor may be obtained), and thus error reminding information (for example, first abnormal reminding information) may be generated according to the error cause obtained by the analysis. As shown in fig. 4, when the persistent integration server executes step 100, it may determine whether the error reason is related to code submission, and if it is determined that the error reason is not related to code submission, may jump to execute step 120 to issue error information as exception reminding information to the enterprise WeChat group; for example, in the process of pulling the target source character string, if it is determined that the abnormal pulling factor includes any one of a network abnormality and a downtime of the git server, it may be determined that the current error cause belongs to an environmental abnormal factor, that is, does not belong to a code abnormal factor related to code submission.
As shown in FIG. 4, the persistent integration server may perform the auto-install subtask through steps 30-40 after performing step 20. It is understood that, after obtaining the data packet to be encoded through the above step 20, the persistent integration server may install a third party dependent packet according to the configuration information in the data packet to be encoded, so that the target source character string may be run through a third party class library provided by the third party dependent packet when compiling the data packet to be encoded. As illustrated in fig. 4, the persistent integration server may proceed to perform step 50 when completing the installation of the third party dependency package (which may also be referred to as a dependency data package or a third party installation package).
It can be understood that, in the process of installing the third-party dependent package, it is also determined whether the installation is successful through step 40, and if the installation fails (for example, the third-party dependent package cannot be acquired due to a network anomaly, or the installation fails when the third-party dependent package is abnormal), the persistent integration server may jump to step 90. At this time, since the network anomaly or the third party dependent package anomaly is the above-mentioned environmental anomaly factor, the persistent integration server may continue to perform step 120 after performing step 100.
For easy understanding, please refer to fig. 5, which is a schematic view of a scenario for generating installation exception log information according to an embodiment of the present application. The persistent integration server shown in fig. 5 may determine whether installation of the third-party dependent package is completed or not when the step 40 is completed, and if not, may generate the installation exception log information shown in fig. 5 when the installation state of the dependent data package (i.e., the third-party dependent package) is a failure state; further, the installation exception log information may be subjected to error analysis to determine a corresponding installation exception factor, and installation error prompt information may be generated based on the installation exception factor associated with the installation exception log information. As shown in fig. 5, when determining that the installation anomaly factor associated with the installation anomaly log information belongs to an environmental anomaly factor (i.e., when performing step 100, it is determined that the error root code is not relevant to submit), the persistent integration server may perform step 120 to display the first type of anomaly notification information corresponding to the applet in the target terminal (i.e., the development terminal) shown in fig. 5, where the first type of anomaly notification information may be the installation error notification information generated based on the installation anomaly factor.
Optionally, if the persistent integration server detects that the version of the third-party dependent package declared in the dependency data file associated with the submitted target source character string does not exist or the name of the third-party dependent package is wrong, the third-party dependent package cannot be installed, so that the installation of the third-party dependent package is also failed, and the persistent integration server may jump to execute step 90. At this time, an installation exception factor such as absence of a version of the third party dependency package declared in the dependency data file by a developer (for example, the above-described developer a) or a name error belongs to the code exception factor. After the step 100 is executed, the persistent integration server may continue to execute the step 110 to obtain the code submission record corresponding to the target source character string and the developer information associated with the code submission record, so that the code submission record and the developer information may be supplemented to the installation error prompting information, and the supplemented installation error prompting information may be used as the second type of exception prompting information corresponding to the applet. In other words, as shown in fig. 4, after the step 110 is executed, the persistent integration server may continue to step 120 to supplement the code submission record recently submitted by the developer a and the developer information of the developer a (for example, the group of the project to which the developer a belongs in the applet development process, the account information of the developer in the second application, and other information) into the installation error prompting information, so as to use the supplemented installation error prompting information as the second type of exception prompting information corresponding to the applet and push the second type of exception prompting information to the second service server (i.e., the enterprise WeChat server) corresponding to the second application (e.g., the enterprise WeChat), so that the second service server may notify the development group (e.g., the group K in the embodiment corresponding to fig. 5) where the developer a is located of the second type of exception prompting information, the supplemented installation error prompt information can be sent to the group K associated with the applet, so that the warning processing in the enterprise WeChat can be realized.
As shown in fig. 5, after the step 40 is executed, the persistent integration server may further execute an automatic compilation subtask through a step 50, and it can be understood that, in the process of performing automatic compilation, the persistent integration server may perform packetization on a data packet to be compiled through a packetization mechanism.
As shown in fig. 4, after the step 50 is executed, the persistent integration server may continue to step 60 to determine whether the compiling is successful, and if so, may jump to execute step 70, where the step 70 may be step S103 described below; otherwise, it may jump to step 90. It is immediately necessary that the compiling error factor determined in the process of compiling the compiling data packet may include a static syntax error, for example, the compiling fails due to a problem in the target source code uploaded by the developer, at this time, the persistent integration server may generate the second exception prompting information corresponding to the applet according to the static syntax error, so that the exception warning may be implemented through the step 100, the step 110, and the step 120. In other words, the method for performing the exception warning according to the embodiment of the present application is the same as the warning method for the second type of exception prompting information generated according to the code exception factor, and will not be further described here.
Step S103, the test data packet is sent to a first service server corresponding to the first application, so that the first service server distributes the test data packet to a target test user.
Specifically, the persistent integration server may obtain a target interface provided by the persistent integration platform on the persistent integration platform corresponding to the applet; the target interface includes an IDE interface associated with the applet; further, the persistent integration server may invoke the IDE interface to upload the test packet simulation to the first service server corresponding to the first application. When the first application is a wechat application in the instant messaging application, the first service server may be a background server corresponding to the wechat application.
It is to be understood that, after the step S102 is executed, the embodiment of the present application may further execute the step S103 to implement automatic uploading of the test data packet in the persistent integration server, so that the test data packet can be automatically uploaded in the persistent integration server without buttons (for example, without a compiling button and an uploading button).
As shown in fig. 4, step 103 of the persistent integration server may execute an automatic upload subtask through step 70, that is, the persistent integration server may call a target interface (i.e., IDE interface) provided by a developer tool in the persistent integration platform, and automatically upload the successfully compiled test packet to the above-mentioned WeChat server (i.e., the above-mentioned first service server). It is understood that, as shown in fig. 4, after the step 70 is executed, the persistent integration server may further execute a step 80 to determine whether the response text message returned by the WeChat server can be received within a preset response time, and if the response text message is received, it is determined that the uploading of the test data packet is completed, at this time, the single integration for the current target source character string may be ended in the persistent integration server.
Optionally, as shown in fig. 4, the persistent integration server may further generate abnormal upload log information when the response text information returned by the WeChat server is not acquired, and may generate third abnormal prompt information corresponding to the applet according to an abnormal upload factor in the abnormal upload log information. The abnormal uploading factor may specifically include: 1) network anomaly; 2) WeChat server exception; 3) the compiled code does not conform to the small program specification (e.g., too large, more than 2M; lack of necessary files, etc.). The abnormal uploading factor 1 and the abnormal uploading factor 2 belong to environmental abnormal factors, and at this time, the specific process of the third abnormal reminding information generated by the persistent integration server may refer to the description of the first type of abnormal reminding information in the embodiment corresponding to fig. 5, which will not be further described here. In addition, since the exception uploading factor 3 belongs to a code exception factor, at this time, the specific process of the third exception prompting information generated by the persistent integration server may refer to the description of the second exception prompting information, and will not be further described here.
It should be understood that after the first application server receives the test data packet of the applet, the test data packet may be used as an experience data packet, so that a two-dimensional code corresponding to the experience data packet may be generated, and therefore, based on the account information of the target test user in the first application bound in the applet development process, the two-dimensional code may be pushed to the target test user corresponding to the account information, so that the target test user may experience a business service provided by the newly developed applet through the two-dimensional code. It should be understood that, in the applet development process, the applets acquired by the target test users are applets carrying target identifiers (for example, carrying experience identifiers).
It can be understood that, in the embodiment of the present application, the applet may be developed under a wechat framework of the wechat application (i.e., the first application), and therefore, the test data packet finally generated by the persistent integration server may be uploaded to the wechat server (i.e., the first service server), so that a target test user using the wechat application may experience the provided service of the newly developed applet carrying the experience identifier. For example, taking a developed applet as a video application applet as an example, a developer may add a video playing plug-in to a previously developed video application applet, so that when a target test user specified by the developer uses the video application applet in a first application (i.e., a WeChat application), the target test user may experience a service function provided by the added video playing plug-in.
The method and the device for processing the incremental change attribute information can acquire a target source character string associated with a business management warehouse and the incremental change attribute information corresponding to the target source character string; the target source character string is determined by the target terminal after being changed aiming at the historical source character string corresponding to the applet associated with the first application; embedding the target source character string into the historical source character string according to the increment change attribute information, and generating a test data packet corresponding to the applet according to the historical source character string embedded with the target source character string; and sending the test data packet to a first service server corresponding to the first application so that the first service server distributes the test data packet to a target test user. Therefore, according to the application, a target source character string (for example, a newly uploaded source code) acquired from a business management warehouse can be embedded into a historical source character string through the introduced continuous integration server, the historical source character string can be an existing source code (for example, a last uploaded source code) in the continuous integration server, the continuous integration server can provide continuous integration service to automatically generate the test data packet, so that human-computer interaction can be avoided, and the generation efficiency of the test data packet can be improved without a button. In addition, by automatically generating the test data packet in the persistent integration server, data interaction between the target terminal (i.e., the development terminal) and the first service server (e.g., the WeChat server) can be avoided, so that decoupling cooperation can be fully exerted in the development process of the applet, and waste of development resources is avoided.
Further, please refer to fig. 6, which is a flowchart illustrating another data processing method according to an embodiment of the present application. As shown in fig. 6, the method may include at least:
step S201, when the current time length reaches the timing pulling time length, a source code pulling instruction aiming at a target source character string is obtained;
step S202, the target source character string and the increment change attribute information corresponding to the target character string are pulled from the service management warehouse according to the source code pulling instruction;
it can be understood that, in step S102 and step S103 in the embodiment of the present application, the user description persistent integration server may obtain, from the business management repository, the target source character string newly uploaded by the development terminal in a timed pull manner. It should be understood that the persistent integration server may further jump to execute step S203 after getting the target source character string uploaded by the development terminal, so as to execute the persistent integration task through the persistent integration service provided by the persistent integration server. The continuous integration task may include the automatic detection subtask, the automatic installation subtask, the automatic compilation subtask, the automatic upload subtask, and the like.
Step S203, embedding the target source character string into the historical source character string according to the increment change attribute information, and generating a data packet to be compiled corresponding to the applet according to the historical source character string embedded with the target source character string;
specifically, the persistent integration server may perform anomaly detection on the target source character string; further, the persistent integration server may determine, according to the incremental change attribute information, position information of the target source string in the historical source string when detecting that the target source string does not satisfy the abnormal pull condition; further, the persistent integration server may embed the target source string into the historical source string based on the location information, and use the historical source string embedded with the target source string as the to-be-compiled data packet corresponding to the applet.
And step S204, compiling the data packet to be compiled according to the dependent data file corresponding to the small program, and obtaining a test data packet corresponding to the small program when the compiling state of the data packet to be compiled is a success state.
Specifically, the persistent integration server may obtain a dependent data packet associated with the to-be-compiled data packet, and obtain a dependent data file for compiling the to-be-compiled data packet when the installation state of the dependent data packet is a successful state; further, the continuous integration server may compile a code of the data packet to be compiled according to a third-party class library provided in the dependency data file, and obtain a sub-package mechanism corresponding to the applet; further, the persistent integration server may divide the data packet to be compiled into N sub-packets based on the sub-packet mechanism; n is a positive integer; the N sub-packages comprise a first data package associated with a main page of the applet and a second data package associated with a sub-page of the applet; further, the persistent integration server may obtain the test data packet corresponding to the applet based on the first data packet and the second data packet when the compiling state of the to-be-compiled data packet is a success state.
Step S205, sending the test data packet to a first service server corresponding to the first application.
Specifically, the persistent integration server may obtain a target interface provided by the persistent integration platform on the persistent integration platform corresponding to the applet; the target interface includes an IDE interface associated with the applet; further, the persistent integration server may invoke the IDE interface to upload the test packet simulation to the first service server corresponding to the first application.
Step S206, if response text information returned by the first service server aiming at the test data packet is obtained within a response time length, determining to finish uploading the test data packet;
for easy understanding, please refer to fig. 7, which is a schematic view of a scenario for uploading a test packet according to an embodiment of the present application. As shown in fig. 7, when the to-be-compiled data packet is successfully compiled, the persistent integration server may obtain the test data packet shown in fig. 7, where the test data packet is determined by dividing the to-be-compiled data packet based on the packetization mechanism. As shown in fig. 7, the first service server (e.g., the WeChat server) may generate response text information for the test data packet uploaded by the persistent integration server when acquiring the test data packet, so that the persistent integration server may end the single integration for the target source string based on the response text information. In addition, the first service server (i.e., the wechat server) shown in fig. 7 may further use the test data packet as an experience data packet, and then may generate an experience invitation notification for the experience data packet, so that a target test user associated with the applet may obtain the experience invitation notification through a public number (or a subscription number, etc.) corresponding to the first application shown in fig. 7.
For convenience of understanding, in the embodiment of the present application, a terminal corresponding to a target test user may be referred to as a test user terminal shown in fig. 7, and it is understood that the test user terminal in the embodiment of the present application may be any user terminal (for example, the user terminal 3000a shown in fig. 1) in the first user terminal cluster in the embodiment corresponding to fig. 1. As shown in fig. 7, when the target test user (e.g., the test user K) corresponding to the test user terminal obtains the experience invitation notification, a trigger operation may be performed on the experience invitation notification, so as to display an identification image corresponding to the applet in a session interface including a public number (e.g., the AAAA shown in fig. 7) corresponding to the first application shown in fig. 7. It can be understood that, in the embodiment of the application, the identification image is taken as the two-dimensional code as an example, so that the test user K can obtain the experience data packet in the session interface by long-pressing the area where the two-dimensional code is located, and thus the experience version of the applet can be started in the first application, and the application display interface corresponding to the applet is accessed through the experience data packet, so that the newly added service function for the applet can be experienced in the corresponding application display interface.
Optionally, in step S207, if the response text information returned by the first service server is not acquired within the response duration, generating abnormal upload log information, generating third abnormal alert information corresponding to the applet according to an abnormal upload factor in the abnormal upload log information, and sending the third abnormal alert information to a group associated with the applet through a second service server associated with the applet; the group is a group in a second application different from the first application.
For convenience of understanding, please refer to fig. 8, which is a schematic view of a scenario in which collaborative development is performed according to multiple development terminals according to an embodiment of the present application. Each of the development terminals 10a, · in development china 10n shown in fig. 8 may submit a corresponding source code to the business repository shown in fig. 8. For example, the developer 1 shown in fig. 8 can develop a plug-in a of an applet, and the developer n can develop a plug-in B of an applet. Therefore, as shown in fig. 7, the development terminal 10a corresponding to the developer 1 can upload the source code 1 for the plug-in a to the business management repository 20 corresponding to the business management server, and similarly, the development terminal 10n corresponding to the developer 2 can upload the source code n for the plug-in B to the business management repository 20 corresponding to the business management server. At this time, when the current time reaches the timer pull time, the persistent integration server 30 shown in fig. 8 may execute the persistent integration service on the source codes uploaded by the two development terminals (in this case, the source codes are the target source codes).
Optionally, as shown in fig. 8, the service management server may further generate service submission notification information (i.e., the submission notification shown in fig. 8) for the two target source codes when detecting that a new target source character string exists in the service management repository shown in fig. 8, and further may pull the two target source character strings from the service management repository shown in fig. 8 when the persistent integration server 30 shown in fig. 8 acquires the submission notification shown in fig. 8, so that the persistent integration server 30 may execute the persistent integration task on the two target source character strings (for example, the persistent integration task may be executed successively for two different plug-ins, or the persistent integration task may be executed synchronously for the two plug-ins, which is not limited here). It should be understood that, in the embodiment of the present application, a specific implementation manner of performing the persistent integration task on two target source strings may refer to the description of the persistent integration task in the embodiment corresponding to the above 4. Therefore, as shown in fig. 8, the persistent integration server may upload the generated test data packet to the first service server 40b (e.g., the above-mentioned WeChat application) shown in fig. 8 when the compiling is successful. On the contrary, when the compiling fails, the error prompt information shown in fig. 8 may be sent to a second business server (for example, an enterprise wechat server), so that an exception alarm can be implemented in the enterprise wechat (i.e., the second application) through the enterprise wechat server.
The method and the device for processing the incremental change attribute information can acquire a target source character string associated with a business management warehouse and the incremental change attribute information corresponding to the target source character string; the target source character string is determined by the target terminal after being changed aiming at the historical source character string corresponding to the applet associated with the first application; embedding the target source character string into the historical source character string according to the increment change attribute information, and generating a test data packet corresponding to the applet according to the historical source character string embedded with the target source character string; and sending the test data packet to a first service server corresponding to the first application so that the first service server distributes the test data packet to a target test user. Therefore, according to the application, a target source character string (for example, a newly uploaded source code) acquired from a business management warehouse can be embedded into a historical source character string through the introduced continuous integration server, the historical source character string can be an existing source code (for example, a last uploaded source code) in the continuous integration server, the continuous integration server can provide continuous integration service to automatically generate the test data packet, so that human-computer interaction can be avoided, and the generation efficiency of the test data packet can be improved without a button. In addition, by automatically generating the test data packet in the persistent integration server, data interaction between the target terminal (i.e., the development terminal) and the first service server (e.g., the WeChat server) can be avoided, so that decoupling cooperation can be fully exerted in the development process of the applet, and waste of development resources is avoided.
Further, please refer to fig. 9, which is a schematic structural diagram of a data processing apparatus according to an embodiment of the present application. As shown in fig. 9, the data processing apparatus 1 may be applied to the persistent integration server 2000 in the embodiment corresponding to fig. 1. The data processing apparatus 1 may include: the device comprises a character string acquisition module 10, a character string embedding module 20 and a data packet sending module 30; further, the data processing apparatus 1 may also respond to the acquisition module 40 and the exception upload module 50;
a character string obtaining module 10, configured to obtain a target source character string associated with a business management repository and incremental change attribute information corresponding to the target source character string; the target source character string is determined by the target terminal after being changed aiming at the historical source character string corresponding to the applet associated with the first application;
wherein, the character string obtaining module 10 includes: a notification acquisition unit 101, a first acquisition unit 102; optionally, the instruction obtaining unit 103 and the second obtaining unit 104;
a notification obtaining unit 101, configured to obtain service submission notification information, which is sent by a service management server corresponding to the service management repository for a target source character string; the service submission notification information contains a hash value of version information corresponding to the target source character string;
a first obtaining unit 102, configured to pull the target source character string and the incremental change attribute information corresponding to the target character string from the service management repository according to the hash value.
Optionally, the instruction obtaining unit 103 is configured to obtain a source code pull instruction for the target source character string when the current duration reaches the timing pull duration;
a second obtaining unit 104, configured to pull the target source character string and the incremental change attribute information corresponding to the target character string from the service management repository according to the source code pull instruction.
It can be understood that, in the process of pulling the target source character string, the data processing apparatus 1 may pull the target source server from the service management repository as required through the notification obtaining unit 101, where the instruction obtaining unit 103 is not used, and the second obtaining unit 104 performs the regular pulling; optionally, when the instruction obtaining unit 103 and the second obtaining unit 104 regularly pull the target source server from the service management repository through the data processing apparatus 1, the notification obtaining unit 101 is not used, and the first obtaining unit 102 performs pull on demand.
The business management warehouse is a code database used for data sharing in a business management server; the code database contains service code data uploaded by at least one terminal associated with the applet; the service code data comprises the target source character string uploaded by a target terminal in the at least one terminal and increment change attribute information corresponding to the target source character string; the service management server is used for performing distributed storage on the target source character string uploaded by the target terminal and performing version management on the version information of the target source character string.
A character string embedding module 20, configured to embed the target source character string into the historical source character string according to the incremental change attribute information, and generate a test data packet corresponding to the applet according to the historical source character string embedded with the target source character string;
wherein, the character string embedding module 20 comprises: a character embedding unit 201, a compiling processing unit 202;
a character embedding unit 201, configured to embed the target source character string into the historical source character string according to the incremental change attribute information, and generate a to-be-compiled data packet corresponding to the applet according to the historical source character string in which the target source character string is embedded;
wherein the character embedding unit 201 includes: an anomaly detection subunit 2011, a position determination subunit 2012 and a character embedding subunit 2013, and optionally, the character embedding unit 201 further includes a first log generation subunit 2014, a first anomaly reminding subunit 2015 and a first reminding pushing subunit 2016;
an anomaly detection submenu 2011, configured to perform anomaly detection on the target source character string;
a position determining subunit 2012, configured to determine, when it is detected that the target source string does not satisfy the abnormal pull condition, position information of the target source string in the history source string according to the incremental change attribute information;
a character embedding subunit 2013, configured to embed the target source character string into the historical source character string based on the location information, and use the historical source character string embedded with the target source character string as a to-be-compiled data packet corresponding to the applet.
Optionally, the first log generating subunit 2014 is configured to generate, when it is detected that the target source string meets the abnormal pulling condition, abnormal pulling log information corresponding to the target source string;
a first exception prompting subunit 2015, configured to generate first exception prompting information corresponding to the applet according to at least one exception pulling factor in the exception pulling log information;
a first reminding pushing subunit 2016 configured to push the first abnormal reminding information to a group associated with the applet through a second service server associated with the applet; the group is a group in a second application different from the first application; the group includes at least one development user participating in developing the applet.
Optionally, the character embedding unit 201 further includes a first log generation subunit 2014, a first exception prompting subunit 2015, and a specific implementation manner of the first prompt pushing subunit 2016 may refer to the description of the pulled target source character string in the embodiment corresponding to fig. 2, and details will not be further described here.
The compiling processing unit 202 is configured to compile the data packet to be facilitated according to the dependent data file corresponding to the applet, and obtain a test data packet corresponding to the applet when a compiling state of the data packet to be compiled is a success state.
Wherein the compiling processing unit 202 includes: a dependency acquisition subunit 2021, a compiling subunit 2022, a sub-packaging subunit 2023, a test packet generation subunit 2024; optionally, the compiling processing unit 202 may further include: a second log generating sub-unit 2025, an installation error sub-unit 2026, a character irrelevant sub-unit 2027, a character relevant sub-unit 2028; a compiling error sub-unit 2029, a second abnormity reminding sub-unit 2030 and a second reminding pushing sub-unit 2031;
the dependency obtaining sub-list 2021 is configured to obtain a dependency data packet associated with the to-be-compiled data packet, and obtain a dependency data file for compiling the to-be-compiled data packet when the installation state of the dependency data packet is a successful state;
the compiling subunit 2022 is configured to perform code compiling on the data packet to be compiled according to the third-party class library provided in the dependent data file, and obtain a sub-packaging mechanism corresponding to the applet;
a packetizing subunit 2023, configured to divide the data packet to be compiled into N packets based on the packetizing mechanism; n is a positive integer; the N sub-packages comprise a first data package associated with a main page of the applet and a second data package associated with a sub-page of the applet;
the test packet generating subunit 2024 is configured to, when the compiling state of the data packet to be compiled is a success state, obtain a test data packet corresponding to the applet based on the first data packet and the second data packet.
Optionally, the second log generating subunit 2025 is configured to generate installation exception log information when the installation status of the dependent packet is a failure status;
an installation error subunit 2026, configured to generate installation error prompt information based on the installation abnormality factor associated with the installation abnormality log information;
the character irrelevant subunit 2027 is configured to, if the installation exception factor belongs to an environmental exception factor irrelevant to the target source character string, use the installation error prompt information as a first class exception alert information corresponding to the applet;
a character correlation subunit 2028, configured to, if the installation exception factor belongs to a code exception factor related to the target source character string, obtain a code submission record corresponding to the target source character string and developer information associated with the code submission record, supplement the code submission record and the developer information to the installation error prompt information, and use the supplemented installation error prompt information as a second type of exception prompt information corresponding to the applet.
Optionally, the compiling error subunit 2029 is configured to generate compiling error log information corresponding to the to-be-compiled data packet when the compiling state of the to-be-compiled data packet is a failure state, and perform error analysis on the compiling error log information to obtain a compiling error factor corresponding to the to-be-compiled data packet; the compiling error factor comprises a static grammar error corresponding to a target source character string in the data packet to be compiled;
the second exception prompting subunit 2030, configured to generate second exception prompting information corresponding to the applet based on the static syntax error;
a second reminding pushing subunit 2031, configured to send the second abnormal reminding information to the group associated with the applet through the second service server associated with the applet; the group is a group in a second application different from the first application.
Among them, the dependency acquisition subunit 2021, the compiling subunit 2022, the sub-packaging subunit 2023, the test packet generating subunit 2024, the second log generating subunit 2025, the mounting error subunit 2026, the character irrelevant subunit 2027, the character relevant subunit 2028; for specific implementation manners of the compiling error subunit 2029, the second exception prompting subunit 2030, and the second prompting pushing subunit 2031, reference may be made to the description of generating the test data packet in the embodiment corresponding to fig. 2, which will not be further described here.
For a specific implementation manner of the character embedding unit 201 and the compiling processing unit 202, reference may be made to the description of step S102 in the embodiment corresponding to fig. 2, and details will not be further described here.
A data packet sending module 30, configured to send the test data packet to a first service server corresponding to the first application, so that the first service server distributes the test data packet to a target test user.
The data packet sending module 30 includes: an interface acquisition unit 301, a packet upload unit 302;
an interface obtaining unit 301, configured to obtain, on a persistent integration platform corresponding to the applet, a target interface provided by the persistent integration platform; the target interface includes an IDE interface associated with the applet;
a data packet uploading unit 302, configured to invoke the IDE interface to upload the test data packet simulation to the first service server corresponding to the first application.
For specific implementation manners of the interface obtaining unit 301 and the data packet uploading unit 302, reference may be made to the description of step S103 in the embodiment corresponding to fig. 2, and details will not be further described here.
For specific implementation manners of the character string obtaining module 10, the character string embedding module 20, and the data packet sending module 30, reference may be made to the description of steps S101 to S103 in the embodiment corresponding to fig. 2, and details will not be further described here.
A response obtaining module 40, configured to determine that the uploading of the test data packet is completed if response text information returned by the first service server for the test data packet is obtained within a response duration;
an exception uploading module 50, configured to generate exception uploading log information if response text information returned by the first service server is not obtained within the response duration, generate third exception prompting information corresponding to the applet according to an exception uploading factor in the exception uploading log information, and send the third exception prompting information to a group associated with the applet through a second service server associated with the applet; the group is a group in a second application different from the first application.
For specific implementation manners of the response obtaining module 40 and the exception uploading module 50, reference may be made to the description of step S206 to step S207 in the embodiment corresponding to fig. 6, and details will not be further described here.
Therefore, according to the application, a target source character string (for example, a newly uploaded source code) acquired from a business management warehouse can be embedded into a historical source character string through the introduced continuous integration server, the historical source character string can be an existing source code (for example, a last uploaded source code) in the continuous integration server, the continuous integration server can provide continuous integration service to automatically generate the test data packet, so that human-computer interaction can be avoided, and the generation efficiency of the test data packet can be improved without a button. In addition, by automatically generating the test data packet in the persistent integration server, data interaction between the target terminal (i.e., the development terminal) and the first service server (e.g., the WeChat server) can be avoided, so that decoupling cooperation can be fully exerted in the development process of the applet, and waste of development resources is avoided.
Further, please refer to fig. 10, which is a schematic diagram of a computer device according to an embodiment of the present application. As shown in fig. 10, the computer device 1000 may be the persistent integration server 2000 in the embodiment corresponding to fig. 1, and the computer device 1000 may include: at least one processor 1001, such as a CPU, at least one network interface 1004, a user interface 1003, memory 1005, at least one communication bus 1002. Wherein a communication bus 1002 is used to enable connective communication between these components. The user interface 1003 may include a Display (Display) and a Keyboard (Keyboard), and the network interface 1004 may optionally include a standard wired interface and a wireless interface (e.g., WI-FI interface). The memory 1005 may be a high-speed RAM memory or a non-volatile memory (non-volatile memory), such as at least one disk memory. The memory 1005 may optionally also be at least one storage device located remotely from the aforementioned processor 1001. As shown in fig. 10, a memory 1005, which is a kind of computer storage medium, may include therein an operating system, a network communication module, a user interface module, and a device control application program.
In the computer device 1000 shown in fig. 10, the network interface 1004 is mainly used for network communication with the service server; the user interface 1003 is an interface for providing a user with input; and the processor 1001 may be used to invoke a device control application stored in the memory 1005 to implement:
acquiring a target source character string associated with a business management warehouse and increment change attribute information corresponding to the target source character string; the target source character string is determined by the target terminal after being changed aiming at the historical source character string corresponding to the applet associated with the first application;
embedding the target source character string into the historical source character string according to the increment change attribute information, and generating a test data packet corresponding to the applet according to the historical source character string embedded with the target source character string;
and sending the test data packet to a first service server corresponding to the first application so that the first service server distributes the test data packet to a target test user.
It should be understood that the computer device 1000 described in this embodiment of the present application may perform the description of the data processing method in the embodiment corresponding to fig. 2 and fig. 6, and may also perform the description of the data processing apparatus 1 in the embodiment corresponding to fig. 9, which is not described herein again. In addition, the beneficial effects of the same method are not described in detail.
Further, here, it is to be noted that: an embodiment of the present application further provides a computer-readable storage medium, where the computer program executed by the aforementioned data processing apparatus 1 is stored in the computer-readable storage medium, and the computer program includes program instructions, and when the processor executes the program instructions, the description of the data processing method in the embodiment corresponding to fig. 2 or fig. 6 can be executed, so that details are not repeated here. In addition, the beneficial effects of the same method are not described in detail. For technical details not disclosed in embodiments of the computer-readable storage medium referred to in the present application, reference is made to the description of embodiments of the method of the present application.
It will be understood by those skilled in the art that all or part of the processes of the methods of the embodiments described above can be implemented by a computer program, which can be stored in a computer-readable storage medium, and when executed, can include the processes of the embodiments of the methods described above. The storage medium may be a magnetic disk, an optical disk, a Read-Only Memory (ROM), a Random Access Memory (RAM), or the like.
The above disclosure is only for the purpose of illustrating the preferred embodiments of the present application and is not to be construed as limiting the scope of the present application, so that the present application is not limited thereto, and all equivalent variations and modifications can be made to the present application.
Claims (15)
1. A data processing method is applied to a continuous integration server and is characterized by comprising the following steps:
acquiring a target source character string associated with a business management warehouse and increment change attribute information corresponding to the target source character string; the target source character string is determined by the target terminal after being changed aiming at the historical source character string corresponding to the applet associated with the first application;
embedding the target source character string into the historical source character string according to the increment change attribute information, and generating a test data packet corresponding to the applet according to the historical source character string embedded with the target source character string;
and sending the test data packet to a first service server corresponding to the first application so that the first service server distributes the test data packet to a target test user.
2. The method of claim 1, wherein the obtaining of the target source string associated with the business management repository and the incremental change attribute information corresponding to the target source string comprises:
acquiring service submission notification information which is sent by a service management server corresponding to the service management warehouse aiming at the target source character string; the service submission notification information contains a hash value of version information corresponding to the target source character string;
and pulling the target source character string and the increment change attribute information corresponding to the target character string from the service management warehouse according to the hash value.
3. The method of claim 1, wherein the obtaining of the target source string associated with the business management repository and the incremental change attribute information corresponding to the target source string comprises:
when the current time length reaches the timing pulling time length, a source code pulling instruction aiming at the target source character string is obtained;
and pulling the target source character string and the increment change attribute information corresponding to the target character string from the service management warehouse according to the source code pulling instruction.
4. The method according to any one of claims 1 to 3, wherein the business management repository is a code database for data sharing in the business management server; the code database contains service code data uploaded by at least one terminal associated with the applet; the service code data comprises the target source character string uploaded by a target terminal in the at least one terminal and increment change attribute information corresponding to the target source character string; the service management server is used for performing distributed storage on the target source character string uploaded by the target terminal and performing version management on the version information of the target source character string.
5. The method according to claim 1, wherein the embedding the target source string into the historical source string according to the incremental change attribute information, and generating the test data packet corresponding to the applet according to the historical source string in which the target source string is embedded, comprises:
embedding the target source character string into the historical source character string according to the increment change attribute information, and generating a data packet to be compiled corresponding to the applet according to the historical source character string embedded with the target source character string;
and compiling the data packet to be compiled according to the dependent data file corresponding to the small program, and obtaining a test data packet corresponding to the small program when the compiling state of the data packet to be compiled is a successful state.
6. The method according to claim 5, wherein the embedding the target source string into the historical source string according to the incremental change attribute information, and generating the to-be-compiled data packet corresponding to the applet according to the historical source string in which the target source string is embedded comprises:
carrying out anomaly detection on the target source character string;
when detecting that the target source character string does not meet the abnormal pulling condition, determining the position information of the target source character string in the historical source character string according to the increment change attribute information;
and embedding the target source character string into the historical source character string based on the position information, and taking the historical source character string embedded with the target source character string as a data packet to be compiled corresponding to the small program.
7. The method of claim 6, further comprising:
when the target source character string is detected to meet the abnormal pulling condition, generating abnormal pulling log information corresponding to the target source character string;
generating first abnormal reminding information corresponding to the small program according to at least one abnormal pulling factor in the abnormal pulling log information;
pushing the first abnormal reminding information to a group associated with the small program through a second business server associated with the small program; the group is a group in a second application different from the first application; the group includes at least one development user participating in developing the applet.
8. The method according to claim 5, wherein the compiling the to-be-compiled data packet according to the dependent data file corresponding to the applet, and obtaining the test data packet corresponding to the applet when the compiling state of the to-be-compiled data packet is a success state includes:
acquiring a dependent data packet associated with the data packet to be compiled, and acquiring a dependent data file for compiling the data packet to be compiled when the installation state of the dependent data packet is a successful state;
according to a third-party class library provided in the dependency data file, code compiling is carried out on the data packet to be compiled, and a sub-packaging mechanism corresponding to the small program is obtained;
dividing the data packet to be compiled into N sub packets based on the sub packet mechanism; n is a positive integer; the N sub-packages comprise a first data package associated with a main page of the applet and a second data package associated with a sub-page of the applet;
and when the compiling state of the data packet to be compiled is a success state, obtaining a test data packet corresponding to the small program based on the first data packet and the second data packet.
9. The method of claim 8, further comprising:
when the installation state of the dependent data packet is a failure state, generating installation abnormal log information;
generating installation error prompt information based on the installation abnormal factors associated with the installation abnormal log information;
if the installation abnormal factor belongs to an environmental abnormal factor irrelevant to the target source character string, taking the installation error prompt message as a first class of abnormal prompt message corresponding to the small program;
and if the abnormal installation factor belongs to the abnormal code factor related to the target source character string, acquiring a code submission record corresponding to the target source character string and developer information related to the code submission record, supplementing the code submission record and the developer information to the error installation prompt information, and taking the supplemented error installation prompt information as second type abnormal prompt information corresponding to the small program.
10. The method of claim 8, further comprising:
when the compiling state of the data packet to be compiled is a failure state, generating compiling error log information corresponding to the data packet to be compiled, and carrying out error analysis on the compiling error log information to obtain a compiling error factor corresponding to the data packet to be compiled; the compiling error factor comprises a static grammar error corresponding to a target source character string in the data packet to be compiled;
generating second abnormal reminding information corresponding to the small program based on the static grammar error;
sending the second abnormal reminding information to a group associated with the small program through a second business server associated with the small program; the group is a group in a second application different from the first application.
11. The method of claim 1, wherein sending the test packet to a first service server corresponding to the first application comprises:
acquiring a target interface provided by a continuous integration platform on the continuous integration platform corresponding to the applet; the target interface includes an IDE interface associated with the applet;
and calling the IDE interface to upload the test data packet simulation to a first service server corresponding to the first application.
12. The method of claim 1, further comprising:
if response text information returned by the first service server for the test data packet is acquired within a response duration, determining that the test data packet is uploaded;
if the response text information returned by the first service server is not acquired within the response duration, generating abnormal uploading log information, generating third abnormal reminding information corresponding to the small program according to abnormal uploading factors in the abnormal uploading log information, and sending the third abnormal reminding information to a group associated with the small program through a second service server associated with the small program; the group is a group in a second application different from the first application.
13. A data processing apparatus applied to a persistent integration server, comprising:
the system comprises a character string acquisition module, a service management warehouse and a service management module, wherein the character string acquisition module is used for acquiring a target source character string associated with the service management warehouse and increment change attribute information corresponding to the target source character string; the target source character string is determined by the target terminal after being changed aiming at the historical source character string corresponding to the applet associated with the first application;
the character string embedding module is used for embedding the target source character string into the historical source character string according to the increment change attribute information and generating a test data packet corresponding to the applet according to the historical source character string embedded with the target source character string;
and the data packet sending module is used for sending the test data packet to a first service server corresponding to the first application so that the first service server can distribute the test data packet to a target test user.
14. A computer device, comprising: a processor, a memory, and a network interface;
the processor is coupled to a memory for providing data communication functionality, a network interface for storing program code, and the processor is configured to invoke the program code to perform the method of any of claims 1-12.
15. A computer-readable storage medium, characterized in that the computer-readable storage medium stores a computer program comprising program instructions which, when executed by a processor, perform the method according to any one of claims 1-12.
Priority Applications (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201911038478.2A CN112732265B (en) | 2019-10-29 | 2019-10-29 | Data processing method and related device |
Applications Claiming Priority (1)
| Application Number | Priority Date | Filing Date | Title |
|---|---|---|---|
| CN201911038478.2A CN112732265B (en) | 2019-10-29 | 2019-10-29 | Data processing method and related device |
Publications (2)
| Publication Number | Publication Date |
|---|---|
| CN112732265A true CN112732265A (en) | 2021-04-30 |
| CN112732265B CN112732265B (en) | 2024-03-19 |
Family
ID=75588953
Family Applications (1)
| Application Number | Title | Priority Date | Filing Date |
|---|---|---|---|
| CN201911038478.2A Active CN112732265B (en) | 2019-10-29 | 2019-10-29 | Data processing method and related device |
Country Status (1)
| Country | Link |
|---|---|
| CN (1) | CN112732265B (en) |
Cited By (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113591440A (en) * | 2021-07-29 | 2021-11-02 | 百度在线网络技术（北京）有限公司 | Text processing method and device and electronic equipment |
| CN114385759A (en) * | 2022-01-13 | 2022-04-22 | 平安科技（深圳）有限公司 | Configuration file synchronization method and device, computer equipment and storage medium |
| CN114385759B (en) * | 2022-01-13 | 2024-04-16 | 平安科技（深圳）有限公司 | Configuration file synchronization method and device, computer equipment and storage medium |
Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| EP1180665A2 (en) * | 2000-08-11 | 2002-02-20 | Takata-Petri AG | Steering angle sensor for motor vehicles |
| US20050259720A1 (en) * | 1997-12-12 | 2005-11-24 | Freescale Semiconductor, Inc. | Ultra wide bandwidth spread-spectrum communications system |
| CN105404519A (en) * | 2015-12-07 | 2016-03-16 | 青岛海信电器股份有限公司 | Version control method, code testing method and system |
| CN105653287A (en) * | 2015-12-31 | 2016-06-08 | 北京元心科技有限公司 | Automatic program version issuing method and device |
| CN109726104A (en) * | 2018-05-15 | 2019-05-07 | 平安普惠企业管理有限公司 | Test bag generation method, test terminal and the storage medium of mobile terminal |
-
2019
- 2019-10-29 CN CN201911038478.2A patent/CN112732265B/en active Active
Patent Citations (5)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| US20050259720A1 (en) * | 1997-12-12 | 2005-11-24 | Freescale Semiconductor, Inc. | Ultra wide bandwidth spread-spectrum communications system |
| EP1180665A2 (en) * | 2000-08-11 | 2002-02-20 | Takata-Petri AG | Steering angle sensor for motor vehicles |
| CN105404519A (en) * | 2015-12-07 | 2016-03-16 | 青岛海信电器股份有限公司 | Version control method, code testing method and system |
| CN105653287A (en) * | 2015-12-31 | 2016-06-08 | 北京元心科技有限公司 | Automatic program version issuing method and device |
| CN109726104A (en) * | 2018-05-15 | 2019-05-07 | 平安普惠企业管理有限公司 | Test bag generation method, test terminal and the storage medium of mobile terminal |
Cited By (3)
| Publication number | Priority date | Publication date | Assignee | Title |
|---|---|---|---|---|
| CN113591440A (en) * | 2021-07-29 | 2021-11-02 | 百度在线网络技术（北京）有限公司 | Text processing method and device and electronic equipment |
| CN114385759A (en) * | 2022-01-13 | 2022-04-22 | 平安科技（深圳）有限公司 | Configuration file synchronization method and device, computer equipment and storage medium |
| CN114385759B (en) * | 2022-01-13 | 2024-04-16 | 平安科技（深圳）有限公司 | Configuration file synchronization method and device, computer equipment and storage medium |
Also Published As
| Publication number | Publication date |
|---|---|
| CN112732265B (en) | 2024-03-19 |
Similar Documents
| Publication | Publication Date | Title |
|---|---|---|
| CN110221872B (en) | Page jump method and device, electronic equipment and storage medium | |
| CN108196915B (en) | Code processing method and device based on application container engine and storage medium | |
| CN106325847B (en) | Method and device for acquiring application program function based on iOS platform | |
| CN111580926A (en) | Model publishing method, model deploying method, model publishing device, model deploying device, model publishing equipment and storage medium | |
| CN109800005B (en) | Client hot update method and device | |
| CN110297776B (en) | Detection report generation and reception methods, devices, equipment and storage medium | |
| KR20160061306A (en) | Method and apparatus for firmware virtualization | |
| CN111367531B (en) | Code processing method and device | |
| CN110716786B (en) | Page display method, system and storage medium | |
| CN110113391B (en) | Client online method and device and client operation method and device | |
| CN106354832B (en) | Data publishing method, device and system | |
| CN113138768B (en) | Application package generation method and device, electronic equipment and readable storage medium | |
| CN112732265B (en) | Data processing method and related device | |
| CN113254217A (en) | Service message processing method and device and electronic equipment | |
| CN113360377A (en) | Test method and device | |
| CN111147585B (en) | Equipment upgrading method, device, storage medium and system | |
| CN114115884A (en) | Management method and related device for programming service | |
| CN109375946B (en) | Method and system for managing component package of node package manager | |
| CN109086059B (en) | Code loading updating method, device and server | |
| CN114610446B (en) | Method, device and system for automatically injecting probe | |
| CN113590179B (en) | Plug-in detection method and device, electronic equipment and storage medium | |
| US20180373512A1 (en) | Method and device for simulating synchronous blocking in asynchronous environment, storage medium, server and terminal | |
| CN112817782B (en) | Data acquisition reporting method and device, electronic equipment and storage medium | |
| CN111427770B (en) | Resource testing method and related equipment | |
| CN111158654A (en) | Algorithm calling method, device, server and storage medium |
Legal Events
| Date | Code | Title | Description |
|---|---|---|---|
| PB01 | Publication | ||
| PB01 | Publication | ||
| SE01 | Entry into force of request for substantive examination | ||
| SE01 | Entry into force of request for substantive examination | ||
| REG | Reference to a national code |
Ref country code: HK Ref legal event code: DE Ref document number: 40042049 Country of ref document: HK |
|
| GR01 | Patent grant | ||
| GR01 | Patent grant |