Call request data processing method, device and equipment

Abstract

The invention provides a call request data processing method, device and equipment, and relates to the technical field of data processing, and the method comprises the steps: deploying an access node and a service node in each data center; the service node manages at least one service instance, and synchronizes service instance information of the service instance among the service nodes; the access node receives a call request of a user, determines a target service node according to the queue length of each service node, and forwards the call request to the target service node; the target service node creates a user instance corresponding to the call request and determines user instance information of the user instance; in response to the fact that the service instance managed by the target service node is in an occupied state, the target service node synchronizes user instance information of the user instance to other service nodes to determine a target service instance in an idle state; and the target service node allocates the user instance to the target service instance to process the call request, thereby ensuring service continuity and data consistency.

Description

Technical Field

[0001] This application relates to the field of data processing technology, and in particular to a method, apparatus and device for processing call requests. Background Technology

[0002] Currently, data centers handling call requests employ either a master-slave architecture or a master-multiple-slave architecture. A master-slave architecture consists of one master node and one standby node. A master-multiple-slave architecture involves a hierarchical deployment of one master node and multiple slave nodes. When network anomalies occur between data centers, the inability of each data center to perceive the status of others can easily lead to disordered call request queuing and duplicate allocation of service terminals. After network recovery, service typically needs to be paused to avoid data conflicts, resulting in frequent service interruptions. Therefore, current call request data processing methods suffer from service unavailability after network recovery in multi-data center scenarios, and struggle to simultaneously guarantee data consistency. Summary of the Invention

[0003] This application provides a data processing method, apparatus, and device for call requests to solve one or more problems existing in the related art.

[0004] This application provides a data processing method for call requests. The method includes: deploying at least one access node and at least one service node in each data center; the service node managing at least one service instance and synchronizing the service instance information of the service instance among the service nodes; the access node receiving a user's call request, determining a target service node based on the queuing length of each service node, and forwarding the call request to the target service node; the target service node creating a user instance corresponding to the call request and determining the user instance information of the user instance; in response to a service instance managed by the target service node being in an occupied state, the target service node synchronizing the user instance information of the user instance to other service nodes to determine a target service instance in an idle state; and the target service node assigning the user instance to the target service instance to process the call request.

[0005] According to one embodiment of this application, determining the target service instance in an idle state includes: responding to the fact that the service instance managed by the target service node is in an occupied state, queuing the user instance in the queuing queues of at least two service nodes based on the user instance information to obtain queue information corresponding to each queuing queue; and determining the target service instance in an idle state from the service instances managed by the at least two service nodes based on the queue information corresponding to each queuing queue.

[0006] According to one embodiment of this application, the step of queuing the user instance information in queuing queues of at least two service nodes to obtain queue information corresponding to each queuing queue includes: obtaining user instance information of the user instance; the user instance information includes at least the inbound call time of the call request, the weight of the call request, and the service capability group identifier; the service capability group identifier represents the service type required when the call request performs data processing; calculating the queuing priority score of the user instance based on the user instance information; determining the sequence of the user instance in the queuing queue based on the queuing priority score; and determining the sequence of the user instance in the queuing queue as the queue information.

[0007] According to one embodiment of this application, calculating the queuing priority score of the user instance based on the user instance information includes: calculating the queuing priority score based on the following formula: P(v) = α W(v) + β (T_current - T_in(v)) + γ Q_priority(v) is where P(v) is the queuing priority score, W(v) is the weight of the call request, T_current is the current time, T_in(v) is the inbound time of the call request, Q_priority(v) is the priority coefficient corresponding to the service capability group identifier, and α, β and γ are adjustable coefficients.

[0008] According to one embodiment of this application, the target service node assigns the user instance to the target service instance, comprising: the target service node determining the current state of the user instance; in response to the current state of the user instance indicating that the user instance has not been assigned to other service instances, and the service capability group associated with the service instance is consistent with the service capability group identifier of the user instance, the target service node assigns the user instance to the target service instance to process the call request based on the service terminal corresponding to the target service instance.

[0009] According to one embodiment of this application, the method further includes: the service node sending statistical information to the access node based on a set time interval; the statistical information includes the number of service instances managed by each service node, the queue length of different service capability groups managed by all service nodes, and the earliest idle time of service instances in different service capability groups managed by all service nodes; the earliest idle time represents the earliest time when the service instance currently in an occupied state can receive another call request; the access node, based on the statistical information, selects the service node with the shortest queue length as the target service node.

[0010] According to one embodiment of this application, the method further includes: service instances are managed only by the service node that created the service instance, and user instances are managed only by the service node that created the user instance; the service node managing the service instance stores first instance data of the service instance, the service instance information representing information in the first instance data used for processing the call request; the service node managing the user instance stores second instance data of the user instance, the user instance information representing information in the second instance data used for processing the call request; in response to the access node receiving a check-in request sent by a service terminal, the access node determines a target service node based on the number of service instances in the statistics, and forwards the check-in request to the target service node; the target service node creates the service instance based on the check-in request and determines the first instance data of the service instance; the target service node synchronizes the service instance information in the first instance data to other service nodes.

[0011] According to one embodiment of this application, the method further includes: each service node writing the managed first instance data and second instance data into a local file for storage; in response to the service node restarting, reading the first instance data and second instance data from the local file to restore the state of the service instance and the state of the user instance.

[0012] This application also provides a data processing apparatus for call requests, the apparatus comprising: a deployment module for deploying at least one access node and at least one service node in each data center; the service node managing at least one service instance and synchronizing service instance information of the service instances among the service nodes; a forwarding module for the access node receiving a user's call request, determining a target service node based on the queuing length of each service node, and forwarding the call request to the target service node; a creation module for the target service node creating a user instance corresponding to the call request and determining user instance information of the user instance; a determination module for, in response to a service instance managed by the target service node being in an occupied state, the target service node synchronizing the user instance information of the user instance to other service nodes to determine a target service instance in an idle state; and a processing module for the target service node allocating the user instance to the target service instance to process the call request.

[0013] This application also provides an electronic device, including: at least one processor; and a memory communicatively connected to the at least one processor; wherein the memory stores instructions executable by the at least one processor, the instructions being executed by the at least one processor to enable the at least one processor to perform the method of the above-described embodiments.

[0014] The method in this application embodiment deploys at least one access node and at least one service node in each data center. The service node manages at least one service instance and synchronizes the service instance information of the service instances among the service nodes. The access node receives a user's call request, determines a target service node based on the queue length of each service node, and forwards the call request to the target service node. The target service node creates a user instance corresponding to the call request and determines the user instance information of the user instance. In response to a service instance managed by the target service node being in an occupied state, the target service node synchronizes the user instance information of the user instance to other service nodes to determine target service instances in an idle state. The target service node assigns the user instance to the target service instance to process the call request. In a multi-data center scenario, this application enables each node to independently process services during network anomalies, ensures continuous service availability after network recovery, and guarantees data consistency.

[0015] It should be understood that the teachings of this application are not required to achieve all the beneficial effects described above, but rather that a specific technical solution can achieve a specific technical effect, and other embodiments of this application can also achieve beneficial effects not mentioned above. Attached Figure Description

[0016] The above and other objects, features, and advantages of exemplary embodiments of this application will become readily apparent upon reading the following detailed description with reference to the accompanying drawings. Several embodiments of this application are illustrated in the drawings by way of example and not limitation, in which:

[0017] In the accompanying drawings, the same or corresponding reference numerals indicate the same or corresponding parts.

[0018] Figure 1 A schematic diagram of the processing flow of the data processing method for call requests provided in an embodiment of this application is shown; Figure 2 This illustration shows an application scenario diagram of the data processing method for call requests provided in an embodiment of this application; Figure 3 This illustration shows an optional schematic diagram of a data processing apparatus for call requests provided in an embodiment of this application; Figure 4 A schematic diagram of the composition structure of the electronic device provided in the embodiments of this application is shown. Detailed Implementation

[0019] To make the objectives, features, and advantages of this application more apparent and understandable, the technical solutions in the embodiments of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, and not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0020] In the following description, references are made to “some embodiments,” which describe a subset of all possible embodiments. However, it is understood that “some embodiments” may be the same subset or different subsets of all possible embodiments and may be combined with each other without conflict.

[0021] In the following description, the terms "first" and "second" are used merely to distinguish similar objects and do not represent a specific ordering of objects. It is understood that "first" and "second" may be interchanged in a specific order or sequence where permitted, so that the embodiments of this application described herein can be implemented in an order other than that illustrated or described herein.

[0022] Unless otherwise defined, all technical and scientific terms used herein have the same meaning as commonly understood by one of ordinary skill in the art to which this application belongs. The terminology used herein is for the purpose of describing embodiments of this application only and is not intended to limit this application.

[0023] The processing flow of the call request data processing method provided in the embodiments of this application will be described. See also Figure 1 , Figure 1 This is a schematic diagram of the data processing method for call requests provided in the embodiments of this application. Figure 1 , will combine Figure 1 Steps S101-S105 are explained below.

[0024] Step S101: Deploy at least one access node and at least one service node in each data center; the service node manages at least one service instance and synchronizes the service instance information of the service instance among the service nodes.

[0025] In some embodiments, an access node may include: AcdEntry (Call Center Entry Service). AcdEntry supports distributed deployment. An access node can be used to: receive user call requests, determine the target service node based on the queuing length of each service node, and forward the call request to the target service node. An access node can also be used to: receive service instance check-in requests, determine the target service node based on the number of service instances managed by each service node, and forward the check-in request to the target service node. A service node may include: AcdServer (Call Center Business Management Service Node). A service node can be used to: create and manage user instances and service instances, manage the status of user instances and service instances in the service node, maintain queuing queues, and synchronize data with other service nodes. A service instance can be used to characterize the presence status of a service terminal in a service node. A user instance can be used to characterize the presence status of a call request in a service node. Service instance information may include: service instance identifier, service instance status, service capability group identifier, earliest idle time, service instance associated queue, and the address of the service node it resides in. A data center may include a call center. A data center can be used to deploy access nodes and service nodes. This application embodiment does not limit the specific number of data centers, access nodes, and service nodes.

[0026] In step S102, the access node receives the user's call request, determines the target service node based on the queue length of each service node, and forwards the call request to the target service node.

[0027] In some embodiments, a user can be a guest initiating a call request and waiting for service access. The call request may include a telephone or audio / video connection request. The call request may trigger the user's calling device to establish a communication link with a service terminal in the call center. The queue length may include the number of user instances waiting to be assigned a service instance in the service node's queue. The service terminal may include agent terminals in the call center.

[0028] Step S103: The target service node creates a user instance corresponding to the call request and determines the user instance information of the user instance.

[0029] In some embodiments, the target service node can manage the status of the created user instances, specifically by determining the status of the user instance through its corresponding heartbeat information. User instance information may include: a unique user identifier, call time, weight value, service capability group identifier, queuing time, queue identifier, and the address of the service node it resides in. The service capability group identifier characterizes the type of service required when processing data for a call request.

[0030] In step S104, in response to the fact that the service instance managed by the target service node is in an occupied state, the target service node synchronizes the user instance information of the user instance to other service nodes to determine the target service instance in an idle state.

[0031] In step S105, the target service node assigns the user instance to the target service instance to handle the call request.

[0032] In some embodiments, an occupied state can represent a service instance being temporarily unable to receive new call requests. An idle state can represent a service instance being able to receive new call requests. Other service nodes may include service nodes other than the target service node. Other service nodes may synchronize data with the target service node. After confirming that a user instance has not been allocated, the target service node allocates the user instance to the returned target service instance, establishes a communication link between the user instance and the service terminal corresponding to the target service instance, and then the service terminal corresponding to the target service instance processes the user's call request.

[0033] As an example, a user initiates a video customer service call request through a mobile application, which is sent to access node A. Access node A queries its local cached statistics and determines that the queue length of service node X is 3, and the queue length of service node Y is 5. Therefore, it forwards the call request to service node X, which has the shorter queue length. Upon receiving the call request, service node X creates a corresponding user instance 1, records the user's identity information, call timestamp, and the service capability group identifier G1 corresponding to the "video customer service" service type, and calculates the initial priority score. Service node X manages service instances including service instance 1 and service instance 2. It determines that service instance 1 is currently occupied processing other users, while service instance 2, although idle, is associated with service capability group G2 instead of G1. Therefore, there is no matching idle service instance in service node X. Service node X synchronizes the user instance information of user instance 1 to service nodes Y and Z. Service node Y adds user instance 1 to the queue corresponding to capability group identifier G1 based on the received user instance information, and service node Z performs the same operation. At this point, user instance 1 is queued in parallel on all three service nodes. In response to the fact that service instance 3 managed by service node Z is in an idle state and its associated service capability group is G1, matching user instance 1, service node Z sends the allocation result of service instance 3 to user instance 1 to service node X. Upon receiving the allocation result, service node X determines the current state of local user instance 1, confirming that it is still in the queue and has not been allocated by other service nodes. It then establishes a service association between service instance 3 and user instance 1, enabling the service terminal corresponding to service instance 3 to handle video customer service call requests. If service node X determines that user instance 1 has already been allocated by another service node, it sends a rejection response to service node Z, and service node Z controls the allocation of service instance 3 to other user instances in the corresponding queue.

[0034] The method in this application, by deploying access nodes and service nodes in various data centers and processing data based on queuing queue length, adopts a decentralized deployment. All nodes can provide complete capabilities, achieving cross-node scheduling and global load balancing in multi-data center scenarios and eliminating service interruptions caused by master-slave switching. By synchronizing service instance information among multiple service nodes, user instance information can be forwarded to other nodes for parallel queuing when no local resources are available, significantly shortening user waiting time. By calculating queuing priority scores using parameters such as call time and weight, the consistency of queuing order is ensured, enabling unified queuing and resource allocation according to priority. By verifying the consistency of user instance status and service capability groups before allocation, duplicate allocation is effectively avoided and the matching of call requests with service terminals is guaranteed. By binding the management rights of service instances and user instances to the target service node and synchronizing only key information for request forwarding, cross-node communication overhead is reduced and data consistency is guaranteed. In multi-data center scenarios, multiple master nodes will not occur after network disconnection, and there is no need to select a master node after network recovery. Even in the event of network anomalies, the data relay continues to function, ensuring data consistency, improving service availability, and enhancing partition tolerance. By writing instance data to local files and retrieving it upon node restart, service continuity after failures is guaranteed, reducing reliance on external shared storage components (such as other databases).

[0035] In some embodiments, determining the target service instance in an idle state in step S104 may include: in response to the service instance managed by the target service node being in an occupied state, queuing the instance in the queuing queues of at least two service nodes based on the user instance information to obtain the queue information corresponding to each queuing queue; and determining the target service instance in an idle state from the service instances managed by at least two service nodes based on the queue information corresponding to each queuing queue.

[0036] In this embodiment, the occupied state can specifically be: processing a call request, in a call, or in uninterrupted system operation. The idle state can specifically be: not processing any call requests, in a ready-to-wait state, or having completed the previous service and not being assigned a new task. The queuing queue can include: waiting queues divided by service capability groups. The queuing queue can specifically be a set of user instances waiting for service set in each service node, and service instances are allocated to user instances in the queuing queue according to queuing priority. Queue information can include: the sequence of user instances in the queuing queue, the queue length, the number of preceding waiting user instances, and the estimated waiting time. This application embodiment does not limit the specific queue information. The queuing queue of the target service node is parallel to the queuing queues of other service nodes. That is, when there are no available service instances in the target service node, user instance information will simultaneously enter the queuing queues of other service nodes for queuing. All queues calculate a consistent priority score based on a globally unified time. If a user instance matches an idle service instance in any queuing queue and completes the allocation, the target service node will notify other nodes to remove the queuing record of the corresponding user instance, so as to achieve unified scheduling of instances across data centers and avoid duplicate allocation.

[0037] As an example, a user initiates a customer service call request through a user terminal. The customer service call request is forwarded to the target service node X via the access node. The customer service call request corresponds to user instance 1, and user instance 1 corresponds to service capability group identifier G1. The target service node X first determines whether there is an idle service instance with service capability group G1 in the service instances 1 and service instances 2 under its management. If there is, it is assigned to user instance 1; if not, the target service node X synchronizes the user instance information of user instance 1 to service node Z in the same data center and service node Y in a different data center. Based on the user instance information, it is queued simultaneously in the queuing queue corresponding to G1 in service node Y and the queuing queue corresponding to G1 in service node Z. Service node Y has an idle service instance 4 associated with G1, and service node Z also has an idle service instance 3 associated with G1. Based on the feedback from each service node, the target service node X, according to the preset allocation rule, that is, if multiple idle service instances are available, the one in the same data center is given priority, therefore, service instance 3 provided by service node Z is determined as the target service instance.

[0038] In some embodiments, queuing is performed on user instance information in queuing queues of at least two service nodes to obtain queue information corresponding to each queuing queue. This may include: obtaining user instance information; calculating the queuing priority score of the user instance based on the user instance information; determining the sequence of the user instance in the queuing queue based on the queuing priority score; and determining the sequence of the user instance in the queuing queue as queue information.

[0039] In this embodiment, user instance information may include: a unique user identifier, the inbound call time of the call request, the weight value of the call request, a service capability group identifier, queuing time, a queue identifier, and the address of the service node. The service capability group identifier represents the service type required for data processing of the call request. Service types may include: video customer service, voice customer service, text customer service, and complaint handling, etc., and this embodiment does not limit the specific service type. The queuing priority score can represent the urgency of the user instance and serve as the basis for sorting in the queuing queue.

[0040] As an example, after creating user instance M, service node X obtains the corresponding user instance information, including the call time T0, the weight value of the call request, and the service capability group identifier G1. It then synchronizes the user instance information to service nodes Y and Z. After receiving the information, service nodes Y and Z calculate the queuing priority score respectively. Then, service nodes Y and Z query the queuing priority scores of existing user instances in the corresponding G1 queue based on the queuing priority score, determine the sequence position of user instance M and the updated queue length, and define the sequence position and queue length as queue information.

[0041] In some embodiments, calculating the queuing priority score of a user instance based on user instance information may include: The queuing priority score is calculated based on the following formula: P(v) = α W(v) + β (T_current - T_in(v)) + γ Q_priority(v) Where P(v) is the queuing priority score, with lower scores indicating higher priority, or vice versa. W(v) is the weight of the call request, which can be a preset fixed value or a weight dynamically calculated based on business rules. T_current is the current time, which is a globally unified time, meaning that all service nodes in each data center obtain the same current time, and all data centers use a consistent time base when calculating priorities. T_in(v) is the inbound call time of the call request, Q_priority(v) is the priority coefficient corresponding to the service capability group identifier, and α, β, and γ are adjustable coefficients used to represent the degree of influence of different factors on queuing priority.

[0042] In some embodiments, the target service node in step S105 assigns the user instance to the target service instance, including: the target service node determining the current state of the user instance; in response to the current state of the user instance indicating that the user instance has not been assigned to other service instances, and the service capability group associated with the service instance is consistent with the service capability group identifier of the user instance, the target service node assigns the user instance to the target service instance to process the call request based on the service terminal corresponding to the target service instance.

[0043] In this embodiment, the current state may include states such as: queued, allocated, serving, ended, and abandoned. This embodiment does not limit the specific current state. Not being allocated to another service instance can mean that the user instance's current state is marked as queued and has not received allocation from other service nodes. Service capability groups may include: video customer service group, voice customer service group, and complaint handling group, etc. This embodiment does not limit the specific service capability group. Service capability groups can characterize the types of service capabilities possessed by a service instance. The service terminal can be used by customer service to receive user call requests and perform corresponding business operations.

[0044] As an example, after service node Z identifies service instance 1 as a candidate target, it sends an allocation request to service node X. Service node X, as the target service node, first determines the current status of user instance M. If the current status is "queued" and the service capability group G1 associated with service instance 1 matches the service capability group identifier G1 of user instance M, service node X updates the current status of user instance M to "allocated" and allocates user instance M to the target service instance 1. After receiving confirmation, service node Z establishes the association between service instance 1 and user instance M, enabling customer service representatives to process call requests corresponding to user instance M through the service terminal corresponding to service instance 1.

[0045] In some embodiments, the data processing method for call requests may further include: the service node sending statistical information to the access node based on a set time interval; and the access node using the statistical information to select the service node with the shortest queue length as the target service node.

[0046] In this embodiment, the statistical information may include the number of service instances managed by each service node, the queue length of different service capability groups managed by all service nodes, and the earliest idle time of service instances in different service capability groups managed by all service nodes. The earliest idle time can characterize the earliest time when a service instance currently in an occupied state can receive another call request.

[0047] As an example, service node A and service node B, deployed in data center 1, send statistical information to access node E, also deployed in data center 1, at set time intervals of 5 seconds. The statistical information sent by service node A may include the number of service instances managed by service node A (50), the queue length of service capability group G1 (10), and the earliest idle time of service instances in service capability group G1 (10:05). The statistical information sent by service node B may include the number of service instances managed by service node B (40), the queue length of service capability group G1 (5), and the earliest idle time of service instances in service capability group G1 (10:03). Access node E receives and stores the statistical information reported by each service node. When a call request for a new service capability group G1 needs to be routed, access node E compares the queue length of service node A (10) with the queue length of service node B (5) based on the statistical information, and selects service node B with the shortest queue length as the target service node.

[0048] In some embodiments, the data processing method for a call request may further include: in response to an access node receiving a sign-in request sent by a service terminal, the access node determines a target service node based on the number of service instances in the statistics and forwards the sign-in request to the target service node; the target service node creates a service instance based on the sign-in request and determines the first instance data of the service instance; the target service node synchronizes the service instance information in the first instance data to other service nodes.

[0049] In this embodiment, service instances are managed only by the service nodes that created the service instances, and user instances are managed only by the service nodes that created the user instances. The service nodes that manage service instances store first instance data for the service instances, and the service instance information represents the information in the first instance data used for processing call requests. The service nodes that manage user instances store second instance data for the user instances, and the user instance information represents the information in the second instance data used for processing call requests. The first instance data may include: complete configuration information of the service instance, status history, performance indicator data, heartbeat information of the service instance, associated service capability group information, check-in timestamp, and address information. This embodiment does not limit the specific first instance data. The service instance information may be the service instance identifier, service instance status, service capability group identifier, and service node address information extracted from the first instance data. The service instance information is the key information in the first instance data used for processing call requests. The second instance data may include: complete configuration information of the user instance, allocation history, heartbeat information of the user instance, user identity information, and service capability group identifier information. This embodiment does not limit the specific second instance data. The user instance information may be the user identifier, call time, service type, weight value, service capability group identifier, queuing time, and service node address information extracted from the second instance data. User instance information is crucial for processing call requests within the second instance data. A check-in request can be used by the service terminal to initiate registration with the access node, thereby registering the service terminal with the corresponding target service node.

[0050] As an example, the service terminal initiates a check-in request to access node A. Access node A queries statistics and determines that service node X manages 15 service instances, service node Y manages 22, and service node Z manages 18. Based on the number of service instances, service node X is determined to be the target service node with the lightest load, and the check-in request is forwarded to service node X. Service node X receives the check-in request, creates service instance S based on the check-in request, and generates corresponding first instance data. Service node X extracts service instance information from the first instance data and synchronizes the service instance information to service nodes Y and Z.

[0051] In some embodiments, the data processing method for call requests may further include: each service node writing the managed first instance data and second instance data into a local file for storage; and in response to a service node restart, reading the first instance data and second instance data from the local file to restore the state of the service instance and the state of the user instance.

[0052] As an example, local files can be disk storage files or database storage files. Local files can retain instance data in the service node after a power outage and restart. A service node restart can be a restart after a server failure recovery. During operation, each service node writes the managed first and second instance data to local files for storage in real time. When a failure occurs, in response to a service node restart, the service node reads the previously written first and second instance data from the local files, parses the read data, and restores the state of the service instances and user instances. The recovered service node can then continue processing unfinished call requests.

[0053] refer to Figure 2 This application provides an application scenario diagram of a data processing method for call requests, which is applied to a multi-data center scenario for call center visitor queuing priority and agent allocation scheduling.

[0054] In two data centers, DataCenter_1 and DataCenter_2, AcdEntry and AcdServer nodes are deployed respectively. The AcdEntry node manages queue count statistics and agent idle time statistics, while the AcdServer node manages queues and agent management. When a visitor terminal initiates a call request, the request first reaches the corresponding AcdEntry node in the data center. Based on the statistics reported by each AcdServer, the AcdEntry node selects the AcdServer node with the shortest queue and forwards the request. The selected AcdServer node creates a visitor instance and registers it in the corresponding queue. Simultaneously, it attempts to assign the visitor to a local agent managed by the node. If no local agent is available, the visitor instance's key information is synchronized to AcdServer nodes in other data centers. These AcdServer nodes queue the visitor based on the key information and search for available agents. Once an agent is found, the allocation result is returned to the AcdServer node that created the visitor instance. The AcdServer node verifies the visitor's status and confirms the allocation, ultimately establishing a communication connection between the visitor and an agent. Agents can sign in to AcdServer nodes in any data center. In the diagram, "visitor" represents a user terminal used to make a call to the call center. The seats in the diagram can be service terminals controlled by customer service representatives.

[0055] Taking the check-in process of Agent A and Agent B as an example, Agent A initiates a check-in request to the AcdEntry_A node in DataCenter_1. The AcdEntry_A node forwards the check-in request to AcdServer_A based on the current agent count in the statistics. AcdServer_A creates instance information for Agent A and stores the first instance data. Then, AcdServer_A determines the key information of Agent A used to handle the call request from the first instance data. AcdServer_A forwards the key information of Agent A to AcdServer_B in DataCenter_2. Agent B initiates a check-in request to the AcdEntry_B node in DataCenter_2. The AcdEntry_B node forwards the check-in request to AcdServer_B based on the statistics. AcdServer_B creates instance information for Agent B and stores the first instance data. Then, AcdServer_B determines the key information of Agent B used to handle the call request from the first instance data. At this point, the AcdServer nodes in both data centers can determine the agent status of each other.

[0056] Taking visitor A's call process as an example, visitor A initiates a call request to the AcdEntry_A node in DataCenter_1. Based on the statistics of each AcdServer, AcdEntry_A selects the AcdServer_A with the shortest queue as the target service node and forwards the call request. AcdServer_A creates a second instance of visitor A's data and calculates the queuing priority score to determine the key information of visitor A to handle the call request. If agent A is idle and the service capability group identifier matches, AcdServer_A directly assigns visitor A to agent A. If agent A is busy, AcdServer_A synchronizes visitor A's key information to AcdServer_B in DataCenter_2. Visitor A queues in AcdServer_B's queue. AcdServer_B finds an idle agent B and assigns it to visitor A. AcdServer_B returns the assignment result to AcdServer_A. AcdServer_A confirms the assignment result after determining that visitor A is in an unassigned state. Finally, visitor A's call request is handled by agent B.

[0057] The exemplary structure of the software modules included in the call request data processing apparatus 90 provided in the embodiments of this application will be further described below. In some embodiments, such as Figure 3 As shown, the data processing device 90 for call requests may include: Deployment module 901 is used to deploy at least one access node and at least one service node in each data center; the service node manages at least one service instance and synchronizes the service instance information of the service instance between the service nodes; The forwarding module 902 is used for the access node to receive the user's call request, determine the target service node according to the queue length of each service node, and forward the call request to the target service node; Module 903 is created to create a user instance corresponding to a call request on the target service node and to determine the user instance information of the user instance. The determination module 904 is used to respond to the fact that the service instance managed by the target service node is in an occupied state. The target service node synchronizes the user instance information of the user instance to other service nodes in order to determine the target service instance in an idle state. Processing module 905 is used by the target service node to allocate user instances to target service instances to process call requests.

[0058] It should be noted that the description of the apparatus in this application embodiment is similar to the description of the method embodiment above, and has similar beneficial effects as the method embodiment, therefore, it will not be repeated. For any technical details not covered in the call request data processing apparatus provided in this application embodiment, please refer to... Figures 1 to 3 The meaning is understood in accordance with the description of any of the accompanying drawings.

[0059] According to embodiments of this application, this application also provides an electronic device and a non-transitory computer-readable storage medium.

[0060] Figure 4 A schematic block diagram of an example electronic device 800 that can be used to implement embodiments of this application is shown. The electronic device is intended to represent various forms of digital computers, such as laptop computers, desktop computers, workstations, personal digital assistants, servers, blade servers, mainframe computers, and other suitable computers. The electronic device may also represent various forms of mobile devices, such as personal digital processors, cellular phones, smartphones, wearable devices, and other similar computing devices. The components shown herein, their connections and relationships, and their functions are merely illustrative and are not intended to limit the implementation of the application described and / or claimed herein.

[0061] like Figure 4As shown, the electronic device 800 includes a computing unit 801, which can perform various appropriate actions and processes based on a computer program stored in a read-only memory (ROM) 802 or a computer program loaded from a storage unit 808 into a random access memory (RAM) 803. The RAM 803 may also store various programs and data required for the operation of the electronic device 800. The computing unit 801, ROM 802, and RAM 803 are interconnected via a bus 804. An input / output (I / O) interface 805 is also connected to the bus 804.

[0062] Multiple components in electronic device 800 are connected to I / O interface 805, including: input unit 806, such as keyboard, mouse, etc.; output unit 807, such as various types of displays, speakers, etc.; storage unit 808, such as disk, optical disk, etc.; and communication unit 809, such as network card, modem, wireless transceiver, etc. Communication unit 809 allows electronic device 800 to exchange information / data with other devices through computer networks such as the Internet and / or various telecommunications networks.

[0063] The computing unit 801 can be a variety of general-purpose and / or special-purpose processing components with processing and computing capabilities. Some examples of the computing unit 801 include, but are not limited to, a central processing unit (CPU), a graphics processing unit (GPU), various special-purpose artificial intelligence (AI) computing chips, various computing units running machine learning model algorithms, a digital signal processor (DSP), and any suitable processor, controller, microcontroller, etc. The computing unit 801 performs the various methods and processes described above, such as the call request data processing method. For example, in some embodiments, the call request data processing method can be implemented as a computer software program tangibly contained in a machine-readable medium, such as storage unit 808. In some embodiments, part or all of the computer program can be loaded and / or installed on the electronic device 800 via ROM 802 and / or communication unit 809. When the computer program is loaded into RAM 803 and executed by the computing unit 801, one or more steps of the call request data processing method described above can be performed. Alternatively, in other embodiments, the computing unit 801 can be configured to perform the call request data processing method by any other suitable means (e.g., by means of firmware).

[0064] Various embodiments of the systems and techniques described above herein can be implemented in digital electronic circuit systems, integrated circuit systems, field-programmable gate arrays (FPGAs), application-specific integrated circuits (ASICs), application-specific standard products (ASSPs), systems-on-a-chip (SoCs), payload-programmable logic devices (CPLDs), computer hardware, firmware, software, and / or combinations thereof. These various embodiments may include implementations in one or more computer programs that can be executed and / or interpreted on a programmable system including at least one programmable processor, which may be a dedicated or general-purpose programmable processor, capable of receiving data and instructions from a storage system, at least one input device, and at least one output device, and transmitting data and instructions to the storage system, the at least one input device, and the at least one output device.

[0065] The program code used to implement the methods of this application may be written in any combination of one or more programming languages. This program code may be provided to a processor or controller of a general-purpose computer, special-purpose computer, or other programmable data processing device, such that when executed by the processor or controller, the functions / operations specified in the flowcharts and / or block diagrams are implemented. The program code may be executed entirely on a machine, partially on a machine, as a standalone software package partially on a machine and partially on a remote machine, or entirely on a remote machine or server.

[0066] In the context of this application, a machine-readable medium can be a tangible medium that may contain or store a program for use by or in conjunction with an instruction execution system, apparatus, or device. A machine-readable medium can be a machine-readable signal medium or a machine-readable storage medium. Machine-readable media can be, but is not limited to, electronic, magnetic, optical, electromagnetic, infrared, or semiconductor systems, apparatus, or devices, or any suitable combination of the foregoing. More specific examples of machine-readable storage media include electrical connections based on one or more wires, portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), optical fibers, portable compact disk read-only memory (CD-ROM), optical storage devices, magnetic storage devices, or any suitable combination of the foregoing.

[0067] To provide interaction with a user, the systems and techniques described herein can be implemented on a computer having: a display device for displaying information to the user (e.g., a CRT (cathode ray tube) or LCD (liquid crystal display) monitor); and a keyboard and pointing device (e.g., a mouse or trackball) through which the user provides input to the computer. Other types of devices can also be used to provide interaction with the user; for example, feedback provided to the user can be any form of sensory feedback (e.g., visual feedback, auditory feedback, or tactile feedback); and input from the user can be received in any form (including sound input, voice input, or tactile input).

[0068] The systems and technologies described herein can be implemented in computing systems that include backend components (e.g., as a data server), or computing systems that include middleware components (e.g., an application server), or computing systems that include frontend components (e.g., a user computer with a graphical user interface or web browser through which a user can interact with implementations of the systems and technologies described herein), or any combination of such backend, middleware, or frontend components. The components of the system can be interconnected via digital data communication of any form or medium (e.g., a communication network). Examples of communication networks include local area networks (LANs), wide area networks (WANs), and the Internet.

[0069] Computer systems can include clients and servers. Clients and servers are generally located far apart and typically interact via communication networks. Client-server relationships are created by computer programs running on the respective computers and having a client-server relationship with each other. Servers can be cloud servers, servers in distributed systems, or servers incorporating blockchain technology.

[0070] It should be understood that the various forms of processes shown above can be used to rearrange, add, or delete steps. For example, the steps described in this application can be executed in parallel, sequentially, or in different orders, as long as the desired result of the technical solution disclosed in this application can be achieved, and this is not limited herein.

[0071] The above description is merely a specific embodiment of this application, but the scope of protection of this application is not limited thereto. Any variations or substitutions that can be easily conceived by those skilled in the art within the scope of the technology disclosed in this application should be included within the scope of protection of this application. Therefore, the scope of protection of this application should be determined by the scope of the claims.

Claims

1. A data processing method for a call request, characterized in that, The method includes: At least one access node and at least one service node are deployed in each data center; the service node manages at least one service instance and synchronizes the service instance information of the service instance among the service nodes; The access node receives a user's call request, determines the target service node based on the queue length of each service node, and forwards the call request to the target service node. The target service node creates a user instance corresponding to the call request and determines the user instance information of the user instance; In response to the fact that the service instance managed by the target service node is in an occupied state, the target service node synchronizes the user instance information of the user instance to other service nodes to identify the target service instance in an idle state. The target service node assigns the user instance to the target service instance to process the call request.

2. The method according to claim 1, characterized in that, The determination of the target service instance in an idle state includes: In response to the fact that the service instance managed by the target service node is in an occupied state, the user instance is queued in the queuing queues of at least two service nodes based on the user instance information, and the queue information corresponding to each queuing queue is obtained. Based on the queue information corresponding to each queue, a target service instance that is in an idle state is determined from the service instances managed by the at least two service nodes.

3. The method according to claim 2, characterized in that, The process of queuing users based on their instance information in queues at at least two service nodes to obtain queue information for each queue includes: Obtain user instance information of the user instance; the user instance information includes at least the call time of the call request, the weight of the call request, and the service capability group identifier; the service capability group identifier represents the service type required when the call request performs data processing; Based on the user instance information, calculate the queuing priority score of the user instance; Based on the queuing priority score, the sequence of the user instance in the queuing queue is determined; The sequence of the user instance in the queuing queue is determined as the queue information.

4. The method according to claim 3, characterized in that, The step of calculating the queuing priority score of the user instance based on the user instance information includes: The queuing priority score is calculated based on the following formula: P(v) = α W(v) + β (T_current - T_in(v)) + γ Q_priority(v) Where P(v) is the queuing priority score, W(v) is the weight of the call request, T_current is the current time, T_in(v) is the inbound time of the call request, Q_priority(v) is the priority coefficient corresponding to the service capability group identifier, and α, β and γ are coefficients that can be adjusted.

5. The method according to claim 1, characterized in that, The target service node allocates the user instance to the target service instance, including: The target service node determines the current state of the user instance; In response to the current state of the user instance indicating that the user instance has not been assigned to another service instance, and the service capability group associated with the service instance is consistent with the service capability group identifier of the user instance, the target service node assigns the user instance to the target service instance to process the call request based on the service terminal corresponding to the target service instance.

6. The method according to claim 1, characterized in that, The method further includes: The service node sends statistical information to the access node at set time intervals; The statistical information includes the number of service instances managed by each service node, the queue length of different service capability groups managed by all service nodes, and the earliest idle time of service instances in different service capability groups managed by all service nodes; the earliest idle time represents the earliest time when the service instance currently in an occupied state can receive another call request. Based on the statistical information, the access node selects the service node with the shortest queue length as the target service node.

7. The method according to claim 6, characterized in that, The method further includes: Service instances are managed only by the service nodes that created the service instances, and user instances are managed only by the service nodes that created the user instances; the service nodes that manage the service instances store first instance data of the service instances, and the service instance information represents the information in the first instance data used to process the call request; the service nodes that manage the user instances store second instance data of the user instances, and the user instance information represents the information in the second instance data used to process the call request. In response to the access node receiving a sign-in request from a service terminal, the access node determines a target service node based on the number of service instances in the statistics and forwards the sign-in request to the target service node. The target service node creates the service instance based on the check-in request and determines the first instance data of the service instance; The target service node synchronizes the service instance information in the first instance data to other service nodes.

8. The method according to claim 7, characterized in that, The method further includes: Each service node writes the data of the first and second instances it manages to a local file for storage; In response to the restart of the service node, the first instance data and the second instance data are read from the local file to restore the state of the service instance and the state of the user instance.

9. A data processing apparatus for a call request, characterized in that, The device includes: The deployment module is used to deploy at least one access node and at least one service node in each data center; the service node manages at least one service instance and synchronizes the service instance information of the service instance among the service nodes; The forwarding module is used by the access node to receive the user's call request, determine the target service node according to the queue length of each service node, and forward the call request to the target service node. A creation module is used by the target service node to create a user instance corresponding to the call request and to determine the user instance information of the user instance; The determination module is used to respond to the fact that the service instance managed by the target service node is in an occupied state, and the target service node synchronizes the user instance information of the user instance to other service nodes to determine the target service instance in an idle state. The processing module is used by the target service node to allocate the user instance to the target service instance to process the call request.

10. An electronic device, characterized in that, include: At least one processor; And a memory communicatively connected to the at least one processor; wherein 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-8.

Images