WO2004051934A1

WO2004051934A1 - A method of realizing protecting switching on packet double-ring network

Info

Publication number: WO2004051934A1
Application number: PCT/CN2003/001038
Authority: WO
Inventors: Zhixiang Wen; Jian Li
Original assignee: Huawei Technologies Co., Ltd.
Priority date: 2002-12-04
Filing date: 2003-12-04
Publication date: 2004-06-17
Also published as: CN1505303A; CN1266869C; AU2003289639A1

Abstract

A method of realizing protecting switching on packet double-ring network, the method makes two sides of the same node of the ring network run status mechanism respectively, uses 'side' not 'node' as basic running unit, and expands therein status of the nodes from three kinds to eight kinds, two sides of each node disposes various status respectively, comprises steps: a, completes initialization of one side of the node on double-ring, sets the physical status and logical status of the side; b, according to the status of the side, the side sends request punctually to neighboring node and neighboring side, at the same time, the side receives the request coming from local side neighboring side and neighboring node; c, the side disposes the received new request ,and according to the disposed result, completes the switching of logical status and physical status, and return to step: b. Using the method of present invention, multipoint, simple point and multi-failure intelligent protecting switching can be achieved on packet double-ring network simply rapidly and expediently.

Description

Method for realizing protection switching on packet double-ring network

The present invention relates to the technical field of packet ring networks, and in particular, to a method for implementing protection switching on a packet dual ring network. Background of the invention

With the gradual popularization and application of packet networks, users have increasingly demanded network reliability. Figure 1 is a schematic diagram of the structure of a dual ring network. As shown in Figure 1, each node on the ring network is divided into a side and b side. It is used to receive and send signals on the outer ring, and side b is used to receive and send signals on the inner ring. The neighboring node on the side of the node on the ring network is a node adjacent to that side, and the next node on the side of the node on the ring network is the This side is adjacent to the adjacent nodes. For example: Node A is divided into side a and b, and node B is divided into side a and sum! ? Side, node B and node D are neighboring nodes of node A, node D is a neighboring node of node A and side a, node B is a neighboring node of node A and b side, and the next node on node a and side a is node B and node A The next node on the b side is the D node. Each node on the dual ring network is connected by two fibers with different directions. When one fiber fails, the node can switch protection and switch the signal to another fiber, which provides the mutual protection between the dual rings basis. When single-point and multi-point faults occur on the dual ring network, a mechanism is required to process and analyze the faults occurring on H, and automatically complete the switchover of the optical fiber, so as to complete the automatic protection of online services.

There are the following types of requests on the network, in order of priority from high to low: a. When a node on the ring network is configured to force the current node to switch, a forced switch request (FS, Force Switch) occurs;

b. When a signal failure fault occurs on the fiber, a signal failure request (SF, Signal Failure);

c. When a signal attenuation fault occurs on the optical fiber, a signal attenuation request (SD, Signal Degrade) occurs;

d. When the nodes on the ring network are configured so that the current node is switched, a manual switch request (MS, Manual Switch) occurs. The MS request has the same function as the FS, but has a lower priority.

e. After the fault of the node on the ring network is cleared, the node needs to wait for a period of time before the node returns to the non-switching state to avoid node oscillation. The fault request during this time is referred to as a wait to restore request (WTR, Wait To Restore);

f. A request that has not failed is called an empty request, which is represented by IDLE.

FS, SF, SD, MS, and WTR in the above requests are fault requests, and IDLE are non-fault requests.

There are similar technologies in RFC2892 and IEEE802.17 draft to complete the intelligent protection switching of the network. The implementation method is as follows:

The status of each node on the packet dual ring network is physically divided into a switched state and a non-switched state; logically divided into: 1. an idle state; 2. a switched state; 3. a pass-through state; 4. a state waiting to be restored. Wherein, when the logic is in the idle state and the passing state, the corresponding physical state is the non-switching state; when the logic is in the switching state and the waiting for recovery state, the corresponding physical state is the switching state.

In a dual ring network, if a request sent by a node can only reach a node adjacent to the node, the request is a short path request; if a request issued by a node can not only reach the node adjacent to the node, it can also be crossed If neighboring nodes reach other nodes, the request is a long path request.

Each node on the packet dual ring network is in an idle state after initialization. In this state, the node is in a protection-preparing handover, and the current node sends a null request to a neighboring node. When a paragraph The optical fiber is faulty. It is assumed here that the optical fiber between node A and node B in Figure 1 fails. Then node A receives a local fault request, and then a protection switchover occurs. It is logically in the switching state and sends a short message to node B. The path request sends a long path request to the D node. When node B receives a short path non-empty request from node A, node B physically switches and enters the switching state logically; if node A receives a local fault clearing request, node A physically returns to the non-switched state At the same time, it logically enters the idle state and sends a short path empty request to node B; node B receives the short path empty request from node A and physically recovers to the non-switching state while logically entering the idle state.

The D node in the idle state receives the long path request from the neighboring A node, and then enters the through state logically. When the D node is in the passing state, it indicates that other nodes on the ring have switched protection. The D node has no protection switch, but only passes through the node as switching information. The D node forwards the received long path message to the next node. If node D receives a null request from node A, it logically enters the idle state. If a local request is detected and the priority of the local request is greater than the current request, or a short path request is received and the priority of this request is greater than the current request, Then, the node D is switched, and at the same time, the node D logically enters a switching state, and the current request is a request currently being processed.

In accordance with the method described above, each node on the ring network processes the local request received by the current node and the request sent by the neighboring node, the switch of its physical state, the switch of the logical state, and the request between neighboring nodes. Send, the nodes coordinate with each other to complete the automatic switching of services on the entire ring network, thereby ensuring the intelligent protection of ring network services.

The disadvantages of the foregoing prior art are: The method described in the prior art uses a node as the most basic processing unit, and treats both sides of the node as a state to process, but the state on both sides of each node on the dual ring network They are completely the same, and their processing of messages and the messages that should be sent are not exactly the same. Therefore, the methods described in the prior art have many complexities when processing and sending messages. The processing speed is slow and it is difficult to implement network faults at the same time. Node cut And intelligent protection of services on the network; in addition, there is only one logical switching state in the prior art, but each side of the node in the switching state, such as the side receiving the fault request, the side adjacent to the side, and the receiving fault The status of the neighboring nodes on the requesting side is not exactly the same. Their processing of messages and the messages that should be sent are not completely the same. If they are regarded as a state, they will be processed and sent. Increase the complexity of processing; In addition, in the prior art, there is only one waiting-to-recovery state, but the actual status of each side of the node in the waiting-to-recovery state is not completely consistent. Their processing of messages and messages that should be sent are also It is not completely consistent. If it is regarded as a state, it will increase the processing complexity when processing messages and sending messages, and the prior art does not give how to switch between waiting for recovery and other states. In this case, if a piece of fiber on the network is in an unstable state, And clearing a fault occurs, it will stop and the switching of the switching node recovery and fiber connected to this section, so that the entire network will be in a constantly being repeated oscillation. SUMMARY OF THE INVENTION The purpose of the present invention is to overcome the shortcomings of the prior art, and propose a method for implementing protection switching on a packet dual-ring network, so that multiple points, single points, and multiple faults can be easily, quickly, and conveniently implemented on the packet dual-ring network. Intelligent protection switching.

The object of the present invention is achieved as follows:

A method for implementing protection switching on a packet dual-ring network. The method runs state machines on both sides of the same node. The method includes the following steps:

a. Complete the initialization of the node side of the dual ring network, and set the logical state and physical state of the node;

b. The side periodically sends requests to the side neighbor node and the side neighbor side according to the state in which it is located, and at the same time, the side receives requests from the side, the side neighbor side, and the side neighbor node; c. The side processes the received new request, completes the switching of the logical state and the physical state according to the processing result, and returns to step b.

The logical state is any one of an idle state, a local switching state, a short path switching state, a neighboring switching state, a through state, an active waiting for recovery state, a short path waiting for recovery state, or a neighboring waiting recovery state.

One side of the node on the ring network is initialized, the logical state of the side is initialized to an idle state, the physical state is initialized to a non-switched state, and the current request is initialized to an empty request. In step b, the node side is timed. Send a first request to a neighboring node and a neighboring side.

One side of a node on the ring network is logically in a local switching state, and when it is physically in a switching state, in step b: the node side sends a second request to a neighboring node at regular intervals, and a third request is sent to the neighboring side. request.

One side of the node on the ring network is logically in a short path switching state, and when it is physically in the switching state, in step b: the node side periodically sends a fourth request to the neighboring node, and sends a third request to the neighboring side. request.

One side of a node on the ring network is logically in a neighboring switching state and physically is in a switching state, in step b: the node side sends a third request to a neighboring node at a regular time.

When one side of a node on the ring network is logically in a through state and is physically in a non-switching state, in step b: the node side does not send any request, and when the side receives a long path request, Forward the request to the next node.

One side of the node on the ring network is logically in an active waiting state for recovery, and when it is physically in a switching state, in step b: the node side periodically sends a fifth request to a neighboring node, and sends a sixth to the neighboring side. request.

One side of the node on the ring network is logically in a short path waiting for recovery state, and when it is physically in a switching state, in step b: the node side periodically sends a seventh request to a neighboring node, and sends a first request to the neighboring side. Six requests. One side of the node on the ring network is logically in a state of waiting for recovery, and when it is physically in a switching state, in step b: the node side periodically sends a sixth request to the neighboring node.

The first request is a [IDLE, 0, S] request, the second request is a [R, W, S] request, the third request is a [R, W, L] request, and the fourth request is a [IDLE, W , S] request, the fifth request is [WTR, W, S], the sixth request is [WTR, W, L], and the seventh request is [IDLE, W, S]

In the first to seventh request triples, the first element indicates the type of the transmission request, IDLE indicates an empty request, WTR indicates a waiting for recovery request, and R indicates a current request. The current request is a forced switch request (FS) and the signal is invalid. Any one of a request (SF), a signal attenuation request (SD), a manual switch request (MS), a wait for recovery request (WTR), or an empty request (IDLE); the second element indicates that the side sending this request is physically Whether it is in a handover state, W means in a handover state, 0 means in a non-handover state; the third element indicates whether the request is sent as a long path request or a short path request, L indicates a long path request, and S indicates a short path request.

The requests that occur on the above network in order of priority are: FS, SF, SD,

MS, WTR, IDLE.

The step c is: the node side judges and processes according to the received priority of the new request and the priority of the request currently being processed, puts a request that cannot be currently processed into a pending queue, and according to the processing result Complete the switch between the logical state and the physical state, and return to step b.

The method for implementing protection switching on a packet dual-ring network proposed by the present invention is characterized in that two sides of the ring network are completely separated, and two sides of the same node are switched respectively, and "side" instead of "node" is the basic operating unit. Increase the number of states to eight, extend the original switching state to the local switching state, the short path switching state, and the neighboring switching state; expand the original waiting recovery state to the active waiting recovery state, the short path waiting to recover state, and the neighboring side Waiting Recovery status. On both sides of each node on the ring network, after receiving the fault detected on the local side, they perform corresponding state transitions and switching actions, and simultaneously send messages to the neighboring side and the nodes. After receiving the message, the neighboring side and the neighboring node do the same, and then send the message to other nodes. In this way, through the cooperative processing of messages by all nodes on the entire network, the switching of the faulty nodes on the network and the intelligent protection of services on the network are finally completed. By using the method of the present invention, intelligent protection switching of multiple points, single points, and multiple faults can be implemented on a packet dual-ring network in a simple, fast, and convenient manner, which greatly improves working efficiency. In addition, the method described in the present invention will The waiting for recovery state is extended to the active waiting for recovery state, the short path waiting for recovery state, and the neighboring side waiting for recovery state, and the corresponding state transition can be completed, thereby avoiding the entire network non-stop caused by the unstable state of a fiber on the network. Repeated oscillations. Brief description of the drawings

Figure 1 is a schematic diagram of the Chinese ring network structure;

2 is a flowchart of a method according to the present invention;

3 is a state transition diagram of a first processing scheme of the embodiment of the present invention; FIG. 4 is a state transition diagram of two processing schemes of the embodiment of the present invention; FIG. 5 is a third state of the embodiment of the present invention State transition diagram of the processing scheme; FIG. 6 is a state transition diagram of the fourth processing scheme of the embodiment of the present invention; FIG. 7 is a state transition diagram of the fifth processing scheme of the embodiment of the present invention; FIG. 8 is the present invention State transition diagram of the sixth processing scheme of the embodiment; FIG. 9 is a state transition diagram of the seventh processing scheme of the embodiment of the present invention; FIG. 10 is state transition diagram of the eighth processing scheme of the embodiment of the present invention Illustration. Mode of Carrying Out the Invention

The present invention is described in detail below with reference to the drawings. The method described in the present invention completely separates the states of two sides of the same node on a dual ring network, and runs a state machine on both sides of the same node, and uses "side" as the basic operating unit to complete the request processing, as shown in Figure 2. It is shown that the overall implementation steps of the method of the present invention are:

b. The side periodically sends requests to the side neighboring node and the side neighboring side according to the state of the side, and at the same time, the side receives requests from the side, the side neighboring side, and the side neighboring node; c, the The side processes the received new request, that is, judges and processes according to the priority of the received new request and the priority of the current request, puts the request that cannot be currently processed in the pending queue, and completes the logic according to the processing result State and physical state, and return to step b. Here, the current request is a request that is currently being processed, and the pending queue is a queue in which requests that cannot be currently processed by the side are arranged in order.

The method according to the present invention divides the physical state into a switching state and a non-switching state; the logical state is divided into: 1. an idle state (IDLE); 2. a local switching state (LOCAL-WRAP); 3. a short path switching state ( SHORT— WRAP); 4. Adjacent side switching state (MATE_WRAP); 5. Pass-through state (PASS — THROUGH); 6. Active waiting for recovery state (ACTIVE — WTR); 7. Short path waiting for recovery state (SHORT — WRT) ; 8. The neighbor is waiting for recovery (MATE-WRT). Wherein, when it is logically in an idle state and a through state, the corresponding physical state is a non-switching state; when it is logically in a local side switching state, a short path switching state, a neighboring side switching state, an active waiting for recovery state, and a short path waiting When the recovery state and the neighboring side are waiting for the recovery state, the corresponding physical state is a switching state.

In the above process, there are seven types of requests sent by one side of the node. The first request is [IDLE, 0, S], the second request is [R, W, S], and the third request is [R, W, L] request, the fourth request is [IDLE, W, S] request, the fifth request is [WTR, W, S], the sixth request is [WTR, W, L], and the seventh request is [IDLE, W, S]. In the first to seventh request triples, the first element indicates the type of the transmission request, IDLE indicates an empty request, WTR indicates a waiting to resume request, and R indicates the current request. The current request is a forced switch request (FS), a signal Any one of the invalidation request (SF), signal attenuation request (SD), manual handover request (MS), waiting for recovery request (WTR), or empty request (IDLE); the second element indicates the physical side of the request Whether the switch is in a switching state, W indicates a switching state, 0 indicates a non-switching state; the third element indicates whether the request is sent as a long path request or a short path request, L indicates a long path request, and S indicates a short path request.

When one side of a node on a dual ring network is in the different states described above, there will be different processing procedures in the above steps b to e. Because there are eight different states on this side logically, there are eight different processing schemes. Here are the explanations:

The first processing scheme is shown in Figure 3: After one side of a node on the ring network completes initialization, it is physically in a non-switching state and logically in an idle state. The current request on this side is set to an empty request, and the current request is For a request that is currently being processed, the side periodically sends a first request to the neighboring node and the neighboring side, and receives and processes the request from the local side, the neighboring side, and the neighboring node. There are five different situations depending on the type of request received:

The first case 310: The side receives the local fault request, and the process is as follows: Step 311: Save the received local fault request as the current request, enter the switching state physically, and send [R, W, S] request, send a neighbor long path request to the neighbor, and logically enter the local switch state.

Second case 320: The side receives a non-empty short path request from a neighboring node, and the processing process is as follows:

Step 321: Enter a handover state physically, save the received non-empty short path request as the current request, send a [R, W, S] request to a neighboring node, and send a neighboring long path request to the neighboring side; Step 322: If the non-empty short path request is WTR, logically enter the short path waiting for recovery state; otherwise, enter the short path switching state logically.

Third case 330: The side receives a long path request from a neighboring node, and the process is as follows:

Step 331: Forward the received new request to the neighboring node, save the received request as the current request, forward the request to the neighboring node, and logically enter the through state.

Fourth case 340: The side receives a long path request from the neighboring side, and the processing process is as follows:

Step 341: Enter a handover state physically, change the current request to a new request received, and send a long path request to a neighboring node;

Step 342: If the received new request is a WTR, it logically enters the neighbor-side waiting recovery state, otherwise it logically enters the neighbor-side switching state.

Fifth case 350: The side receives no other request, and does not process it.

The second processing scheme is shown in Figure 4: When one side of a node on the ring network is logically in the local switching state and physically in the switching state, the local side periodically sends a second request to the neighboring node, and sends the first request to the neighboring side. Three requests, the side receives requests from the local side, the neighboring side, and the neighboring nodes and processes them. Depending on the type of request received, there are six different situations:

The first case 410: The side receives a local fault clearing request from the local side, and the processing process is as follows:

Step 411: Check whether the request is in the pending queue, and if the request is in the pending queue, delete the pending request, otherwise perform step 412;

Step 412: Check whether there is SF or SD in the pending queue, and if there is, execute step 413; otherwise, the side logically enters the active waiting for recovery state, and the current request is changed to WTR, and the process is ended;

Step 413: Remove the highest priority request from the pending queue, and update the current request. Instead, the status is unchanged.

The second case 420: The side receives the fault request from the local side, and the processing process is as follows: Step 421: If the priority of the request is higher than the priority of the current request from the local side, step 422 is performed; otherwise, step 423 is performed ;

Step 422: Put the current request into the pending queue, and change the current request to the received local fault request, the status remains unchanged, and the process ends;

Step 423: If the priority of the request is lower than the priority of the current request on the local side, the current request is placed in the pending queue, the state remains unchanged, and the process ends; otherwise, no processing is performed.

Third case 430: The side receives a short path request from a neighboring node, and the processing process is as follows:

Step 431: If the current request priority of the side is higher than SD, no processing is performed, and the process ends; otherwise, step 432 is performed;

Step 432: If the priority of the received new request is higher than the priority of the current request on that side, step 433 will be performed; otherwise, no processing is performed and the process ends;

Step 433: Put the current request into the Guiqi queue, change the current request on the side to the new request received, and logically enter the short path switching state.

Fourth case 440: The side receives a long path request from a neighboring node, and the processing process is as follows:

Step 441: If the priority of the current request on the side is higher than SD, no processing is performed and the process ends; otherwise, step 442 is performed;

Step 442: If the priority of the received new request is higher than or equal to the priority of the current request of the side, step 443 is performed; otherwise, the processing is not performed and the process is ended;

Step 443: Put the current request into the pending queue, change the current request on the side to the received new request, and forward the request to the neighboring side, and physically restore the side to the non-switched state. Logically Into the through state. Fifth case 450: The side receives a long path request from the neighboring side, and the processing process is as follows:

Step 451: If the priority of the current request on the side is higher than SD, no processing is performed and the process is ended, otherwise, step 452 is performed;

Step 452: If the priority of the received new request is higher than the priority of the current request of the side, or the priority of the received new request is equal to the priority of the current request of the side and the side is the b side of the node, Step 453 is performed; otherwise, no processing is performed, and the process ends;

Step 453: Put the current request into the pending queue, change the current request on the side to the received new request, and the side logically enters the neighboring-side switching state.

The sixth case 460: The side receives the long path request forwarded by the neighboring side, and the processing process is as follows:

Step 461: If the priority of the current request on the side is higher than SD, go to step 463; otherwise, go to step 462;

Step 462: If the priority of the received new request is higher than or equal to the current request, step 464 is performed; otherwise, step 463 is performed;

Step 463: Send the neighboring side long path request to the neighboring side with the current request, keeping the state unchanged. Step one silver 464: Put the current request on the side into the pending queue, and physically restore the non-switched state on the current side of the side. Change the current request on the side to the new request received, and logically put the side into the through state.

The third processing scheme is shown in FIG. 5: When one side of a node on a ring network is logically in a short path switching state and physically in a switching state, the side periodically sends a fourth request to a neighboring node, and sends a first request to the neighboring side. Three requests. This side receives and processes requests from the local side and from neighboring sides and neighboring nodes. There are five different situations in this process:

The first case 510: The side receives the information requested by the side to clear, and the processing process is as follows: Step 511: Check whether the request is in the pending queue, and delete it if it is in the pending queue. Except for this pending request, no processing is performed.

The second case 520: The side receives the fault request from the side, and the processing process is as follows: Step 521: If the new request FS or SF is received, go to step 522; if no, go to step 523;

Step 522: Change the current request on the side to a new request received, the side logically enters the switching state on the side, and ends the process;

Step 523: If the new request has a higher priority than the current request, go to step 522; if no, 'J, go to step 524;

Step 524: Put the received new request into the pending queue, and keep the state unchanged. Third case 530: The side receives a short path request from a neighboring node, and the processing process is as follows:

Step 531: if the received new request is not a WTR, then execute step 532; otherwise, execute step 533;

Step 532: Change the current request to the received new request, keep the state unchanged, and end the process.

Step 533: If there is no SD in the suspend queue, the side logically enters a short path to wait for recovery and ends the process, otherwise, execute step 534;

Step 534: Remove the SD in the currently suspended queue, change the current request on the side to SD, and the side logically enters the switching state on the side.

The fourth case 540: The side receives a long path request from a neighboring node, and the processing process is as follows:

Step 541: If the priority of the current request on the side is higher than SD, no processing is performed and the process ends, otherwise, step 542 is performed;

Step 542: If the priority of the received new request is higher than or equal to the priority of the current request on that side, step 543 is performed; otherwise, no processing is performed and the process ends; Step 543: Change the current request on the side to the received new request, and forward the received new request to the neighboring side, the side logically enters the through state, and the side is physically restored to the non-switched state. .

Fifth case 550: The side receives a long path request from the neighboring side, and the processing process is as follows:

Step 551: If the priority of the current request on the side is higher than SD, no processing is performed, and the process ends, otherwise, step 552 is performed;

Step 552: If the priority of the received new request is higher than the priority of the current request of the side, step 554 is performed, otherwise, step 553 is performed;

Step 553: If the priority of the received new request is equal to the priority of the current request of the side, and the side is the b side of the node, step 554 is performed, otherwise, no processing is performed, and the process ends;

554: The current request is put into a pending queue, and the current request is changed to a new request received, and the side logically enters a neighboring-side switching state.

The sixth case 560: The side receives the forward long path request from the neighboring side, and the processing process is as follows:

Step 561: If the priority of the request side is higher than the current SD, step 563 is performed, step 562 whether the shell ^1;

Step 562: If the priority of the received new request is higher than or equal to the current request priority, step 564 is performed, otherwise step 563 is performed;

Step 563: The side sends a neighboring side long path request to the department side with the current request and keeps the state unchanged, and ends the process;

Step 564: The side is physically restored to the non-switching state, and then the current request is put into the pending queue, and the current request on the side is changed to the received new request, and the side logically enters the through state. The fourth processing scheme is shown in FIG. 6: In the above method, when one side of a node on a ring network is logically in a neighboring switching state and physically in a switching state, the side periodically sends a third request to the neighboring node. The side receives requests from the local side, the neighboring side, and the nodes and processes them. There are eight different situations in this process:

The first case 610: The side receives the request for clearing information from its own side, and the process is as follows: Step 611: Check whether the request is in the pending queue, and if it is in the pending queue, delete the pending request, otherwise, Do nothing.

The second case 620: The side receives the fault request from the side, and the processing process is as follows: Step 621: If the priority of the received new request is higher than SD, go to step 623, otherwise, go to step 622;

Step 622: If the priority of the received new request is higher than the priority of the current request of the side, step 623 is performed; otherwise, step 624 is performed;

Step 623: Change the current request on the side to the received new request, logically enter the switching state on the side, and end the process;

Step 624: Put the received new request into the pending queue, and keep the state unchanged. Third case 630: The side receives a short path request from a neighboring node, and the process is as follows:

Step 631: If the received new request is higher than SD, go to step 634, otherwise, go to step 632;

Step 632: If the priority of the received new request is lower than the current request, no processing is performed. If the priority of the received new request is equal to the current request, step 633 is performed. If the priority of the received new request is high At the current request, step 634 is performed;

Step 633: Immediately send a neighboring long path request to the neighboring side, and keep the state unchanged, and end the process;

Step 634: Change the current request on the side to the new request received, and the logic on the side Enter the short path switching state.

The fourth case 640: The side receives a long path request from a neighboring node, but the first long path request received from the outer ring must be discarded. The process is as follows:

Step 641: If the priority of the current request on the side is higher than SD, no processing is performed and the process ends, otherwise, step 642 is performed;

Step 642: If the priority of the received new request is higher than the current request priority of the side, step 645 is performed; if the priority of the received new request is equal to the current request priority of the side, step 643 is performed, If the priority of the received new request is lower than the current request priority of the side, no processing is performed, and the process ends;

Step 643: If the received new request comes from a neighboring node on the neighboring side, no processing is performed, and the process ends, otherwise, step 644 is performed;

Step 644: If the received new request is from the outer ring, go to step 645, otherwise, go to step 646;

Step 645: Physically restore the side to the non-switching state, change the current request on the side to the new request received, and forward the received new request to the neighboring side, and the side logically enters the through state ; '

Step 646: Send a long path request to the neighboring side immediately.

Fifth case 650: The side receives a long path request from the neighboring side, and the processing process is as follows:

Step 651: If the received new request is WTR, go to step 652, otherwise, go to step 653;

Step 652: If there is no SD in the pending queue, go to step 654, otherwise, go to step 655;

Step 653: Change the current reliance on the side to the new request received, keep the state unchanged, and end the process; Step 654: The current request on the side is changed to a new request, the new request is forwarded to an adjacent node, and the side logically enters a state of waiting for recovery on the adjacent side;

Step 655: Remove the SD in the pending queue, change the current request on the side to the new request received, and logically enter the switching state on the side.

The sixth case 660: The side receives the long path request forwarded by the neighboring side, and the processing process is as follows:

Step 661: The current request on the side is changed to a received new request, the side is physically restored to a non-switched state, the received new request is forwarded to a neighboring node, and the side logically enters a through state.

The fifth processing scheme is shown in FIG. 7: When one side of a node on a ring network is logically in a through state and physically in a non-switching state, the side does not send any requests. When the side receives a long path request, The request is forwarded to the next node, and the side receives the request from the local side and from the neighboring side and the neighboring node, and processes the request. There are five different situations in this process:

The first case 710: The side receives the request for clearing from the side, and the process is as follows: Step 711: Check 'This request is in the pending queue. If it is in the pending queue, go to step 712, otherwise, do not do Process and end the process;

Step 712: Delete this request, and keep the status unchanged.

The second case 720: The side receives the fault request from the side, and the processing process is as follows: Step 721: If the priority of the received new request is higher than SD, the side performs step 723, otherwise proceeds to step 722;

Step 722: If the priority of the new request is less than or equal to SD, perform step 724 on the side, otherwise, perform step 723;

Step 723: The side physically enters a handover state, and changes the current request to a received new request. The side logically enters the handover state of the side, and ends the process.

Step 724: Put the received new request into the pending queue. Third case 730: The side receives a short path request from a neighboring node, and the process is as follows:

Step 731: If the received new request is an empty request, go to step 732, otherwise, go to step 733;

Step 732: Change the current request to an empty request, the side logically enters the idle state, and the process ends;

Step 733: The side physically enters a switching state, and changes the current request to a received new request, and the side logically enters a short path switching state.

Fourth case 740: The side receives a long path request from a neighboring node, and the process is as follows:

Step 741: If the received new request is a WTR request, go to step 742, otherwise, go to step 744;

Step 742: If there is SD in the pending queue, go to step 743; otherwise, go to step

744;

Step 743: The side physically enters the switching state, changes the current request to SD, the side logically enters the switching state of the local side, and ends the process;

Step _744: Change the current request to the received new request, and forward the received new request to the next node, and keep the state unchanged.

情况 Five cases 750: The side receives a long path request from the neighboring side, and the processing process is as follows:

Step 751: The side physically enters a switching state, and changes the current request to a new request received;

Step 752: If the new request received by the side is WTR, the side logically enters the neighboring side waiting for recovery state; otherwise, the side logically enters the neighboring side switching state.

The sixth case 760: The side receives other requests other than the above requests and does not process them. The sixth processing scheme is shown in FIG. 8: When one side of a node on a ring network is logically in an active waiting state for recovery and is physically in a switching state, the side periodically sends a fifth request to a neighboring node, and sends a first request to the neighboring side. Six requests, the side receives requests from the local side, neighboring sides, and neighboring nodes and processes them. There are seven different situations in this process:

The first case 810: The side receives a fault request from the local side, and the process is as follows: Step 811: Change the current request to a new request received. If there is a WTR in the pending queue, delete the WTR. The local side Logically enter the local switching state.

The second case 820: The side receives a short path request from a neighboring node, and the process is as follows:

Step 821: If the received new request is [WTR, W, S], go to step 822, otherwise, go to step 823;

Step 822: Put the received new request into a pending queue, keep the state unchanged, and end the process;

Step 823: If the new request received by the side is [IDLE, W, S], go to step 824, otherwise go to step 825;

Step 824: Delete the WTR request in the pending queue, and end the process.

Step 825: If the new request received by the side is an empty request, it is not processed, otherwise, step 826 is performed;

Step 826: Change the current request to the received new request. If there is a WTR request in the pending queue, delete the request, and the side logically enters the short path switching state.

Third case 830: The side receives a long path request from a neighboring node, and the process is as follows:

Step 831: If the received new request is WTR, no processing is performed, otherwise, step 832 is performed;

Step 832: The physical state on the side enters the switching state, and changes the current request to the connected state. The new request received is then forwarded to the neighboring side, and the WTR request in the pending queue is deleted at the same time, and the side logically enters the through state.

The fourth case 840: The side receives the long path request from the neighboring side, and the process is as follows:

Step 841: If the received new request is WTR, no processing is performed, otherwise, step 842 is performed;

Step 842: Change the current request to the received new request. If there is a WTR request in the pending queue, delete the request, and the side logically enters the neighboring-side switching state.

Fifth case 850: The side receives a short path request from the neighboring side, and the process is as follows:

Step 851: Immediately send a neighboring long path request to the neighboring side, and keep the state unchanged. The sixth case 860: The side receives the long path request forwarded by the neighboring side, and the process is as follows:

Step 861: The physical state of the side enters a non-switching state, changes the current request to a received new request, forwards the received new request to a neighboring node, and deletes the request if there is a WTR request in the pending queue. At the same time, a new request is forwarded to the next node, and the side logically enters the through state.

The seventh case 870: When the WTR timer expires, the processing is as follows: Step 871: Check whether there is a WTR in the pending queue, and if so, go to step 872, otherwise, go to step 873;

Step 872: Remove the WTR from the pending queue, change the current request to a pending request, and the side logically enters the short path waiting for recovery state, otherwise proceed to step 873;

Step 873: The side physically enters a non-switching state, and changes the current request to an empty request, and the side logically enters an idle state.

The seventh processing scheme is shown in Figure 9. When one side of a node on the ring network is logically short, When the path is waiting for recovery, when it is physically in the switching state, the side periodically sends a seventh request to the neighboring node and a sixth request to the neighboring side. The side receives requests from the local side, the neighboring side, and the node and processes them. There are five different cases of this processing method:

The first case 910: The side receives the fault request from the local side, and the processing process is as follows: Step 911: The current request is changed to the received new request, and the side logically enters the local side switching state.

Second case 920: The side receives a short path request from a neighboring node, and the process is as follows:

Step 921: If the received new request is an empty request, go to step 922, otherwise, go to step 923;

Step 922: The physical state of the side enters a non-switching state, and the current request is changed to an empty request. The side logically enters an idle state and ends the process.

Step 923: If the new request received by the side is WTR, no processing is performed, otherwise, step 924 is performed;

Step 924: The current request is changed to the received new request, and the side logically enters a short path switching state.

Third case 930: The side receives a long path request from a neighboring node, and the process is as follows:

Step 931: The physical state of the side enters a non-switching state, changes the current request to a received new request, and then forwards the received new request to the neighboring side, and the side logically enters the through state.

Fourth case 940: The side receives a long path request from the neighboring side, and the processing process is as follows:

Step 941: If the received new request is WTR, no processing is performed, otherwise, step 942 is performed; Step 942: The current request is changed to the received new request, and the side logically enters a neighboring-side switching state.

Fifth case 950: The side receives a short path request from the neighboring side, and the process is as follows:

Step 951: Immediately send a neighbor long path request to the neighbor, and keep the state unchanged. The sixth case 960: The side receives the long path request forwarded by the neighboring side, and the processing process is as follows:

Step 961: The physical state of the side enters a non-switching state, and changes the current request to a received new request, and then forwards the received new request to a neighboring node, and the side logically enters a through state.

The eighth processing scheme is shown in FIG. 10: When one side of a node on a ring network is logically in a state of waiting for recovery and is physically in a switching state, the side periodically sends a sixth request to the neighboring node. Requests from the local side, neighboring sides, and neighboring nodes are processed. There are six different situations in this process:

笫 A case 1010: The side receives the fault request from the side, and the processing process is as follows: Step 1011: The current request is changed to the new request received, and the side logically enters the state of the side switching. .

The second case 1020: The side receives a short path request from a neighboring node, and the process is as follows:

Step 1021: If the received new request is an IDLE request, no processing is performed, otherwise, step 1022 is performed;

Step 1022: If the received new request is an empty request, go to step 1023, otherwise, go to step 1024;

Step 1023: Change the current request to the received new request, and the side logically enters the short path waiting for recovery state, and ends the process; Step 1024: The current request is changed to the received new request, and the side logically enters a short path switching state.

Third case 1030: The side receives a long path request from a neighboring node, and the process is as follows:

Step 1031: If the received new request is WTR, no processing is performed, otherwise, step 1032 is performed;

Step 1032: The physical state of the side enters a non-switching state, changes the current request to a new request received, and then forwards the received new request to the neighboring side, and the side logically enters the through state.

Case 440: The side receives the long path request from the neighboring side, and the processing process is as follows:

Step 1041: If the received new request is WTR, no processing is performed, otherwise, step 1042 is performed;

Step 1042: The current request is changed to the received new request, and the side logically enters a neighboring-side switching state.

Fifth case 1050: The side receives a short path request from the neighboring side, and the processing process is as follows:

Step 1051: The physical state of the side enters a non-switching state, changes the current request to an empty request, and the side logically enters the idle state.

Case 660: The side receives the long path request forwarded by the neighboring side, and the processing process is as follows:

Step 1061: The physical state of the side enters a non-switching state, changes the current request to a received new request, and then forwards the received new request to the next node, and the side logically enters the through state.

The above are only the preferred embodiments of the present invention, but the protection scope of the present invention It is not limited to this, any changes or replacements that can be easily conceived by anyone familiar with the technology within the technical scope disclosed by the present invention should be covered by the protection scope of the present invention.

Claims

Claim

1. A method for implementing protection switching on a packet dual-ring network, characterized in that the method runs state machines on both sides of the same node, and the method includes the following steps:

b. The side periodically sends requests to the side neighbor node and the side neighbor side according to the state in which the side is located. Meanwhile, the side receives requests from the side, the side neighbor side, and the side neighbor node. The new request received is processed, and the logical state and the physical state are switched according to the processing result, and the process returns to step b.

2. The method according to claim 1, wherein the logical states are an idle state, a local switching state, a short path switching state, a neighboring switching state, a passing state, an active waiting for recovery state, and a short path. Either the waiting-to-recovery state or the neighboring waiting-to-recovery state.

3. The method according to claim 2, wherein one side of a node on the ring network completes initialization, initializes a logical state of the side to an idle state, a physical state to a non-switched state, and a current request to an empty request, Then in the step b, the node side periodically sends a first request to the neighboring node and the neighboring side.

4. The method according to claim 2, characterized in that: one side of the node on the ring network is logically in a local switching state and physically in a switching state, then in step b: the node side is timed to The neighboring node sends a second request, and sends a third request to the neighboring side.

5. The method according to claim 2, characterized in that: one side of the node on the ring network is logically in a short path switching state and physically is in a switching state, then in step b: the node side is timed to The neighboring node sends a fourth request, and sends a third request to the neighboring side.

6. The method according to claim 2, wherein, one side of a node on the ring network, When it is logically in the neighboring switching state and physically is in the switching state, in step b: the node side periodically sends a third request to the neighboring node.

7. The method according to claim 2, characterized in that, when one side of a node on the ring network is logically in a through state and physically in a non-switching state, in step b: the node side does not send For any request, when the side receives the long path request, it forwards the request to the next node.

8. The method according to claim 2, characterized in that, one side of a node on the ring network is logically in an active waiting state for recovery, and when it is physically in a switching state, in step b: the node side periodically The neighboring node sends a fifth request, and sends a sixth request to the neighboring side.

9. The method according to claim 2, characterized in that: one side of a node on the ring network is logically in a short path waiting for recovery state, and when it is physically in a switching state, in step b: timing of the node side A seventh request is sent to the neighboring node, and a sixth request is sent to the neighboring side.

10. The method according to claim 2, characterized in that, one side of the node on the ring network is logically in a state of waiting for recovery on the neighboring side, and when it is physically in a switching state, in step b: timing of the side of the node Send a sixth request to a neighboring node.

11. The method according to claim 3, wherein the first request is a [IDLE, 0, S] request.

12. The method according to claim 4, wherein the second request is a [R, W, S] request, and the third request is a [R, W, L] request.

13. The method according to claim 5, wherein the third request is [R,

W, L] request, the fourth request is [IDLE, W, S] request.

14. The method according to claim 6, wherein the third request is a [R, W, L] request.

15. The method according to claim 8, wherein the fifth request is [WTR _: W, S], and the sixth request is [WTR, W, L].

16. The method according to claim 9, wherein the sixth request is [WTR _: W, L], and the seventh request is [IDLE, W, S].

17. The method according to claim 10, wherein the sixth request is [WTR, W, L].

18. The method according to claim 12, 13, or 14, wherein R in the second request or the third request is a current request, and the current request is a forced switching request

(FS), signal failure request (SF), signal attenuation request (SD), manual switching request (MS), waiting for recovery request (WTR), or empty request (IDLE).

19. The method according to claim 18, wherein the requests in the network from the highest priority to the highest priority are: FS, SF, SD, MS, WTR, IDLE.

20. The method according to claim 1, wherein the step c is: the node side judges and processes the received request according to the priority of the new request and the priority of the request currently being processed, and Requests that cannot be processed are placed in the pending queue, and the logical state and the physical state are switched according to the processing result, and the process returns to step b.