fc-server 0.7.0__tar.gz → 0.7.2__tar.gz

{fc-server-0.7.0 → fc-server-0.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: fc-server
-Version: 0.7.0
+Version: 0.7.2
 Home-page: https://fc.readthedocs.io/
 Author: Larry Shen
 Author-email: larry.shen@nxp.com
@@ -11,11 +11,10 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Programming Language :: Python
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.7
+Requires-Python: >=3.8
 License-File: LICENSE
 Requires-Dist: aiohttp>=3.7.4.post0
 Requires-Dist: async-lru>=1.0.3

{fc-server-0.7.0 → fc-server-0.7.2}/docker/fc_server/docker-compose.yaml

@@ -10,6 +10,7 @@ services:
     tty: true
     ports:
       - "8600:8600"
+    restart: unless-stopped
     volumes:
       - /tmp:/tmp
       - $PWD/../../fc_server/config/lavacli.yaml:/root/.config/lavacli.yaml

{fc-server-0.7.0 → fc-server-0.7.2}/fc_client/client.py

@@ -11,20 +11,24 @@ import asyncio
 import json
 import os
 import pathlib
+import re
 import signal
 import socket
 import subprocess
 import sys
+import textwrap
 import time
 import urllib.parse
 from getpass import getuser
 from socket import gethostname
+from urllib.parse import urlparse, urlunparse
 
 import aiohttp
 import prettytable
 import psutil
 import requests
 import yaml
+from tenacity import retry, stop_after_attempt, wait_fixed
 
 from fc_common import which
 from fc_common.config import Config
@@ -34,6 +38,38 @@ from fc_common.version import get_runtime_version
 class Client:
     daemon_pid_file = "/tmp/fc/fc_client_daemon.pid"
     etcd_url = None
+    version = get_runtime_version("fc-client")
+    me = "/".join(
+        (
+            os.environ.get("LG_HOSTNAME", gethostname()),
+            os.environ.get("LG_USERNAME", getuser()),
+        )
+    )
+
+    @staticmethod
+    def action(caller, *caller_args):
+        for caller_arg in caller_args:
+            if "format" in caller_arg and caller_arg.format == "json":
+                os.environ.setdefault("FC_DISABLE_INFO", "true")
+                break
+
+        Client.conditional_print(
+            f"FC-CLIENT VERSION: {Client.version}, "
+            "HOMEPAGE: https://fc.readthedocs.org/"
+        )
+        Client.mode_check()
+
+        caller(*caller_args)
+
+    @staticmethod
+    def conditional_print(msg):
+        if not os.environ.get("FC_DISABLE_INFO", None):
+            print(msg)
+
+    @staticmethod
+    def verbose_print(msg, args):
+        if args.verbose >= 10:
+            print(msg)
 
     @staticmethod
     def mode_check():
@@ -41,42 +77,90 @@ class Client:
         lg_crossbar = os.environ.get("LG_CROSSBAR", None)
 
         if fc_server and lg_crossbar:
-            print("MODE: single")
+            Client.conditional_print("MODE: single")
             Client.mode = "single"
         elif fc_server:
-            print("MODE: cluster (LG_CROSSBAR not set, fallback to cluster mode)")
+            Client.conditional_print(
+                "MODE: cluster (LG_CROSSBAR not set, fallback to cluster mode)"
+            )
             Client.mode = "cluster"
         elif lg_crossbar:
-            print("MODE: cluster (FC_SERVER not set, fallback to cluster mode)")
+            Client.conditional_print(
+                "MODE: cluster (FC_SERVER not set, fallback to cluster mode)"
+            )
             Client.mode = "cluster"
         else:
-            print("MODE: cluster")
+            Client.conditional_print("MODE: cluster")
             Client.mode = "cluster"
 
     @staticmethod
     def labgrid_call(args, extras):
+        verbose = ["-v"] * args.verbose
+
         metadata = Client.fetch_metadata(args.resource)
         os.environ["LG_CROSSBAR"] = metadata["lg"]
 
         # FIXME: temp fix for bootstrap command  # pylint: disable=fixme
-        if extras == ["ssh"]:
+        if extras and extras[0] in ["ssh", "scp"]:
             cmd = " ".join(extras)
             try:
                 import fc_plugins  # pylint: disable=import-outside-toplevel
 
-                cmd = fc_plugins.get_rule(metadata["lg"], cmd)
+                cmd = fc_plugins.get_rule(metadata["lg"], extras[0])
+                if len(extras) > 1:
+                    cmd += " " + " ".join(extras[1:])
             except ImportError:
                 pass
 
             os.environ["LG_PLACE"] = args.resource
-            os.execvp(
-                "labgrid-client",
-                ["labgrid-client", "-p", args.resource] + cmd.split(" "),
+            full_cmd = (
+                ["labgrid-client"] + verbose + ["-p", args.resource] + cmd.split(" ")
             )
+            Client.verbose_print(full_cmd, args)
+            os.execvp("labgrid-client", full_cmd)
+        else:
+            full_cmd = ["labgrid-client"] + verbose + ["-p", args.resource] + extras
+            Client.verbose_print(full_cmd, args)
+            os.execvp("labgrid-client", full_cmd)
+
+    @staticmethod
+    def communicate_with_server_sync(url, aim=None):
+        if aim:
+            headers = {
+                "X-FC-Client-ID": Client.me,
+                "X-FC-Client-Version": Client.version,
+                "X-FC-Aim": aim,
+            }
         else:
-            os.execvp(
-                "labgrid-client", ["labgrid-client", "-p", args.resource] + extras
+            headers = {"X-FC-Client-ID": Client.me}
+
+        output = requests.get(url, headers=headers)
+        try:
+            output_data = json.loads(output.text)
+        except json.JSONDecodeError as exc:
+            print(exc)
+            sys.exit(
+                "Fatal: unable to parse resource data,"
+                f"status_code={output.status_code},"
+                f"text={output.content}"
             )
+        return output_data
+
+    @staticmethod
+    async def communicate_with_server_async(url, timeout=5):
+        timeout = aiohttp.ClientTimeout(total=timeout)
+        async with aiohttp.ClientSession(timeout=timeout) as session:
+            try:
+                async with session.get(url) as response:
+                    output = await response.text()
+            except Exception as exc:  # pylint: disable=broad-except
+                parsed = urlparse(url)
+                fc_server = urlunparse((parsed.scheme, parsed.netloc, "", "", "", ""))
+                Client.conditional_print(
+                    f"Warning: {fc_server} skipped due to {type(exc)}"
+                )
+                return ""
+        return output
 
     @staticmethod
     def communicate_with_daemon(msg_type, para=None):
@@ -172,16 +256,7 @@ class Client:
     def cluster_info(args):
         async def get_server_info(fc_server):
             url = f"{fc_server}/server_info"
-            timeout = aiohttp.ClientTimeout(total=5)
-            async with aiohttp.ClientSession(timeout=timeout) as session:
-                try:
-                    async with session.get(url) as response:
-                        output = await response.text()
-                except Exception as exc:  # pylint: disable=broad-except
-                    print(f"Warning: {fc_server} skipped due to {type(exc)}")
-                    return ""
-
-            return output
+            return await Client.communicate_with_server_async(url)
 
         if args.resource:
             metadata = Client.fetch_metadata(args.resource)
@@ -212,16 +287,7 @@ class Client:
     def all_locks(_):
         async def get_all_locks(fc_server):
             url = f"{fc_server}/all_locks"
-            timeout = aiohttp.ClientTimeout(total=5)
-            async with aiohttp.ClientSession(timeout=timeout) as session:
-                try:
-                    async with session.get(url) as response:
-                        output = await response.text()
-                except Exception as exc:  # pylint: disable=broad-except
-                    print(f"Warning: {fc_server} skipped due to {type(exc)}")
-                    return ""
-
-            return output
+            return await Client.communicate_with_server_async(url, 10)
 
         metadata = Client.fetch_metadata("all")
 
@@ -244,7 +310,7 @@ class Client:
             specified_device_type = args.device_type
             specified_peripheral_info = args.peripheral_info
 
-            url = f"{fc_server}/resource"
+            url = f"{fc_server}/resources"
 
             if specified_resource:
                 url += f"/{specified_resource}"
@@ -261,14 +327,13 @@ class Client:
             if query_string:
                 url += f"?{query_string}"
 
-            timeout = aiohttp.ClientTimeout(total=5)
-            async with aiohttp.ClientSession(timeout=timeout) as session:
-                try:
-                    async with session.get(url) as response:
-                        output = await response.text()
-                except Exception as exc:  # pylint: disable=broad-except
-                    print(f"Warning: {fc_server} skipped due to {type(exc)}")
-                    return []
+            if args.verbose >= 2:
+                client_timeout = 15
+            else:
+                client_timeout = 5
+            output = await Client.communicate_with_server_async(url, client_timeout)
+            if output == "":
+                return []
 
             try:
                 ret = json.loads(output)
@@ -285,34 +350,44 @@ class Client:
         resources = sum(resource_data, [])
 
         if args.verbose == 0:
-            field_names = ["Resource", "Farm", "Status", "Note"]
+            field_names = ["Resource", "Farm", "Status"]
         elif args.verbose == 1:
-            field_names = ["Resource", "Farm", "Status", "Note", "Comment"]
+            field_names = ["Resource", "Farm", "Status", "Comment"]
+        elif args.verbose == 2:
+            field_names = ["Resource", "Farm", "Status", "Comment", "Label"]
         else:
             field_names = [
                 "Resource",
                 "Farm",
                 "Status",
-                "Note",
                 "Comment",
+                "Label",
                 "Info",
             ]
 
         if args.format == "json":
-            json_data = []
-            for resource in resources:
-                json_data.append(
-                    {prop.lower(): value for prop, value in zip(field_names, resource)}
-                )
-            print(json.dumps(json_data))
+            print(json.dumps(resources))
         else:
             table = prettytable.PrettyTable(align="l")
+            max_info_width = 60
 
             for resource in resources:
-                table.add_row(resource)
+                if "comment" in resource:
+                    resource["comment"] = textwrap.fill(resource["comment"], width=25)
+                for key in ("label", "info"):
+                    if key in resource:
+                        yaml_str = yaml.dump(resource[key], allow_unicode=True)
+                        if key == "info" and any(
+                            len(line) > max_info_width for line in yaml_str.splitlines()
+                        ):
+                            yaml_str = "\n".join(
+                                textwrap.fill(line, width=max_info_width)
+                                for line in yaml_str.splitlines()
+                            )
+                        resource[key] = yaml_str
+                table.add_row([resource[field.lower()] for field in field_names])
 
             table.field_names = field_names
-            table.max_width = 80
 
             print(table.get_string(sortby="Resource"))
 
@@ -320,37 +395,55 @@ class Client:
     @which(
         "labgrid-client",
         "Use 'pip3 install labgrid' or other customized way to install labgrid software please.",
-    )
+    )  # pylint: disable=too-many-branches, too-many-statements
     def lock(args):
+        def check_resource_ready():
+            print(f"Check if {resource} is free...")
+            url = f"{fc_server}/resources/{resource}"
+            output_data = Client.communicate_with_server_sync(url, "lock")
+            Client.verbose_print(output_data, args)
+
+            rc = output_data.get("rc")  # pylint: disable=invalid-name
+            if rc != 0:
+                reason = output_data.get("msg", "Unknown error")
+                if rc == 2 and "labgrid" in reason:
+                    print(reason)
+                else:
+                    sys.exit(f"Fatal: {reason}")
+
+        @retry(wait=wait_fixed(2), stop=stop_after_attempt(5))
+        def check_labgrid_resource_ready(resource):
+            cmd = f"labgrid-client -p {resource} show | grep acquired:"
+            ret, place_info_text = subprocess.getstatusoutput(cmd)
+            if ret == 0:
+                acquired = place_info_text.split()[1]
+                if acquired not in ["fc/fc", "None"]:
+                    sys.exit(
+                        f"error: place {resource} is already acquired by {acquired}"
+                    )
+                if acquired == "None":
+                    raise Exception
+
         resource = args.resource
         metadata = Client.fetch_metadata(resource)
 
         fc_server = metadata.get("fc", None)
         if not fc_server:
             sys.exit("Fatal: invalid resource")
-        else:
-            url = f"{fc_server}/resource/{resource}"
-            output = requests.get(url)
-            output_data = json.loads(output.text)
-
-            if len(output_data) == 0:
-                sys.exit("Fatal: invalid resource")
 
-            if output_data[0][3] != "":
-                sys.exit("Fatal: non-debuggable resource")
+        if resource:
+            os.environ["LG_CROSSBAR"] = metadata["lg"]
 
-        os.environ["LG_CROSSBAR"] = metadata["lg"]
+            check_resource_ready()
+            try:
+                check_labgrid_resource_ready(resource)
+            except Exception:  # pylint: disable=broad-except
+                sys.exit(
+                    f"error: place {resource} is not ready, "
+                    "contact admin to recover this device please "
+                    "if this persists after a few minutes"
+                )
 
-        if resource:
-            print(f"Check if {resource} is free")
-            cmd = f"labgrid-client -p {resource} show | grep acquired:"
-            ret, place_info_text = subprocess.getstatusoutput(cmd)
-            if ret == 0:
-                acquired = place_info_text.split()[1]
-                if acquired not in ["fc/fc", "None"]:
-                    sys.exit(
-                        f"error: place {resource} is already acquired by {acquired}"
-                    )
             print(f"Try to acquire resource {resource}...")
             with subprocess.Popen(
                 ["labgrid-client", "reserve", "--wait", f"name={resource}"],
@@ -388,13 +481,6 @@ class Client:
         metadata = Client.fetch_metadata(resource)
         os.environ["LG_CROSSBAR"] = metadata["lg"]
 
-        me = "/".join(  # pylint: disable=invalid-name
-            (
-                os.environ.get("LG_HOSTNAME", gethostname()),
-                os.environ.get("LG_USERNAME", getuser()),
-            )
-        )
-
         if resource:  # pylint: disable=too-many-nested-blocks
             cmd = f"labgrid-client -p {resource} show"
             ret, place_info_text = subprocess.getstatusoutput(cmd)
@@ -413,7 +499,7 @@ class Client:
                     for k, v in reservations.items():  # pylint: disable=invalid-name
                         if k == f"Reservation '{token}'":
                             owner = v["owner"]
-                            if owner == me:
+                            if owner == Client.me:
                                 print("Start to free the place.")
                                 signal.signal(signal.SIGINT, lambda _: "")
                                 subprocess.call(
@@ -431,23 +517,37 @@ class Client:
             sys.exit("No resource specified.")
 
 
-def main():
-    print(
-        f"FC-CLIENT VERSION: {get_runtime_version('fc-client')}, "
-        "HOMEPAGE: https://fc.readthedocs.org/"
-    )
+class VerbosityAction(argparse.Action):
+    def __call__(self, parser, namespace, values, option_string=None):
+        current = getattr(namespace, self.dest, 0)
+        if values is None:
+            setattr(namespace, self.dest, current + 1)
+        elif values.isdigit():
+            setattr(namespace, self.dest, current + int(values))
+        elif re.fullmatch(r"v+", values):
+            setattr(namespace, self.dest, current + len(values) + 1)
+        else:
+            parser.error(f"Invalid verbosity argument: {values}")
 
-    Client.mode_check()
 
+def main():
     parser = argparse.ArgumentParser()
-    parser.set_defaults(func=lambda args: parser.print_help())
+    parser.set_defaults(func=lambda _: parser.print_help())
     parser.add_argument(
         "-r", "--resource", "-p", "--place", type=str, help="resource name"
     )
     parser.add_argument("-f", "--farm-type", type=str, help="farm type")
     parser.add_argument("-d", "--device-type", type=str, help="device type")
     parser.add_argument("-i", "--peripheral-info", type=str, help="peripheral info")
-    parser.add_argument("-v", "--verbose", action="count", default=0)
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action=VerbosityAction,
+        nargs="?",
+        default=0,
+        help="increase verbosity level "
+        "(can be used multiple times or with a number: -v, -vv, -v1, -v2)",
+    )
 
     args, extras = parser.parse_known_args()
 
@@ -514,12 +614,12 @@ def main():
 
         if len(extras) > 0 and extras[0] in ["init", "i"]:
             args, extras = parser.parse_known_args(extras, namespace=args)
-            args.func(extras)
+            Client.action(args.func, extras)
         else:
             args = parser.parse_args(extras, namespace=args)
-            args.func(args)
+            Client.action(args.func, args)
     else:
-        Client.labgrid_call(args, extras)
+        Client.action(Client.labgrid_call, args, extras)
 
 
 if __name__ == "__main__":