CN116048525A - Management method, device and equipment of command line tool - Google Patents

Abstract

The embodiment of the specification discloses a command line tool management method, device and equipment. By receiving the command line code uploaded by the publisher; compiling the command line code to generate a temporary resource package; acquiring configuration information of the code to be issued, and constructing a target resource package according to the configuration information and the temporary resource package; and issuing the target resource package, so that centralized unified management of different command line tools is realized, and the issuing party can generate and issue the target resource package meeting the standard only by providing corresponding codes and configuration information for the platform.

Description

Management method, device and equipment of command line tool

Technical Field

The present disclosure relates to the field of internet technologies, and in particular, to a command line tool-based management method, device, and equipment.

Background

A command line tool is a tool that can be used in the context of a user terminal and that can be implemented in different programming languages. Within some institutions, there are often many different developers to develop and generate different command line tools. For a plurality of different developers of command line tools, functions of some tool classes are often repeatedly implemented among them, and the command line tools respectively developed by the tools also often lack a unified architecture, a standard and a unified debugging mode, so that the overall management is inconvenient.

Based on this, there is a need for an efficient command line tool management scheme.

Disclosure of Invention

The embodiment of the specification provides a command line tool management method, device, equipment and storage medium, which are used for solving the following technical problems: there is a need for an efficient command line tool management scheme.

To solve the above technical problems, one or more embodiments of the present specification are implemented as follows:

in a first aspect, embodiments of the present disclosure provide a method for managing a command line tool, the method comprising: receiving a command line code uploaded by an issuer; compiling the command line code to generate a temporary resource package; acquiring configuration information of the code to be issued, and constructing a target resource package according to the configuration information and the temporary resource package; and publishing the target resource package.

In a second aspect, embodiments of the present disclosure provide a command line tool management apparatus, the apparatus comprising: the receiving module is used for receiving the command line code uploaded by the publisher; the compiling module is used for compiling the command line codes to generate temporary resource packages; the construction module is used for acquiring configuration information of the code to be issued and constructing a target resource package according to the configuration information and the temporary resource package; and the release module releases the target resource package.

In a third aspect, one or more embodiments of the present description provide an electronic device comprising:

at least one processor; the method comprises the steps of,

a memory communicatively coupled to the at least one processor; wherein, the liquid crystal display device comprises a liquid crystal display device,

the memory stores instructions executable by the at least one processor to enable the at least one processor to perform the method of the first aspect.

In a fourth aspect, embodiments of the present description provide a non-volatile computer storage medium having stored thereon computer-executable instructions that, when read by a computer in the storage medium, cause one or more processors to perform the method as described in the first aspect.

The above-mentioned at least one technical solution adopted by one or more embodiments of the present disclosure can achieve the following beneficial effects: by receiving the command line code uploaded by the publisher; compiling the command line code to generate a temporary resource package; acquiring configuration information of the code to be issued, and constructing a target resource package according to the configuration information and the temporary resource package; and issuing the target resource package, thereby realizing centralized unified management of different command line tools, and the issuer can generate and issue the target resource package meeting the standard only by providing corresponding codes and configuration information for the platform, so that unified management of different command line tools is realized, and the working efficiency and experience of the issuer are improved.

Drawings

In order to more clearly illustrate the embodiments of the present description or the technical solutions in the prior art, the drawings that are required in the embodiments or the description of the prior art will be briefly described below, it being obvious that the drawings in the following description are only some of the embodiments described in the present description, and that other drawings may be obtained according to these drawings without inventive effort for a person skilled in the art.

FIG. 1 is a flow chart of a method for managing command line tools according to an embodiment of the present disclosure;

fig. 2 is a schematic structural diagram of a management platform according to an embodiment of the present disclosure;

FIG. 3 is a schematic timing diagram of resource publishing performed by a software publisher in a management platform according to an embodiment of the present disclosure;

FIG. 4 is a timing diagram illustrating interactions with a management platform when a software user executes a command line tool according to an embodiment of the present disclosure;

FIG. 5 is a schematic structural diagram of a command line tool management device according to an embodiment of the present disclosure;

fig. 6 is a schematic structural diagram of an electronic device according to an embodiment of the present disclosure.

Detailed Description

The embodiment of the specification provides a command line tool management method, device, equipment and storage medium.

In order to make the technical solutions in the present specification better understood by those skilled in the art, the technical solutions in the embodiments of the present specification will be clearly and completely described below with reference to the drawings in the embodiments of the present specification, and it is obvious that the described embodiments are only some embodiments of the present application, but not all embodiments. All other embodiments, which can be made by one of ordinary skill in the art based on the embodiments herein without making any inventive effort, shall fall within the scope of the present application.

The command line tool is free of graphical elements, based primarily on text, in contrast to the application of a graphical user interface. Command line tools are popular among developers because of their more efficient workflow and compact interfaces. The present command line tools are many, but basically, the present command line tools are developed and issued respectively in the process of issuing and using, and lack of a unified framework and standard, which actually brings inconvenience to the management (including issuing, using and testing, etc.) of the command line tools, and therefore, the embodiments of the present specification provide a management scheme of the command line tools.

As shown in fig. 1, fig. 1 is a flow chart of a command line tool management method according to an embodiment of the present disclosure, including:

s101: and receiving the command line code uploaded by the publisher.

As shown in fig. 2, the management method of the embodiment of the present disclosure is applied to a centralized management platform, and fig. 2 is a schematic structural diagram of a management platform provided by the embodiment of the present disclosure. The centralized management platform in the architecture provides a software development kit (Software Development Kit, SDK) for the developer of the command line tool (usually the developer is the code publisher), and each developer can obtain the SDK from the platform and write the code based on the SDK. In other words, the management platform can interface with a plurality of different developers simultaneously and provide a corresponding development environment.

S103, compiling the command line code to generate a temporary resource package.

After the command line code written based on the SDK, each developer can upload the code to the management platform in the development environment, and the management platform compiles the code, so as to generate a usable temporary resource package (also referred to as a temporary version). The temporary version may also be issued temporarily (i.e., uploaded to a public path for each user to download) while the relevant information of the temporary resource package is returned to the issuer. The related information may include, for example, path, build time, etc. of the temporary resource package

S105, acquiring configuration information of the code to be issued, and constructing a target resource package according to the configuration information and the temporary resource package.

After the software publisher obtains the foregoing relevant information, the temporary resource package may be subjected to, for example, local debugging and testing. After the completion confirmation of the temporary resource package test is available, the publisher can perform corresponding configuration on the temporary resource package, wherein the configuration comprises functional configuration, release strategy configuration, integration mode configuration, gray scale configuration and the like.

The function configuration is used for configuring functions of a plurality of tool packages contained in the temporary resource package. For example, if the command line tool corresponding to the temporary resource package may include functions A, B and C, the function configuration may be used to configure the usage rights, the usage environment, etc. of a specific function.

The delivery policy configuration may be used to strategically configure the functionality of multiple toolkits contained in the temporary resource package to the user. For example, if the command line tool corresponding to the temporary resource package may include functions A, B and C, the function configuration may be used to configure the usage rights, the usage environment, etc. of a specific function. For example, functions A, B and C are both the lowest authority by default (i.e., all users can use) or function a is configured with a higher authority based on the configuration so that only users with the highest authority can use function a in the command line tool.

The integration scheme configuration may be such that the user specifically includes which toolkits to include in the final target resource package generated, or how to integrate for the specific toolkits. For example, the temporary resource package may include a plurality of function applications X, Y and Z that may be independent, and then the configuration of the integration manner may be used to determine which function applications are specifically included in the finally generated target resource package, and how the function applications are integrated.

The greyscale configuration may be used to determine how to update the impression (i.e. whether greyscale impressions are made) towards the user after release. For example, it may be greyscale delivery (i.e., updates on part of the users and transitions stepwise to full user updates), or it may be generic (i.e., updates on full users at the same time).

The configuration information of the publisher for the temporary resource package may be generated in a standard configuration interface provided by the management platform. For example, the management platform provides a configuration interface that includes a plurality of selectable controls to provide information input or option selections for the publisher. After the management platform obtains the information, the configuration information can be analyzed and calculated to generate a corresponding calculation result, and the calculation result is fixed to generate a configuration mirror image. And then constructing an image file containing configuration information based on the configuration image and the temporary resource package, namely generating and obtaining the target resource package.

In this way, for different software publishers, the management platform can perform corresponding configuration on the temporary resource package adopted by the management platform, and the management platform can perform rule solidification based on configuration information provided by the software publishers, so that unified publishing and management can be performed based on rules solidified by the configuration information.

S107, publishing the target resource package.

And after the publisher confirms that the code function of the mirror image file has no problem, the publisher confirms the publication again, so that the target resource package is published to the outside through the platform. Fig. 3 is a schematic timing diagram of resource publishing performed by a software publisher in a management platform according to an embodiment of the present disclosure.

After the official version (i.e., the target resource package) is released, the software user can download the target resource package from the software source, complete the installation locally and obtain the command line tool for use. Because the target resource package actually contains the configuration information, in the use process, the command line tool performs a local pre-checking operation based on the configuration information to obtain the pre-checking information (including version number, authority limit information, local configuration information and the like) of the command line tool. And further, based on the pre-detection information and the management platform, interaction is performed so as to verify the configuration information to generate a verification result, and thus operations such as upgrading, disabling, burying points and the like are performed locally based on the verification result.

FIG. 4 is a timing diagram illustrating interactions with a management platform when a software user executes a command line tool according to an embodiment of the present disclosure. In the schematic diagram, the installation of the software is actually a pre-completed process, and any command line tool can perform pre-inspection based on the mode and complete verification based on interaction between the configuration information and the management platform during execution, so that unified management is realized.

By receiving the command line code uploaded by the publisher; compiling the command line code to generate a temporary resource package; acquiring configuration information of the code to be issued, and constructing a target resource package according to the configuration information and the temporary resource package; and issuing the target resource package, thereby realizing centralized unified management of different command line tools, and the issuer can generate and issue the target resource package meeting the standard only by providing corresponding codes and configuration information for the platform, so that unified management of different command line tools is realized, and the working efficiency and experience of the issuer are improved.

In one embodiment, when the publisher obtains the configuration information of the code to be published, the publisher constructs a software resource package according to the configuration information and the temporary resource package. The management platform can determine a plurality of application packages contained in the temporary resource package through compiling, and display the application packages to a publisher in the form of control options for selection, so that the publisher can configure and upload the integration mode of the application packages in the configuration information, and the management platform can acquire the integration mode of the application packages contained in the configuration information of the code to be published; and forming one or more target resource packages according to the integration mode.

For example, the temporary resource package includes an application package 1, an application package 2, and an application package 3, and the publisher may choose to integrate all application packages into one target resource package, or integrate application package 2 and application package 3 into one target resource package and integrate application package 1 into another target resource package.

Since in practical applications the locally executed command line tool by the software user is likely not up-to-date, such non-up-to-date may be manifested as that the configuration information of the locally executed command line tool by the software user does not conform to the configuration information contained in the target resource package, e.g. it may manifest as inconsistent configuration of rights, unsatisfactory version numbers, and that the period of the command line tool has expired, etc.

Based on this, it is convenient for the issuer to perform unified management on the command line tool, when the software user (i.e. the user) executes the command line tool, after executing the pre-inspection to obtain the pre-inspection information, policy access may be initiated to the management platform, where the policy access request is generated when the user runs the command line tool corresponding to the target resource package, and the policy access request generally also carries information such as a version number, an installation time, a local right and so on.

The management platform can execute configuration verification according to the policy access request and the configuration information to generate a verification result; and returning the verification result to the user so that the user can execute the command line tool according to the verification result. Configuration checks herein may include, for example, version checks, rights checks, lifecycle checks, and the like.

For example, the version verification may be performed by the management platform obtaining a version number of a command line tool included in the access request; and comparing the version number of the command line tool with the version number contained in the configuration information to generate a version verification result. In general, the version number contained in the configuration information is a minimum version number available, and if the version number of the command line tool is smaller than the version number contained in the configuration information, it may be considered that the command line tool executed by the software user will not be used or will need to be forcefully updated.

In this way, the software publisher can conveniently and uniformly manage the command line tools published by the software publisher for all software users. For example, if a software publisher needs to drop the command line tool, it may configure a larger version number in the management platform such that no version number of any command line tool can exceed the larger version number, thereby achieving a unified drop-off for the command line tool.

For another example, the software publisher may determine a lifecycle (e.g., one month) of any one version in the configuration information, and when the runtime of the version number exceeds the lifecycle, the command line tool with the version number is not available.

For another example, the verification of rights may be based on a user identification. That is, the software publisher may pre-configure a white list in the management platform, where the white list includes the user identifier and the function authority, the user identifier in the white list is a user having at least a part of the function use authority, and the user identifier not in the white list does not have the use authority.

In the implementation mode, the command line tool can acquire the user mark of the local user during pre-detection and carry uploading in the access request, so that the management platform can acquire the user mark contained in the access request; and comparing whether the user identifier is matched with the user identifier contained in the configuration information, and generating a user permission verification result.

For example, a software developer may pre-configure a white list rule of "person of department 1 is open, person of job number 011 is open, and specific functions a, b, c, and d are open," so that the management platform may fix the rule in the form of a white list, and thus the functions a, b, c, and d in the software command line tool cannot be used by the user in one department 2 or the user of department 1 of job number 012.

In one embodiment, if a command line tool has a large number of user groups, the management platform may also decide how to update based on the configuration of the software publisher when the verification results characterize verification passing. Specifically, a management platform acquires a gray level strategy of a target resource package contained in the configuration information, and generates a strategy result corresponding to the user according to the gray level strategy; pushing the policy results to the user for the user to update the command line tool.

For example, the software publisher may perform a gray update based on the job number of the command line tool user, generate a policy result characterizing the update if the remainder of the job number for 5 is 1, and push the policy result to the software user (user) in order for the user to update the command line tool. And if the remainder is other numbers, generating a strategy result with the characteristics not updated, and pushing the strategy result to the user. By the method, gray level updating can be realized when the command line tool has more users, and the command line tool is more stable.

In one embodiment, if the software publisher needs to perform the embedded point analysis on the command line tool, a policy result for characterizing the code instrumentation may be pushed to the user, so that the user performs code instrumentation on the command line tool based on the policy result, and generates the command line tool including the instrumented code.

For example, the software publisher may pre-configure the relevant information to the management platform, and the command line tool may pull the relevant code according to the configuration information and perform corresponding analysis and code instrumentation on the local command line tool when the command line tool is started, so as to generate a new command line tool including the instrumentation code. And, the location where instrumentation is specifically performed, the form of the instrumentation code, and the like may be indicated in the configuration information.

In the embodiment of the present specification, instrumentation refers to inserting other codes (or may also be referred to as instrumentation codes) into the code of the command line tool on the basis of ensuring the logic and functional integrity of the code of the original command line tool, collecting information (such as a method itself, a method parameter value, a return value, etc.) generated when the command line tool is executed by the other codes, and collecting dynamic context information when the command line tool is running by inserting the other codes at specific positions.

For example, the original pseudocode form of the command line tool may be: { call is made to xxx address through xx port, apply for value of data x }. I.e. apply for data calls to the remote device.

And the pseudo code form of the new code generated after code instrumentation may be:

{

recording the current system time t1;

calling the xxx address through the xx port, and applying for the value of the data x;

the current system time t2 is recorded.

}

The "recording the current system time t1" and the "recording the current system time t2" are the other codes inserted. These inserted other codes obviously do not affect the execution of the original command line tool, call to xxx address through xx port, apply for the value of data x.

In one embodiment, when the software user executes the command line tool containing the instrumentation code locally, the management platform may obtain the usage information generated by the command line tool containing the instrumentation code, analyze the usage information to generate an analysis result, and send the analysis result to the issuer.

As shown in the previous example, through other codes inserted, the management platform can count the specific time consumption't 2-t 1' for executing 'calling to the xxx address through the xx port and applying for the value of the data x'. And the analysis results are displayed through a management platform or sent to the publisher, so that unified exception analysis and data insight functions are provided for the software publisher.

Based on the same thought, one or more embodiments of the present disclosure further provide apparatuses and devices corresponding to the above method, as shown in fig. 5 and fig. 6.

In a second aspect, as shown in fig. 5, fig. 5 is a schematic structural diagram of a management device of a command line tool according to an embodiment of the present disclosure, where the device includes:

a receiving module 501 for receiving the command line code uploaded by the publisher;

a compiling module 503 for compiling the command line code to generate a temporary resource package;

the construction module 505 acquires configuration information of the code to be issued, and constructs a target resource package according to the configuration information and the temporary resource package;

and a publishing module 507 for publishing the target resource package.

Optionally, the constructing module 505 determines an integration manner of the application packages included in the configuration information of the code to be distributed by using the application packages included in the temporary resource package; and forming one or more target resource packages according to the integration mode.

Optionally, the apparatus further includes a verification module 509, configured to receive an access request from a user, where the policy access request is generated when the user runs a command line tool corresponding to the target resource package; performing configuration verification according to the policy access request and the configuration information to generate a verification result; and returning the verification result to the user so that the user can execute the command line tool according to the verification result.

Optionally, the verification module 509 obtains a version number of a command line tool included in the access request; and comparing the version number of the command line tool with the version number contained in the configuration information to generate a version verification result.

Optionally, the verification module 509 obtains a user identifier included in the access request; and comparing whether the user identifier is matched with the user identifier contained in the configuration information, and generating a user permission verification result.

Optionally, the device further includes an updating module 511, configured to obtain a gray level policy of a target resource package included in the configuration information, and generate a policy result corresponding to the user according to the gray level policy; pushing the policy results to the user for the user to update the command line tool.

Optionally, the updating module 511 pushes a policy result for characterizing code instrumentation to the user, so that the user performs code instrumentation on the command line tool based on the policy result, and generates a command line tool containing instrumented code.

Optionally, the apparatus further includes an analysis module 513, configured to obtain usage information generated by the command line tool containing the instrumentation code, analyze the usage information to generate an analysis result, and send the analysis result to the publisher.

In a third aspect, as shown in fig. 6, fig. 6 is a schematic structural diagram of an electronic device provided in an embodiment of the present disclosure, where the device includes:

at least one processor; the method comprises the steps of,

a memory communicatively coupled to the at least one processor; wherein, the liquid crystal display device comprises a liquid crystal display device,

the memory stores instructions executable by the at least one processor to enable the at least one processor to perform the method of the first aspect.

In a fourth aspect, based on the same considerations, the embodiments of the present disclosure also provide a non-volatile computer storage medium corresponding to the above-described method, storing computer executable instructions that, when read by a computer in the storage medium, cause one or more processors to perform the method according to the first aspect.

In the 90 s of the 20 th century, improvements to one technology could clearly be distinguished as improvements in hardware (e.g., improvements to circuit structures such as diodes, transistors, switches, etc.) or software (improvements to the process flow). However, with the development of technology, many improvements of the current method flows can be regarded as direct improvements of hardware circuit structures. Designers almost always obtain corresponding hardware circuit structures by programming improved method flows into hardware circuits. Therefore, an improvement of a method flow cannot be said to be realized by a hardware entity module. For example, a programmable logic device (Programmable Logic Device, PLD) (e.g., field programmable gate array (Field Programmable Gate Array, FPGA)) is an integrated circuit whose logic function is determined by the programming of the device by a user. A designer programs to "integrate" a digital system onto a PLD without requiring the chip manufacturer to design and fabricate application-specific integrated circuit chips. Moreover, nowadays, instead of manually manufacturing integrated circuit chips, such programming is mostly implemented by using "logic compiler" software, which is similar to the software compiler used in program development and writing, and the original code before the compiling is also written in a specific programming language, which is called hardware description language (Hardware Description Language, HDL), but not just one of the hdds, but a plurality of kinds, such as ABEL (Advanced Boolean Expression Language), AHDL (Altera Hardware Description Language), confluence, CUPL (Cornell University Programming Language), HDCal, JHDL (Java Hardware Description Language), lava, lola, myHDL, PALASM, RHDL (Ruby Hardware Description Language), etc., VHDL (Very-High-Speed Integrated Circuit Hardware Description Language) and Verilog are currently most commonly used. It will also be apparent to those skilled in the art that a hardware circuit implementing the logic method flow can be readily obtained by merely slightly programming the method flow into an integrated circuit using several of the hardware description languages described above.

The controller may be implemented in any suitable manner, for example, the controller may take the form of, for example, a microprocessor or processor and a computer readable medium storing computer readable program code (e.g., software or firmware) executable by the (micro) processor, logic gates, switches, application specific integrated circuits (Application Specific Integrated Circuit, ASIC), programmable logic controllers, and embedded microcontrollers, examples of which include, but are not limited to, the following microcontrollers: ARC625D, atmel AT91SAM, microchip PIC18F26K20, and Silicone Labs C8051F320, the memory controller may also be implemented as part of the control logic of the memory. Those skilled in the art will also appreciate that, in addition to implementing the controller in a pure computer readable program code, it is well possible to implement the same functionality by logically programming the method steps such that the controller is in the form of logic gates, switches, application specific integrated circuits, programmable logic controllers, embedded microcontrollers, etc. Such a controller may thus be regarded as a kind of hardware component, and means for performing various functions included therein may also be regarded as structures within the hardware component. Or even means for achieving the various functions may be regarded as either software modules implementing the methods or structures within hardware components.

The system, apparatus, module or unit set forth in the above embodiments may be implemented in particular by a computer chip or entity, or by a product having a certain function. One typical implementation is a computer. In particular, the computer may be, for example, a personal computer, a laptop computer, a cellular telephone, a camera phone, a smart phone, a personal digital assistant, a media player, a navigation device, an email device, a game console, a tablet computer, a wearable device, or a combination of any of these devices.

For convenience of description, the above devices are described as being functionally divided into various units, respectively. Of course, the functions of each element may be implemented in one or more software and/or hardware elements when implemented in the present specification.

It will be appreciated by those skilled in the art that the present description may be provided as a method, system, or computer program product. Accordingly, the present specification embodiments may take the form of an entirely hardware embodiment, an entirely software embodiment or an embodiment combining software and hardware aspects. Furthermore, the present description embodiments may take the form of a computer program product on one or more computer-usable storage media (including, but not limited to, disk storage, CD-ROM, optical storage, etc.) having computer-usable program code embodied therein.

The present description is described with reference to flowchart illustrations and/or block diagrams of methods, apparatus (systems) and computer program products according to embodiments of the specification. It will be understood that each flow and/or block of the flowchart illustrations and/or block diagrams, and combinations of flows and/or blocks in the flowchart illustrations and/or block diagrams, can be implemented by computer program instructions. These computer program instructions may be provided to a processor of a general purpose computer, special purpose computer, embedded processor, or other programmable data processing apparatus to produce a machine, such that the instructions, which execute via the processor of the computer or other programmable data processing apparatus, create means for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.

These computer program instructions may also be stored in a computer-readable memory that can direct a computer or other programmable data processing apparatus to function in a particular manner, such that the instructions stored in the computer-readable memory produce an article of manufacture including instruction means which implement the function specified in the flowchart flow or flows and/or block diagram block or blocks.

These computer program instructions may also be loaded onto a computer or other programmable data processing apparatus to cause a series of operational steps to be performed on the computer or other programmable apparatus to produce a computer implemented process such that the instructions which execute on the computer or other programmable apparatus provide steps for implementing the functions specified in the flowchart flow or flows and/or block diagram block or blocks.

In one typical configuration, a computing device includes one or more processors (CPUs), input/output interfaces, network interfaces, and memory.

The memory may include volatile memory in a computer-readable medium, random Access Memory (RAM) and/or nonvolatile memory, such as Read Only Memory (ROM) or flash memory (flash RAM). Memory is an example of computer-readable media.

Computer readable media, including both non-transitory and non-transitory, removable and non-removable media, may implement information storage by any method or technology. The information may be computer readable instructions, data structures, modules of a program, or other data. Examples of storage media for a computer include, but are not limited to, phase change memory (PRAM), static Random Access Memory (SRAM), dynamic Random Access Memory (DRAM), other types of Random Access Memory (RAM), read Only Memory (ROM), electrically Erasable Programmable Read Only Memory (EEPROM), flash memory or other memory technology, compact disc read only memory (CD-ROM), digital Versatile Discs (DVD) or other optical storage, magnetic cassettes, magnetic tape magnetic disk storage or other magnetic storage devices, or any other non-transmission medium, which can be used to store information that can be accessed by a computing device. Computer-readable media, as defined herein, does not include transitory computer-readable media (transmission media), such as modulated data signals and carrier waves.

It should also be noted that the terms "comprises," "comprising," or any other variation thereof, are intended to cover a non-exclusive inclusion, such that a process, method, article, or apparatus that comprises a list of elements does not include only those elements but may include other elements not expressly listed or inherent to such process, method, article, or apparatus. Without further limitation, an element defined by the phrase "comprising one … …" does not exclude the presence of other like elements in a process, method, article or apparatus that comprises the element.

The description may be described in the general context of computer-executable instructions, such as program modules, being executed by a computer. Generally, program modules include routines, programs, objects, components, data structures, etc. that perform particular tasks or implement particular abstract data types. The specification may also be practiced in distributed computing environments where tasks are performed by remote processing devices that are linked through a communications network. In a distributed computing environment, program modules may be located in both local and remote computer storage media including memory storage devices.

In this specification, each embodiment is described in a progressive manner, and identical and similar parts of each embodiment are all referred to each other, and each embodiment mainly describes differences from other embodiments. In particular, for apparatus, devices, non-volatile computer storage medium embodiments, the description is relatively simple, as it is substantially similar to method embodiments, with reference to the section of the method embodiments being relevant.

The foregoing describes specific embodiments of the present disclosure. Other embodiments are within the scope of the following claims. In some cases, the actions or steps recited in the claims can be performed in a different order than in the embodiments and still achieve desirable results. In addition, the processes depicted in the accompanying figures do not necessarily require the particular order shown, or sequential order, to achieve desirable results. In some embodiments, multitasking and parallel processing are also possible or may be advantageous.

The foregoing is merely one or more embodiments of the present description and is not intended to limit the present description. Various modifications and alterations to one or more embodiments of this description will be apparent to those skilled in the art. Any modification, equivalent replacement, improvement, or the like, which is within the spirit and principles of one or more embodiments of the present description, is intended to be included within the scope of the claims of the present description.

Claims (10)

1. A method of command line tool management, the method comprising:

receiving a command line code uploaded by an issuer;

compiling the command line code to generate a temporary resource package;

acquiring configuration information of the code to be issued, and constructing a target resource package according to the configuration information and the temporary resource package;

and publishing the target resource package.

2. The method of claim 1, wherein obtaining configuration information of the code to be deployed, constructing a software resource package according to the configuration information and the temporary resource package, comprises:

determining a plurality of application packages contained in the temporary resource package

Acquiring an integration mode of an application packet contained in configuration information of the code to be distributed;

and forming one or more target resource packages according to the integration mode.

3. The method of claim 1, wherein the method further comprises:

receiving an access request of a user, wherein the policy access request is generated when the user runs a command line tool corresponding to the target resource package;

performing configuration verification according to the policy access request and the configuration information to generate a verification result;

and returning the verification result to the user so that the user can execute the command line tool according to the verification result.

4. The method of claim 3, wherein performing a configuration check based on the access request and the configuration information, generating a check result, comprises:

acquiring a version number of a command line tool contained in the access request;

and comparing the version number of the command line tool with the version number contained in the configuration information to generate a version verification result.

5. The method of claim 3, wherein performing a configuration check based on the access request and the configuration information, generating a check result, comprises:

acquiring a user identifier contained in the access request;

and comparing whether the user identifier is matched with the user identifier contained in the configuration information, and generating a user permission verification result.

6. A method as claimed in claim 3, wherein the method further comprises:

acquiring a gray level strategy of a target resource package contained in the configuration information, and generating a strategy result corresponding to the user according to the gray level strategy;

pushing the policy results to the user for the user to update the command line tool.

7. The method of claim 6, wherein pushing the policy result to the user for the user to update the command line tool based on the policy result comprises:

pushing a strategy result for representing code instrumentation to the user, so that the user performs code instrumentation on the command line tool based on the strategy result, and generating the command line tool containing the instrumented code.

8. The method of claim 7, wherein the method further comprises:

and acquiring the use information generated by the command line tool containing the instrumentation code, analyzing the use information to generate an analysis result, and sending the analysis result to the publisher.

9. A command line tool management apparatus, the apparatus comprising:

the receiving module is used for receiving the command line code uploaded by the publisher;

the compiling module is used for compiling the command line codes to generate temporary resource packages;

the construction module is used for acquiring configuration information of the code to be issued and constructing a target resource package according to the configuration information and the temporary resource package;

and the release module releases the target resource package.

10. An electronic device, comprising:

at least one processor; the method comprises the steps of,

a memory communicatively coupled to the at least one processor; wherein, the liquid crystal display device comprises a liquid crystal display device,

the memory stores instructions executable by the at least one processor to enable the at least one processor to perform the method of any one of claims 1 to 8.

Images