def _print_port_details()

in fboss/py/fboss/cli/commands/port.py [0:0]

• 107 lines of code
• 38 McCabe index (conditional complexity)

    def _print_port_details(self, port_info):
        """Print out port details

        :var port_info PortInfoThrift: port information
        """

        admin_status = "ENABLED" if port_info.adminState else "DISABLED"
        oper_status = "UP" if port_info.operState else "DOWN"

        speed, suffix = self._convert_bps(port_info.speedMbps * (10 ** 6))
        vlans = " ".join(str(vlan) for vlan in (port_info.vlans or []))

        fec_status = port_info.fecMode

        pause = ""
        if port_info.txPause:
            pause = "TX "
        if port_info.rxPause:
            pause = pause + "RX"
        if pause == "":
            pause = "None"
        fmt = "{:.<50}{}"
        lines = [
            ("Name", port_info.name.strip()),
            ("ID", str(port_info.portId)),
            ("Description", port_info.description or ""),
            ("Admin State", admin_status),
            ("Link State", oper_status),
            ("Speed", "{:.0f} {}".format(speed, suffix)),
            ("VLANs", vlans),
            ("Forward Error Correction", fec_status),
            ("Pause", pause),
        ]

        if hasattr(port_info, "pfc") and port_info.pfc:
            pfc_str = ""
            if port_info.pfc.tx:
                pfc_str = "TX "
            if port_info.pfc.rx:
                pfc_str = pfc_str + "RX"
            if port_info.pfc.watchdog:
                pfc_str = pfc_str + " WD"
            lines.append(("PFC", pfc_str))

        if hasattr(port_info, "profileID") and port_info.profileID:
            lines.append(("ProfileID", port_info.profileID))

        print()
        print("\n".join(fmt.format(*l) for l in lines))

        if hasattr(port_info, "portQueues"):
            print(fmt.format("Unicast queues", len(port_info.portQueues)))
            for queue in port_info.portQueues:
                name = "({})".format(queue.name) if queue.name != "" else ""
                attrs = [queue.mode]
                for val in (
                    "weight",
                    "reservedBytes",
                    "scalingFactor",
                    "bandwidthBurstMinKbits",
                    "bandwidthBurstMaxKbits",
                ):
                    if hasattr(queue, val) and getattr(queue, val):
                        attrs.append("{}={}".format(val, getattr(queue, val)))

                if hasattr(queue, "portQueueRate") and queue.portQueueRate:
                    if queue.portQueueRate.field == 1:  # pps
                        attrs.append(
                            "minpps={}".format(queue.portQueueRate.value.minimum)
                        )
                        attrs.append(
                            "maxpps={}".format(queue.portQueueRate.value.maximum)
                        )
                    elif queue.portQueueRate.field == 2:  # kbps
                        attrs.append(
                            "minkbps={}".format(queue.portQueueRate.value.minimum)
                        )
                        attrs.append(
                            "maxkbps={}".format(queue.portQueueRate.value.maximum)
                        )

                if not (hasattr(queue, "aqms") and queue.aqms):
                    attrs.append("TAIL DROP")
                    print(
                        "    Queue {} {:29}{}".format(queue.id, name, ",".join(attrs))
                    )
                else:
                    print(
                        "    Queue {} {:29}{}".format(queue.id, name, ",".join(attrs))
                    )
                    for aqm in queue.aqms:
                        attrs = []
                        if aqm.behavior == QueueCongestionBehavior.EARLY_DROP:
                            attrs.append("EARLY DROP")
                        elif aqm.behavior == QueueCongestionBehavior.ECN:
                            attrs.append("ECN")
                        if hasattr(aqm.detection, "linear") and aqm.detection.linear:
                            attrs.append("{}={}".format("detection", "linear"))
                            linear = aqm.detection.linear
                            attrs.append(
                                "{}={}".format("minThresh", linear.minimumLength)
                            )
                            attrs.append(
                                "{}={}".format("maxThresh", linear.maximumLength)
                            )
                            attrs.append(
                                "{}={}".format("probability", linear.probability)
                            )

                            print("{:<41}{}".format("", ",".join(attrs)))

                if hasattr(queue, "dscps") and queue.dscps:
                    dscpRanges = []
                    for _, dscpRange in itertools.groupby(
                        enumerate(sorted(queue.dscps)), lambda p: p[1] - p[0]
                    ):
                        dscpRange = list(dscpRange)
                        dscpRanges.append(
                            "[{}]".format(dscpRange[0][1])
                            if len(dscpRange) == 1
                            else "[{}-{}]".format(dscpRange[0][1], dscpRange[-1][1])
                        )
                    print("{:<41}DSCP={}".format("", ",".join(dscpRanges)))