CN116414397A

CN116414397A - Fusion processing method, device, equipment, medium and product based on Python language

Info

Publication number: CN116414397A
Application number: CN202310067990.XA
Authority: CN
Inventors: 单赟吉; 马丽萍
Original assignee: Beijing Taoyoutianxia Technology Co ltd
Current assignee: Beijing Taoyoutianxia Technology Co ltd
Priority date: 2023-01-12
Filing date: 2023-01-12
Publication date: 2023-07-11

Abstract

The embodiment of the application provides a fusing processing method, a fusing processing device, fusing processing equipment, fusing processing media and fusing processing products based on Python language, and relates to the field of Python development. The method comprises the following steps: determining target decorators from a plurality of pre-created Python decorators, each Python decorator being used for executing a fusing strategy, the fusing strategy being used for representing switching rules among different fusing states; responding to a call instruction aiming at a preset remote service, and determining the current fusing state of the preset remote service; and initiating a call according to the current fusing state, and judging whether to switch the current fusing state according to the current fusing state, the call result and the target fusing strategy executed by the target decorator. The scheme shown in the embodiment of the application can adapt to the purposes of different scenes by arranging a plurality of fusing strategies, can adapt to the scene change by a means of adding a Python decorator on the basis of avoiding modifying the original code, and finally achieves the purpose of reducing the workload of developers.

Description

Fusion processing method, device, equipment, medium and product based on Python language

Technical Field

The application relates to the field of Python development, in particular to a fusing processing method, a fusing processing device, fusing processing equipment, fusing processing media and fusing processing products based on Python language.

Background

In RPC (Remote Procedure Call, remote service call) scenario based on Python language, if a response failure occurs in downstream dependency, a timeout waiting needs to be performed at an upstream interface to perform a return process, which will increase the overall operation delay; if the downstream dependence has abnormal faults, the upstream interface is not compatible with the downstream dependence, so that the faults are reported layer by layer to finally influence the user experience; if the downstream resources are so intense that they do not respond quickly enough to the upstream requests and a large number of requests remain sent at the upstream interface, this will result in overwhelming downstream dependencies.

At present, for various problems caused by downstream dependence, a general processing mode is overtime processing, but the processing efficiency of the mode is lower; a relatively efficient manner of handling is fuse handling, which, although has many advantages over timeout handling, current fuses are typically fixed. If a scene change is encountered, the original code needs to be modified to achieve the purpose of adding fuses matched with the scene, and the time and the labor are consumed relatively.

Disclosure of Invention

In order to solve one of the above technical problems, an embodiment of the present application provides a fusing processing method, device, equipment, medium and product based on Python language. The details of the above-described various aspects are shown below.

In one aspect, an embodiment of the present application provides a method for fusing processing based on Python language, where the method includes:

determining target decorators from a plurality of pre-created Python decorators, each Python decorator being used for executing a fusing strategy, the fusing strategy being used for representing switching rules among different fusing states; responding to a call instruction aiming at a preset remote service, and determining the current fusing state of the preset remote service; and initiating a call according to the current fusing state, and judging whether to switch the current fusing state according to the current fusing state, the call result and the target fusing strategy executed by the target decorator.

Optionally, different fusing strategies characterize switching rules between different fusing states according to different types of parameters; the parameters of the target type corresponding to the target fusing strategy are any one of the following: response time length, equipment operation data, response results and response results within preset time.

Optionally, the current fusing state is an off state; initiating a call according to the current fusing state, and judging whether to switch the current fusing state according to the current fusing state, a call result and a target fusing strategy executed by a target decorator, wherein the method comprises the following steps:

initiating remote call to a preset remote service, and determining a call result according to the parameter of the target type, wherein the call result is used for indicating whether the parameter of the target type is matched with a first parameter value; if the invoking result is determined to trigger a first switching rule in the target fusing strategy, switching the current fusing state from the closing state to the opening state; the first switching rule includes: the parameter of the target type matches the first parameter value, or the cumulative number of times the parameter of the target type matches the first parameter value reaches a first preset number of times.

Optionally, the current fusing state is a half-open state, call is initiated according to the current fusing state, and whether to switch the current fusing state is judged according to the current fusing state, a call result and a target fusing strategy executed by the target decorator, including:

and initiating remote call to the preset remote service, and determining a call result according to the parameter of the target type, wherein the call result is used for indicating whether the parameter of the target type is matched with the second parameter value. If the invoking result is determined to trigger a second switching rule in the target fusing strategy, switching the current fusing state from a half-open state to an open state; the second switching rule includes: the parameter of the target type matches the second parameter value, or the accumulated number of times the parameter of the target type matches the second parameter value reaches a second preset number of times. If the invoking result is determined to trigger a third switching rule in the target fusing strategy, switching the current fusing state from a half-open state to a closed state; the third switching rule includes: the parameter of the target type does not match the second parameter value, or the accumulated number of times the parameter of the target type does not match the second parameter value reaches a third preset number of times.

Optionally, the current fusing state is an open state; initiating a call according to the current fusing state, and judging whether to switch the current fusing state according to the current fusing state, a call result and a target fusing strategy executed by a target decorator, wherein the method comprises the following steps:

initiating a call to a spam service adapted to the preset remote service so as to intercept the call to the preset remote service; the spam service is a local service. And taking the current accumulated interception time and/or the accumulated interception times as a calling result. If the calling result is determined to trigger a fourth switching rule in the target fusing strategy, switching the current fusing state from the starting state to the half-starting state; the fourth switching rule includes: the accumulated interception time is not less than a preset interception time threshold, and/or the accumulated interception times is not less than a preset interception times threshold.

Optionally, the creating process of the target decorator includes:

obtaining a logic code written by the Python language for the target decorator, wherein the logic code comprises a default part. And inputting the switching condition corresponding to the parameter of the target type according to the target fusing strategy into the default part. And obtaining the target decorator through compiling operation.

Optionally, in response to a call instruction for a preset remote service, the method includes:

Responding to a call instruction aiming at a preset remote service, and setting a preset number of acquisition windows, wherein the time length of the acquisition windows is a preset unit time length; and collecting response results of the calling instructions through a preset number of collecting windows so as to provide data basis for switching among all fusing states.

Optionally, the method further comprises:

counting the calling result aiming at the preset remote service in the preset time; the calling result comprises successful calling service, failed calling service, intercepted service calling and unknown calling; and carrying out data display according to the statistical result of each calling result.

On the other hand, the embodiment of the application also provides a fusing processing device based on Python language, which comprises the following modules.

The first determining module is used for determining a target decorator from a plurality of pre-created Python decorators, wherein each Python decorator is used for executing a fusing strategy, and the fusing strategy is used for representing switching rules among different fusing states.

And the second determining module is used for responding to the calling instruction aiming at the preset remote service and determining the current fusing state of the preset remote service.

The judging module is used for initiating calling according to the current fusing state and judging whether to switch the current fusing state according to the current fusing state, the calling result and the target fusing strategy executed by the target decorator.

The embodiment of the application also provides electronic equipment, which comprises:

the device comprises a memory, a processor and a computer program stored on the memory, wherein the processor executes the computer program to realize a fusing processing method based on Python language.

The embodiment of the application also provides a computer readable storage medium, on which a computer program is stored, which is characterized in that the computer program realizes a fusing processing method based on Python language when being executed by a processor.

The embodiment of the application also provides a computer program product, which comprises a computer program and is characterized in that the computer program is executed by a processor to realize a fusing processing method based on Python language.

The beneficial effects that technical scheme that this application embodiment provided brought are:

the embodiment of the application provides a fusing processing method based on Python language, which comprises the following steps: determining target decorators from a plurality of pre-created Python decorators, each Python decorator being used for executing a fusing strategy, the fusing strategy being used for representing switching rules among different fusing states; responding to a call instruction aiming at a preset remote service, and determining the current fusing state of the preset remote service; and initiating a call according to the current fusing state, and judging whether to switch the current fusing state according to the current fusing state, the call result and the target fusing strategy executed by the target decorator. Two types of Python decorators exist in Python grammar, a function decorator and a class decorator. Regardless of the Python decorator, other functions can be added with additional functions without any code changes, or method classes can be added with additional functions without any code changes. The method uses the advantages of the Python decorators, and realizes the corresponding Python decorators according to the fusing strategy on the basis of avoiding modifying the original codes, thereby realizing the purpose of adding a new fusing strategy. Therefore, the method can adapt to the purposes of different scenes by arranging a plurality of fusing strategies, can adapt to the scene change by a means of adding a Python decorator on the basis of avoiding modifying the original codes, and finally achieves the purpose of reducing the workload of developers.

Drawings

In order to more clearly illustrate the technical solutions in the embodiments of the present application, the drawings that are required to be used in the description of the embodiments of the present application will be briefly described below.

Fig. 1 is a flow chart of a fusing processing method based on Python language according to an embodiment of the present application;

fig. 2 is an application scenario schematic diagram of a fusion processing method based on Python language according to an embodiment of the present application;

fig. 3 is a schematic structural diagram of a fusing processing device based on Python language according to an embodiment of the present application;

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

Detailed Description

Embodiments of the present application are described below with reference to the drawings in the present application. It should be understood that the embodiments described below with reference to the drawings are exemplary descriptions for explaining the technical solutions of the embodiments of the present application, and the technical solutions of the embodiments of the present application are not limited.

As used herein, the singular forms "a", "an", "the" and "the" are intended to include the plural forms as well, unless expressly stated otherwise, as understood by those skilled in the art. It will be further understood that the terms "comprises" and "comprising," when used in this application, specify the presence of stated features, information, data, steps, operations, elements, and/or components, but do not preclude the presence or addition of other features, information, data, steps, operations, elements, components, and/or groups thereof, all of which may be included in the present application. It will be understood that when an element is referred to as being "connected" or "coupled" to another element, it can be directly connected or coupled to the other element or intervening elements may be present. Further, "connected" or "coupled" as used herein may include wirelessly connected or wirelessly coupled. The term "and/or" as used herein indicates that at least one of the items defined by the term, e.g., "a and/or B" may be implemented as "a", or as "B", or as "a and B".

For the purpose of making the objects, technical solutions and advantages of the present application more apparent, the embodiments of the present application will be described in further detail below with reference to the accompanying drawings.

Python language, a computer programming language. The decorator (decollator) is a grammar format in Python, such as @ closed method, @ static method, @ property, @ xxx. Setter, @ wraps (), @ func_name is a decorator. The decorator may allow additional functionality to be added to other functions without any code changes.

In general, decorators can be used in the following scenarios: insert log, performance test, transaction, cache, permission check, etc. In the embodiment of the application, the decorator is mainly used for configuring a fusing function for a preset remote service.

In order to solve the problems shown in the background art, the embodiment of the application provides a fusing processing method based on a Python language, which can be applied to any electronic equipment. Specifically, determining a target decorator from a plurality of pre-created Python decorators, wherein each Python decorator is used for executing a fusing strategy, and the fusing strategy is used for representing switching rules among different fusing states; responding to a call instruction aiming at a preset remote service, and determining the current fusing state of the preset remote service; and initiating a call according to the current fusing state, and judging whether to switch the current fusing state according to the current fusing state, the call result and the target fusing strategy executed by the target decorator. The method realizes the corresponding Python decorators according to the fusing strategy on the basis of the original codes through the Python decorators, namely, new fusing strategies can be added without modifying the codes. In general, the method can adapt to the purposes of different scenes by arranging a plurality of fusing strategies, can adapt to the scene change by a means of adding a Python decorator on the basis of avoiding modifying the original codes, and finally achieves the purpose of reducing the workload of developers.

Alternatively, the method provided in the embodiments of the present application may be implemented as a stand-alone application or as a functional module/plug-in of an application. For example, the application may be a specific Python language-based fusing process or other application having Python language-based fusing process function, by which the purpose of the fusing process may be achieved.

The technical solutions of the embodiments of the present application and technical effects produced by the technical solutions of the present application are described below by describing several exemplary embodiments. It should be noted that the following embodiments may be referred to, or combined with each other, and the description will not be repeated for the same terms, similar features, similar implementation steps, and the like in different embodiments.

The embodiment of the application provides a method embodiment to solve the technical problems. Specifically, fig. 1 shows a flow diagram of a blowing processing method based on Python language. The method comprises steps S110 to S130.

S110, determining target decorators from a plurality of pre-created Python decorators, wherein each Python decorator is used for executing a fusing strategy, and the fusing strategy is used for representing switching rules among different fusing states.

Two types of Python decorators are defined in Python syntax. One is a function decorator that is essentially a Python function, usually beginning with the symbol "@; the function decorator can decorate other Python functions and Python classes. The other is a class decorator, essentially of the Python class, also beginning with the symbol "@; the function decorator can decorate either the Python function or other Python class. For example, python carries several built-in decorators: @classmethod; @ staticmethod; @ property.

Where the Python function or Python class decorated by the Python decorator is understood as the objective function or objective class. It should be noted that the purpose of the decorator to decorate an objective function or class of objectives is to provide an objective function or class of objectives with new functionality.

In order to understand the implementation process of the Python decorator, the embodiment of the application also provides an application example of the function decorator.

In this example, the function decorator is "log (func)", and the decorated Python function is "add (x, y)". It can be appreciated from this example that the goal of adding an interpreted language to the output of "add (x, y)" is achieved without changing the original code of "add (x, y)".

In this example, the

input parameters

200 and 50, i.e., add (200,50), may yield the following:

i prepare to start the calculation: add function:

200+50＝250

the calculation is completed-!

Specifically, when the parameter of the target type is the response time, if the response time of calling the preset remote service exceeds the preset response time, determining that the calling of the preset remote service has a problem; if the response result is received within the preset response time, it can be determined that no problem occurs in the calling of the preset remote service. If the problem of calling the preset remote service is determined to occur for a plurality of times, the measure of fusing the preset remote service is needed.

Specifically, when the parameter of the target type is the equipment operation data, if the equipment operation data is detected to exceed the preset operation threshold value in the process of calling the preset remote service, the normal operation of the equipment can be influenced by the calling process of the preset remote service; if the index of the equipment in operation is detected not to exceed the preset operation threshold, the fact that the normal operation of the equipment is not affected by the preset remote service can be determined. For a preset remote service affecting the operation of the device, measures of fusing are required. For example, the device operation data may be specifically operation data of the CPU, or operation data of the GPU.

Specifically, when the parameter of the target type is a response result, if the response result of the preset remote service is information containing "failure" or information matching "failure", it may be determined that the response result of the preset remote service is an error; if the response result of the preset remote service is information containing "success" or information matching "success", it can be determined that the response result of the preset remote service is correct. If the response result is information containing "failure" or information matching "failure" a plurality of times, measures for fusing processing need to be taken.

Specifically, when the parameter of the target type is a response result in a preset time, if the response result of the preset remote service is information containing "failure" or information matched with "failure" in the preset time, it can be determined that the response result of the preset remote service is an error; if the response result of the preset remote service is information containing "success" or information matching "success", it can be determined that the response result of the preset remote service is correct. If the response result is information containing "failure" or information matching "failure" multiple times within the preset time, measures of fusing processing need to be taken.

S120, determining the current fusing state of the preset remote service in response to a call instruction for the preset remote service.

The fusing state of the preset remote service may include the following three states:

and a closed state. Specifically, when the fusing state is the off state, the fusing processing of the preset remote service is closed, and the preset remote service is normally invoked.

An on state. Specifically, when the fusing state is an on state, the fusing process for the preset remote service is started, that is, the call for the preset remote service is intercepted.

Semi-open state. Specifically, when the fusing state is a half-open state, the method indicates a normal calling of a preset remote service of the part, and determines whether to switch to an open state or a closed state according to the calling condition.

Because the processing ideas for fusing in different scenes are different, different fusing strategies are generated, and in order to implement each fusing strategy to solve the fusing service requirements in different scenes, when the fusing component is created, the parameter threshold value corresponding to each fusing strategy can be obtained.

In one implementation of this embodiment, the creation process of the target fuse component includes:

Writing a logic code of the target decorator through Python language, wherein the logic code comprises a default part; inputting a switching condition corresponding to a parameter of a target type according to a target fusing strategy into a default part; and obtaining the target decorator through compiling operation.

Alternatively, the configuration of the target fusing strategy may be achieved by configuring parameters of the target type. Specifically, in the embodiment of the present application, if the fusing states exist in the above 3 types, the switching conditions between the 3 types include various thresholds. For example, from the off state to the on state, a first parameter value is set for "response time", the matching degree of the response time and the first parameter value is compared, and a cumulative matching number threshold, that is, a first preset number of times, when the response time matches the first parameter value is set.

To more clearly understand the creation process of the Python decorator, an exemplary piece of code is also provided by embodiments of the present application.

In this example, the objective function is RPC (), i.e., a function that is called for a preset remote service. Among them, added to RPC () is a Python-type decorator "Policy". The parameter on which this example is based is the response time.

Class Policy (object)/Python type decorator

……

defmark failure (self):// mark single request failure

……

def __ check_fuse (self)// determines whether to enter the blown state.

……

@Policy

def RPC ()/decorated objective function

……

S130, calling is initiated according to the current fusing state, and whether the current fusing state is switched is judged according to the current fusing state, a calling result and a target fusing strategy executed by the target decorator.

The method provided by the embodiment of the application is based on Python language, and two Python decorators exist in Python grammar, namely a function decorator and a class decorator. Regardless of the Python decorator, other Python functions can be added with additional functions without any code changes, or Python classes can be added with additional functions without any code changes. The method uses the advantages of the Python decorators, and realizes the corresponding Python decorators according to the fusing strategy on the basis of avoiding modifying the original codes, thereby realizing the purpose of adding a new fusing strategy. Therefore, the method can adapt to the purposes of different scenes by arranging a plurality of fusing strategies, can adapt to the scene change by a means of adding a Python decorator on the basis of avoiding modifying the original codes, and finally achieves the purpose of reducing the workload of developers.

The target fusing strategy is different for the switching rules under different fusing states, and an embodiment of the present application provides an embodiment to determine how specific parameters determine whether to switch the current fusing state according to the type of the fusing state.

In one implementation of this embodiment, the current blown state is the off state. Step S130 may specifically include the following steps Sa1 to Sa3.

Sa1, initiate the remote call to the preset remote service.

Specifically, in the case where the blown state is the off state, a call may be initiated to the remote service, and during the call, various data during the call may be monitored. If the parameter of the target type is "response duration", monitoring the time for feeding back the response result when the remote service is called; if the parameter of the target type is a response result, monitoring whether the response result fed back when the remote service is called is the failure or the information matched with the failure.

And Sa2, determining a calling result according to the parameter of the target type, wherein the calling result is used for indicating whether the parameter of the target type is matched with the first parameter value.

The first parameter value is a value indicating that the fusing process is required. The matching with the first parameter value indicates that the current calling result needs to be subjected to fusing processing, or needs to be accumulated so as to achieve the purpose of fusing processing. That is, the fusing state needs to be adjusted to the on state.

Specifically, a call result is determined from the monitored data according to the parameter of the target type, and whether the parameter of the target type matches the first parameter value is determined by the call result. If the parameter of the target type is "response time", the first parameter value is a preset response time value; wherein, the response time is not less than the first parameter value, and the first parameter value is determined to be matched; and if the response time is smaller than the first parameter value, determining that the first parameter value is not matched. If the parameter of the target type is "equipment operation data", the first parameter value is a preset operation threshold; if the equipment operation data is not smaller than the operation threshold value, determining to match the first parameter value; and if the equipment operation data is smaller than the operation threshold value, determining that the first parameter value is not matched. If the parameter of the target type is "response result", the first parameter value is "failure" or information matched with "failure"; if the response result is "failure" or information matched with "failure", determining to match the first parameter value; if the "response result" is not the above information, it is determined that the first parameter value is not matched.

The device operation data may be operation data of a CPU, operation data of a GPU, or the like. Taking the operation data of the CPU as an example, setting the operation threshold of the CPU as 80%, and if the current operation data of the CPU is 81%, determining that the operation data of the CPU is matched with the first parameter value.

Sa3, if the invoking result is determined to trigger a first switching rule in the target fusing strategy, switching the current fusing state from the closing state to the opening state; the first switching rule includes: the parameter of the target type matches the first parameter value, or the cumulative number of times the parameter of the target type matches the first parameter value reaches a first preset number of times.

Specifically, a first switching rule is set in the target fusing strategy, and the rule is used for indicating how to switch from the off state to the on state.

Specifically, if the parameter of the target type is the device operation data, the switching operation may be implemented according to the first switching rule that "the parameter of the target type matches the first parameter value", that is, when the device operation data matches the first parameter value. If the parameters of the target type are "response time", "response result" and "response result in the preset time", the first switching rule is "the accumulated number of times of matching the parameters of the target type with the first parameter value reaches the first preset number of times" as the switching rule, and taking the corresponding time as an example, the response time is accumulated once when the response time matches the first parameter value, and when the accumulated number of times reaches the first preset number of times, the switching operation can be executed.

For a clearer understanding of the implementation of the first switching rule, reference may be made to the following pseudo code examples. In this example, the function being decorated is RPC ()

In this example, when the current fusing state is the off state, the preset remote service needs to be directly invoked. Specifically, after the RPC () function is called, a callback result is obtained to give feedback whether the RPC () function is called successfully. If the call result is failure or information (corresponding to the first parameter value) matched with the failure, a failure accumulation operation needs to be performed, for example, a failure accumulation operation is performed through "mark_failure (self)", for example, a self-adding 1 operation is performed on "_bad_count"; after the accumulation is finished, it needs to check whether the accumulated value triggers a first preset number of times (i.e. self_bad_count > self_threshold is executed), and if the first preset number of times is triggered, the current fusing state needs to be adjusted from the on state to the off state (i.e. self_state=policy state.

In this example, after the adjustment of the state, the accumulated parameter may also be cleared, for example, "self_bad_count=0" is performed.

In another implementation of this embodiment, the current blown state is a half-open state. Step S130 may specifically include the following steps Sb1 to Sb4.

Sb1, initiating remote call to a preset remote service.

Specifically, under the condition that the fusing state is the closing state, a call can be initiated to the remote service, and various data in the call process can be monitored in the call process.

And Sb2, determining a calling result according to the parameter of the target type, wherein the calling result is used for indicating whether the parameter of the target type is matched with the second parameter value.

The second parameter value is a value indicating that the fusing process is required. The matching with the second parameter value indicates that the current calling result needs to be subjected to fusing processing, or needs to be accumulated so as to achieve the purpose of fusing processing. That is, the fusing state needs to be adjusted to the on state.

Since the current fusing state is a half-open state, a second parameter value needs to be additionally set when matching parameters of a target type. Specifically, a call result is determined from the monitored data according to the parameter of the target type, and whether the parameter of the target type matches the second parameter value is determined by the call result.

Specifically, a call result is determined from the monitored data according to the parameter of the target type, and whether the parameter of the target type matches the second parameter value is determined by the call result. If the parameter of the target type is the response time length, the second parameter value is a preset response time length value; wherein, the response time is not less than the second parameter value, and the second parameter value is determined to be matched; and if the response time is smaller than the second parameter value, determining that the second parameter value is not matched. If the parameter of the target type is the equipment operation data, the second parameter value is a preset operation threshold value; if the equipment operation data is not smaller than the operation threshold value, determining to match the second parameter value; and if the equipment operation data is smaller than the operation threshold value, determining that the second parameter value is not matched. If the parameter of the target type is a response result, the second parameter value is "failure" or information matched with "failure"; and if the response result is "failure" or information matched with "failure", determining to match the second parameter value, and if the response result is not "failure" or information not matched with "failure", determining to not match the second parameter value.

Sb3, if the invoking result is determined to trigger a second switching rule in the target fusing strategy, switching the current fusing state from the half-open state to the open state; the second switching rule includes: the parameter of the target type does not match the second parameter value, or the cumulative number of times the parameter of the target type does not match the second parameter value reaches a second preset number of times.

Specifically, a second switching rule is set in the target fusing strategy, and the second switching rule is used for indicating how to switch from the half-open state to the open state.

If the parameter of the target type is the equipment operation data, and the second switching rule according to the second switching rule is that the parameter of the target type matches the second parameter value, that is, when the equipment operation data matches the second parameter value, the switching operation can be implemented. If the parameters of the target type are the response time, the response result and the response result in the preset time, the second switching rule is used as the switching rule, wherein the accumulated times of the parameter of the target type matched with the second parameter value reach the second preset times. Taking response time as an example, if the response time matches the second parameter value, accumulating once, and executing switching operation when the accumulated times reach the second preset times.

Sb4, if the invoking result is determined to trigger a third switching rule in the target fusing strategy, switching the current fusing state from the half-open state to the closed state; the third switching rule includes: the parameter of the target type matches the second parameter value, or the accumulated number of times the parameter of the target type matches the second parameter value reaches a third preset number of times.

Specifically, a third switching rule is set in the target fusing strategy, and the third switching rule is used for indicating how to switch from the half-open state to the closed state.

If the parameter of the target type is the equipment operation data, and the second switching rule according to the second switching rule is that the parameter of the target type does not match the second parameter value, that is, when the equipment operation data matches the second parameter value, the switching operation can be implemented. If the parameters of the target type are the response time, the response result and the response result in the preset time, the second switching rule is used as the switching rule, wherein the accumulated times of the parameter of the target type, which is not matched with the second parameter value, reach the second preset times. Taking the response time as an example, if the response time does not match the second parameter value once, accumulating once, and when the accumulated times reach the third preset times, executing the switching operation.

This embodiment also provides a section of pseudo code example in order to more clearly understand the implementation of the second and third switching rules. In this example, the parameter according to which the target fusing strategy is based is the response result.

In this example, when the current fusing state is the half-open state, the preset remote service needs to be directly invoked. Specifically, after the RPC () function is called, a callback result is obtained to give feedback whether the RPC () function is called successfully.

If the callback result is that the call is successful, performing a successful accumulation (for example, performing a_mark_success (self) function), specifically, performing a self-adding operation on the accumulation parameter (for example, performing_halfopen_good_count+ =1); after the accumulation is finished, judging whether the accumulation parameter exceeds a second preset number of times (for example, self_halfopen_three); and setting the current fusing state to be a closing state (such as PolicyState. OPEN) under the condition that the current fusing state is not less than the second preset times.

If the callback result is call failure, performing a successful accumulation (for example, performing a_mark_failure (self) function), and performing an operation of adding an accumulation parameter (for example, performing_halfopen_good_count+ =1) in the function; after the accumulation is finished, judging whether the accumulation parameter exceeds a second preset number of times (for example, self_halfopen_three); if the number of times is not less than the second preset number of times, the current fusing state is set to be the off state (such as PolicyState. OPEN)

In this example, after the current state is adjusted, the accumulated parameters also need to be cleared.

In yet another implementation of this embodiment, the current blown state is an on state. Specifically, the step S130 includes the following steps Sc1 to Sc3.

Sc1, initiating a call to a spam service adapted to the preset remote service so as to intercept the call to the preset remote service. The spam service is a local service.

Optionally, the call instruction further includes a call parameter for a preset remote service. Specifically, according to the calling parameters carried by the calling instruction, calling is initiated to the spam service, so that spam data is obtained, and the spam data is consistent with the type of feedback data obtained by calling the preset remote service. The spam service is used for providing response data of spam for the purpose of completing the instruction of a calling instruction when intercepting the call of the preset remote service; the response data of the spam is stored locally in advance. The spam service is of a service level, specifically, if the spam service is not directly called through any parameter, default spam data can be obtained, and the spam service level is lower; if the spam service is invoked by at least one parameter, spam data responsive to the at least one parameter may be obtained, the spam service being of a higher level.

In order to better understand the implementation effect of the spam service, a specific example is also provided. In this example, the preset remote service is to remotely acquire the user avatar of the current page, so the response data of the preset remote service includes the avatar address of the user, and so on. The calling instruction carries the gender information of the user, and if the spam service is directly called, the default user head portrait is fed back. If the spam service is called through the sex information, the user head portrait corresponding to the sex information is fed back, if a male is fed back, and if a female is fed back, the female head portrait is fed back.

In addition, the feedback data can be determined by combining a plurality of parameters of the calling instruction, so that the description is simple and convenient, and the description is omitted. By setting the level of the spam data, the user-defined operation of the spam data is realized, and the user experience is improved.

Sc2, taking the current accumulated interception time and/or accumulated interception times as a calling result.

Sc3, if the calling result is determined to trigger a fourth switching rule in the target fusing strategy, switching the current fusing state from the opening state to the half-opening state; the fourth switching rule includes: the accumulated interception time is not less than a preset interception time threshold, and/or the accumulated interception times is not less than a preset interception times threshold.

When the fusing state is in the opening state, interception processing can be performed by setting an interception time threshold and/or an interception time threshold. Specifically, when the interception times threshold is set, the accumulated interception times are used as calling results and compared with the interception times threshold, and if the interception times are not smaller than the interception times threshold, the fourth switching rule is determined to be triggered. When the interception time threshold is set, accumulating the interception time as a calling result, comparing the calling result with the interception time threshold, and determining that the fourth switching rule is triggered if the interception time is not smaller than the interception time threshold.

This embodiment also provides a section of pseudo code example for a clearer understanding of the implementation of the fourth switching rule. In this example, the parameter according to which the target fusing strategy is based is the accumulated interception time.

/>

In this example, in the state that the fusing state is on, fusing a call to a preset remote service, and performing a cumulative operation (for example, by executing a try_call (self, func, args, kwargs) function); wherein, in the case that the accumulated fusing time is less than 20s, the fusing state is maintained as an on state (e.g., raise PolicyMasked ()); and setting the current fusing state as a half-open state under the condition that the accumulated fusing time is not less than 20 s.

In the calling process, how to monitor each calling process so as to provide valuable data reference for state switching is also a technical problem which needs to be solved urgently. For this purpose, an alternative embodiment is also provided in the present application.

In one implementation of this embodiment, the method includes the following steps Sd1 to Sd2 in addition to steps S120 to S130.

Sd1, responding to a call instruction aiming at a preset remote service, and setting a preset number of acquisition windows, wherein the time length of the acquisition windows is a preset unit time length.

Specifically, the unit time is taken as one acquisition window, and then the time length of the acquisition window is the preset unit time length. Over time, the preset number of acquisition windows may move in the direction of the passage of time.

Sd2, collecting response results of the calling instruction through a preset number of collecting windows so as to provide data basis for switching among all fusing states.

Specifically, in one acquisition window, a calling process for a preset remote service is monitored, and parameters of a target type are acquired. For example, for "response time," the response time for invoking a preset remote service is monitored.

In order to better understand the working principle of the acquisition window, a specific example is also provided. In this example, 60 acquisition windows are provided, each having a time length of 1 second, i.e., 1 minute divided into 60 cells. In the period 14:00:01-14:00:02, 60 acquisition windows acquire a plurality of parameters at corresponding windows in sequence, such as: response time, device performance, response results, etc. The acquisition operation is finished until 14:00:02, then 60 acquisition windows slide to the time period 14:00:02-14:00:03 again, and data acquisition is continued.

In the process of accessing the preset remote service, the final results are various, and how to feed back the results to the user to achieve the purpose of fusing monitoring is also a problem to be solved. For this purpose, an alternative embodiment is also provided in the present application.

In one implementation of this embodiment, the method further comprises the following steps Se 1-Se 2.

Se1, counting the calling result aiming at the preset remote service in the preset time; the call results include call services have succeeded, call services have failed, intercepted service calls, and unknown calls.

And Se2, carrying out data display according to the statistical result of each calling result.

Specifically, after the remote service is called, determining whether the calling result is any one of successful calling service, failed calling service and unknown calling after the current fusing state is the closing state; or, after the remote service is called, determining whether the calling result is any one of successful calling service, failed calling service and unknown calling. And directly counting the times of intercepted service calls when the current fusing state is an opening state.

In order to more clearly understand the execution of Se 1-Se 2, the present application also provides examples of statistics over time and large disc presentation operations. In the demonstration process of this example, the current fusing state undergoes the following process: closed- > open- > half open- > closed.

Specifically, from an on state, the blown state is an off state; from 15:44, starting to preset abnormal calling result of the remote service, starting to generate the condition that the calling service fails, and also presenting an ascending trend; at 15:46 minutes, the fusing process is started and is continued until 15:53, ending the fusing process and adjusting to a half-open state; after the accumulated multiple times of call services in the semi-open state are successful, the call services are adjusted to the closed state again. And finally, the calling result of the preset remote service is normal.

Based on the above method embodiments, the present application further provides an apparatus embodiment, specifically, a schematic structural diagram of a blowing processing apparatus 300 based on Python language as shown in fig. 3. The apparatus 300 includes the following modules.

A first determining module 310 is configured to determine a target decorator from a plurality of Python decorators created in advance, each Python decorator being configured to execute a fusing strategy, and the fusing strategy being configured to characterize a switching rule between different fusing states.

The second determining module 320 is configured to determine a current fusing state of the preset remote service in response to a call instruction for the preset remote service.

The judging module 330 is configured to initiate a call according to the current fusing state, and judge whether to switch the current fusing state according to the current fusing state, the call result, and the target fusing policy executed by the target decorator.

Optionally, the current fusing state is an off state; the judging module 330 initiates a call according to the current fusing state, and judges whether to switch the current fusing state according to the current fusing state, the call result and the target fusing policy executed by the target decorator, which is specifically configured to:

And initiating remote call to a preset remote service, and determining a call result according to the parameter of the target type, wherein the call result is used for indicating whether the parameter of the target type is matched with the first parameter value. If the invoking result is determined to trigger a first switching rule in the target fusing strategy, switching the current fusing state from the closing state to the opening state; the first switching rule includes: the parameter of the target type matches the first parameter value, or the cumulative number of times the parameter of the target type matches the first parameter value reaches a first preset number of times.

Optionally, the current fusing state is a half-open state; the judging module 330 is used for initiating a call according to the current fusing state, and judging whether to switch the current fusing state according to the current fusing state, the call result and the target fusing strategy executed by the target decorator, specifically

Optionally, the current fusing state is an open state; the judging module 330 initiates a call according to the current fusing state, and judges whether to switch the current fusing state according to the current fusing state, the call result and the target fusing policy executed by the target decorator, which is specifically configured to:

Optionally, the first determining module 310 is specifically configured to, during the creation of the target decorator:

obtaining a logic code written in a Python language for a target decorator, wherein the logic code comprises a default part; inputting a switching condition corresponding to a parameter of a target type according to a target fusing strategy into a default part; and obtaining the target decorator through compiling operation.

Optionally, the second determining module 320 may be further configured to:

Optionally, the apparatus 300 further includes a display module 340, specifically configured to:

counting the calling result aiming at the preset remote service in the preset time; the call results include call services have succeeded, call services have failed, intercepted service calls, and unknown calls. And carrying out data display according to the statistical result of each calling result.

The apparatus of the embodiments of the present application may perform the method provided by the embodiments of the present application, and implementation principles of the method are similar, and actions performed by each module in the apparatus of each embodiment of the present application correspond to steps in the method of each embodiment of the present application, and detailed functional descriptions of each module of the apparatus may be referred to in the corresponding method shown in the foregoing, which is not repeated herein.

The embodiment of the application provides an electronic device, which comprises a memory, a processor and a computer program stored on the memory, wherein the processor executes the computer program to realize the steps of a fusing processing method based on a Python language, and compared with the related art, the method can realize the following steps: the purpose of adapting to different scenes is achieved by arranging a plurality of fusing strategies, scene change can be adapted by means of adding a Python decorator on the basis of avoiding modification of an original code, and finally the purpose of reducing workload of developers is achieved.

In an alternative embodiment, an electronic device is provided, as shown in fig. 4, the electronic device 4000 shown in fig. 4 includes: a processor 4001 and a memory 4003. Wherein the processor 4001 is coupled to the memory 4003, such as via a bus 4002. Optionally, the electronic device 4000 may further comprise a transceiver 4004, the transceiver 4004 may be used for data interaction between the electronic device and other electronic devices, such as transmission of data and/or reception of data, etc. It should be noted that, in practical applications, the transceiver 4004 is not limited to one, and the structure of the electronic device 4000 is not limited to the embodiment of the present application.

The processor 4001 may be a CPU (Central Processing Unit ), general purpose processor, DSP (Digital Signal Processor, data signal processor), ASIC (Application Specific Integrated Circuit ), FPGA (Field Programmable Gate Array, field programmable gate array) or other programmable logic device, transistor logic device, hardware components, or any combination thereof. Which may implement or perform the various exemplary logic blocks, modules, and circuits described in connection with this disclosure. The processor 4001 may also be a combination that implements computing functionality, e.g., comprising one or more microprocessor combinations, a combination of a DSP and a microprocessor, etc.

Bus 4002 may include a path to transfer information between the aforementioned components. Bus 4002 may be a PCI (Peripheral Component Interconnect, peripheral component interconnect standard) bus or an EISA (Extended Industry Standard Architecture ) bus, or the like. The bus 4002 can be divided into an address bus, a data bus, a control bus, and the like. For ease of illustration, only one thick line is shown in fig. 4, but not only one bus or one type of bus.

Memory 4003 may be, but is not limited to, ROM (Read Only Memory) or other type of static storage device that can store static information and instructions, RAM (Random Access Memory ) or other type of dynamic storage device that can store information and instructions, EEPROM (Electrically Erasable Programmable Read Only Memory ), CD-ROM (Compact Disc Read Only Memory, compact disc Read Only Memory) or other optical disk storage, optical disk storage (including compact discs, laser discs, optical discs, digital versatile discs, blu-ray discs, etc.), magnetic disk storage media, other magnetic storage devices, or any other medium that can be used to carry or store a computer program and that can be Read by a computer.

The memory 4003 is used for storing a computer program that executes an embodiment of the present application, and is controlled to be executed by the processor 4001. The processor 4001 is configured to execute a computer program stored in the memory 4003 to realize the steps shown in the foregoing method embodiment.

Among them, electronic devices include, but are not limited to: and a server.

Embodiments of the present application provide a computer readable storage medium having a computer program stored thereon, where the computer program, when executed by a processor, may implement the steps and corresponding content of the foregoing method embodiments.

The embodiments of the present application also provide a computer program product, which includes a computer program, where the computer program can implement the steps of the foregoing method embodiments and corresponding content when executed by a processor.

The terms "first," "second," "third," "fourth," "1," "2," and the like in the description and in the claims of this application and in the above-described figures, if any, are used for distinguishing between similar objects and not necessarily for describing a particular sequential or chronological order. It is to be understood that the data so used may be interchanged where appropriate such that the embodiments of the present application described herein may be implemented in other sequences than those illustrated or otherwise described.

It should be understood that, although the flowcharts of the embodiments of the present application indicate the respective operation steps by arrows, the order of implementation of these steps is not limited to the order indicated by the arrows. In some implementations of embodiments of the present application, the implementation steps in the flowcharts may be performed in other orders as desired, unless explicitly stated herein. Furthermore, some or all of the steps in the flowcharts may include multiple sub-steps or multiple stages based on the actual implementation scenario. Some or all of these sub-steps or phases may be performed at the same time, or each of these sub-steps or phases may be performed at different times, respectively. In the case of different execution time, the execution sequence of the sub-steps or stages may be flexibly configured according to the requirement, which is not limited in the embodiment of the present application.

The foregoing is merely an optional implementation manner of the implementation scenario of the application, and it should be noted that, for those skilled in the art, other similar implementation manners based on the technical ideas of the application are adopted without departing from the technical ideas of the application, and also belong to the protection scope of the embodiments of the application.

Claims

1. A method for fusing based on Python language, the method comprising:

determining target decorators from a plurality of pre-created Python decorators, each Python decorator for executing a fusing strategy for characterizing switching rules between different fusing states;

determining a current fusing state of the preset remote service in response to a call instruction for the preset remote service;

and initiating a call according to the current fusing state, and judging whether to switch the current fusing state according to the current fusing state, a call result and a target fusing strategy executed by the target decorator.

2. The method of claim 1, wherein different fusing strategies characterize switching rules between the different fusing states in terms of different types of parameters;

the parameters of the target type corresponding to the target fusing strategy are any one of the following parameters: response time length, equipment operation data, response results and response results within preset time.

3. The method of claim 2, wherein the current blown state is an off state; the step of initiating the call according to the current fusing state, and judging whether to switch the current fusing state according to the current fusing state, the call result and the target fusing strategy executed by the target decorator, comprises the following steps:

Initiating remote call to the preset remote service, and determining a call result according to the parameter of the target type, wherein the call result is used for indicating whether the parameter of the target type is matched with a first parameter value;

if the calling result is determined to trigger a first switching rule in the target fusing strategy, switching the current fusing state from the closing state to the opening state; the first switching rule includes: the parameter of the target type is matched with a first parameter value, or the accumulated times of the parameter of the target type matched with the first parameter value reach a first preset times.

4. The method of claim 2, wherein the current fusing state is a half-open state, wherein the initiating the call according to the current fusing state and determining whether to switch the current fusing state according to the current fusing state, the call result, and the target fusing policy executed by the target decorator comprises:

initiating remote call to the preset remote service, and determining a call result according to the parameter of the target type, wherein the call result is used for indicating whether the parameter of the target type is matched with a second parameter value;

if the invoking result is determined to trigger a second switching rule in the target fusing strategy, switching the current fusing state from the half-open state to an open state; the second switching rule includes: the parameter of the target type is matched with the second parameter value, or the accumulated times of the parameter of the target type matched with the second parameter value reach a second preset times;

If the calling result is determined to trigger a third switching rule in the target fusing strategy, switching the current fusing state from the half-open state to the closed state; the third switching rule includes: and the parameter of the target type does not match the second parameter value, or the accumulated times of the parameter of the target type which does not match the second parameter value reach a third preset times.

5. The method of claim 2, wherein the current blown state is an on state; the step of initiating the call according to the current fusing state, and judging whether to switch the current fusing state according to the current fusing state, the call result and the target fusing strategy executed by the target decorator, comprises the following steps:

initiating a call to a spam service adapted to the preset remote service so as to intercept the call to the preset remote service; the spam service is a local service;

taking the current accumulated interception time and/or accumulated interception times as the calling result;

if the calling result is determined to trigger a fourth switching rule in the target fusing strategy, switching the current fusing state from the starting state to a half-starting state; the fourth switching rule includes: the accumulated interception time is not less than a preset interception time threshold, and/or the accumulated interception times is not less than a preset interception times threshold.

6. The method of any one of claims 1-5, wherein the creation process of the target decorator comprises:

acquiring a logic code written in a Python language, wherein the logic code comprises a default part;

inputting a switching condition corresponding to a parameter of a target type according to the target fusing strategy into the default part;

and obtaining the target decorator through compiling operation.

7. The method according to any one of claims 1-5, characterized in that the method comprises:

responding to a call instruction aiming at a preset remote service, setting a preset number of acquisition windows, wherein the time length of the acquisition windows is a preset unit time length;

and collecting response results of the calling instruction through the preset number of collecting windows so as to provide data basis for switching among all fusing states.

8. The method according to any one of claims 1-5, characterized in that the method comprises:

counting the calling result of the preset remote service in the preset time; the calling result comprises successful calling service, failed calling service, intercepted service calling and unknown calling;

And carrying out data display according to the statistical result of each calling result.

9. A Python language-based fusing processing apparatus, comprising:

a first determining module, configured to determine a target decorator from a plurality of Python decorators created in advance, where each Python decorator is configured to execute a fusing strategy, and the fusing strategy is used to characterize a switching rule between different fusing states;

the second determining module is used for responding to a calling instruction aiming at a preset remote service and determining the current fusing state of the preset remote service;

and the judging module is used for initiating calling according to the current fusing state and judging whether to switch the current fusing state according to the current fusing state, the calling result and the target fusing strategy executed by the target decorator.

10. An electronic device comprising a memory, a processor and a computer program stored on the memory, characterized in that the processor executes the computer program to carry out the steps of the method according to any one of claims 1-8.

11. A computer readable storage medium, on which a computer program is stored, characterized in that the computer program, when being executed by a processor, implements the steps of the method according to any of claims 1-8.

12. A computer program product comprising a computer program, characterized in that the computer program, when being executed by a processor, implements the steps of the method according to any of claims 1-8.