Les abandons importants et durables dans les files d'attente critiques sont courants dans les situations de capacité excessive et risquent d'avoir des répercussions pour les clients.

Les compteurs dans les files d'attente critiques suivantes doivent être surveillés étroitement.

vc_queue_net_sch, vc_queue_link_select et vc_queue_link_sch : ces planificateurs sont destinés à la sélection de liens, à la QOS et à la planification de liens pour les paquets destinés aux dispositifs Edge. Orchestrator effectue des paquets à partir du programmateur de paquets global (vc_queue_net_sch), choisit le lien approprié pour les envoyer (vc_queue_link_select) et les met en file d'attente dans le planificateur de paquets au niveau de la liaison (vc_queue_link_sch).

Les abandons ici indiquent que la passerelle ne peut pas envoyer suffisamment rapidement le trafic VCMP (par exemple, les paquets de retour d'Internet) vers des dispositifs Edge.

vc_queue_link_encrypt_0 et vc_queue_link_encrypt_1 : il s'agit du chiffrement des paquets basé sur le logiciel, qui gère le chiffrement des paquets, ainsi que l'encapsulation et le traitement similaire avant la transmission des paquets.

Dans une passerelle sur laquelle DPDK est activé, les problèmes de capacité sont d'abord observés comme des abandons dans cette file d'attente. Les abandons dans la file d'attente indiquent que la passerelle ne peut pas chiffrer suffisamment rapidement le trafic.

vc_queue_vcmp_tx : il s'agit de la transmission de paquets pour les paquets VCMP. La file d'attente gère la transmission des paquets sur les interfaces, la mise en file d'attente de retransmission potentielle si nécessaire et la libération de paquets. Les abandons de la file d'attente indiquent que la passerelle ne peut pas envoyer de trafic VCMP (par exemple, les paquets de retour d'Internet) suffisamment rapidement vers des dispositifs Edge.

Voici un exemple de script Python pour vérifier les abandons vcmp_tx. Exécutez le script Python sur une passerelle avec des abandons dans la file d'attente pour afficher les détails des problèmes.

#!/usr/bin/env python
"""
Check VCG vcmp handoff drops packet check
"""
import os
import sys
import subprocess
import commands
import re
import json
from optparse import OptionParser

# Parse commandline options:
parser = OptionParser(usage="%prog -w <warning threshold> -c <critical threshold> [ -h ]")
parser.add_option("-w", "--warning", action="store", type="string", dest="warn_threshold", help="Count Warning threshold should be in <value>")
parser.add_option("-c", "--critical",action="store", type="string", dest="crit_threshold", help="Count Critical threshold should be in <value>")
(options, args) = parser.parse_args()

json_data= {"vcg_handoff_data": {"count":0,"drops":[]}}
vcg_handoff_file="/tmp/vcg_handoff_drop_check"
bw_threshold=768000

def find_bw_throughput():
    total_bw = 0
    value = 2
    flag = os.path.exists("/opt/vc/etc/dpdk-override.json")
    if flag is True:
       with open("/opt/vc/etc/dpdk-override.json") as json_file:
            data = json.load(json_file)
       value = data["enabled"]
    if value == 0:
      status,output = commands.getstatusoutput("ifstat  -bqTn 1 1")
      if status == 0:
         total_bw = float(output.splitlines()[-1].split()[-1]) + float(output.splitlines()[-1].split()[-2])
    return int(total_bw)

def store_vcg_hanoff_queue_qlength():
    samples_count = 5
    if not os.path.isfile(vcg_handoff_file):
       with open(vcg_handoff_file, 'w') as outfile:
           json.dump(json_data, outfile )

    if os.path.isfile(vcg_handoff_file):
       with open(vcg_handoff_file) as vcg_handoff_data:
           handoff_data = json.load(vcg_handoff_data)
    else:
       with open(vcg_handoff_file, 'w') as outfile:
           json.dump(json_data, outfile )

    if os.path.isfile('/opt/vc/bin/debug.py'):
       L=[]
       f=subprocess.check_output(["/opt/vc/bin/debug.py","--handoff"])
       x=[r.split() for r in f.split('\n')]
       res = list(filter(None, x))

       if handoff_data["vcg_handoff_data"]["count"] == 0:
           for item in res:
              if not item[0] == "name":
                 #handoff_data["vcg_handoff_data"]["drops"].append({item[0]:[item[13]]})
                 handoff_data["vcg_handoff_data"]["drops"].append({item[0]:["1"] * samples_count})
                 handoff_data["vcg_handoff_data"]["count"] = 1
           with open(vcg_handoff_file, 'w') as outfile:
                json.dump(handoff_data, outfile )

       if not handoff_data["vcg_handoff_data"]["count"] == 0:
        count_status = handoff_data["vcg_handoff_data"]["count"] - 1
        for item in res:
            if not item[0] == "name":
               for key in  handoff_data["vcg_handoff_data"]["drops"]:
                   field_num = len(item) - 6
                   if item[0] == key.keys()[0]:
                      key[key.keys()[0]].append(item[field_num])
                      del key[key.keys()[0]][0]
                      #key[key.keys()[0]][count_status]=item[field_num]
        handoff_data["vcg_handoff_data"]["count"] += 1
        if handoff_data["vcg_handoff_data"]["count"] == samples_count + 1:
           handoff_data["vcg_handoff_data"]["count"] = 1

        with open(vcg_handoff_file, 'w') as outfile:
           json.dump(handoff_data, outfile )

def get_status_of_drops(warn_value,crit_value):
    result = []
    diff_drops_data = []
    both_value = False
    total_bw = find_bw_throughput()
    if os.path.isfile(vcg_handoff_file):
       with open(vcg_handoff_file) as vcg_handoff_data:
           handoff_data = json.load(vcg_handoff_data)

    for drops in handoff_data["vcg_handoff_data"]["drops"]:
       for key,value in drops.items():
           if key == "vc_queue_vcmp_tx_0":
               for cumlative_data in range(len(value)):
                  if not cumlative_data == 4:
                     drop_value = int(value[cumlative_data+1]) - int(value[cumlative_data])
                     diff_drops_data.append(drop_value)
                     warn_counter = 0
                     crit_counter = 0
                     for data in diff_drops_data:
                        if int(data) >= int(crit_value) and int(total_bw) > int(bw_threshold):
                           both_value = True
                        if int(data) > int(crit_value):
                          crit_counter +=1
                        if int(data) > int(warn_value) and  int(data) < int(crit_value):
                          warn_counter +=1
                     if both_value == True:
                        if not result:
                           result.append({key:diff_drops_data,"current_bw":total_bw,"status":"critical"})
                     if crit_counter  == 4:
                        result.append({key:diff_drops_data,"current_bw":total_bw,"status":"critical"})
                     if warn_counter == 4:
                        result.append({key:diff_drops_data,"status":"warning"})
    if not result:
       return "OK",diff_drops_data,total_bw
    else:
       return result

if __name__ == '__main__':

   crit_threshold = options.crit_threshold
   warn_threshold = options.warn_threshold
   crit = 0
   if not options.crit_threshold:
      print "CRITICAL: Missing critical threshold value."
      sys.exit(2)
   if not options.warn_threshold:
      print "CRITICAL: Missing warning threshold value."
      sys.exit(2)

   store_vcg_hanoff_queue_qlength()
   result = get_status_of_drops(warn_threshold,crit_threshold)
   result_type = isinstance(result, tuple)
   if result_type != True:
      for item in result:
         if item["status"] == "critical":
            crit = 1

   if result[0] == "OK":
      print "OK: Handoff drops with 5 samples are good and Current drop values %s and Current BW is %s Kbps" %(result[1],result[2])
      sys.exit(0)
   elif crit == 1:
      print "Critical: List of drops which are above %s packets: %s. Current_bw value is in kbps" %(crit_threshold, result)
      sys.exit(2)
   else:
      print "Warning: List of drops which are above %s packets: %s. Current_bw value is in kbps" %(warn_threshold,result)
      sys.exit(1)

vc_queue_vcmp_data_0 et vc_queue_vcmp_data_1 : il s'agit de la première étape de traitement des paquets de données VCMP reçus sur les tunnels VCMP. La file d'attente gère la réorganisation des paquets et les paquets manquants. Il s'agit du début du traitement des paquets de données entrant sur un tunnel VCMP.

Les abandons de la file d'attente indiquent que la passerelle ne peut pas recevoir suffisamment rapidement le trafic des dispositifs Edge. Il peut s'agir d'une indication indirecte de la perte de paquets sur la passerelle, ce qui nécessite une réorganisation importante des paquets.

vc_queue_natt_0, vc_queue_natt_1, vc_queue_esp_0 et vc_queue_esp_1 : il s'agit du déchiffrement du trafic NATT/ESP chiffré. Le trafic qui se trouve sur un tunnel chiffré est ici pour configurer l'état nécessaire au déchiffrement et est ensuite dirigé vers une file d'attente de traitement de déchiffrement.

Les abandons de la file d'attente indiquent que la passerelle ne peut pas déchiffrer suffisamment rapidement le trafic Non VMware SD-WAN Site.

ipv4_bh : il s'agit du traitement des paquets de données IPv4, comme le routage, la QoS, l'association de flux et d'homologues, pour les paquets de retour reçus d'Internet pour le trafic NAT ou depuis le routeur PE pour le trafic VLAN/VRF.

Dans toutes les passerelles, à l'exception des passerelles sans DPDK activé, les problèmes de capacité sont d'abord observés comme des abandons dans la file d'attente. Les abandons dans la file d'attente indiquent que la passerelle ne peut pas recevoir suffisamment rapidement de paquets.