CLI: Bedrock support and misc improvements

mcstatus/__main__.py

@@ -1,10 +1,13 @@
 from __future__ import annotations
 
+import dns.resolver
 import sys
+import json as _json
 import argparse
 import socket
+import warnings
+import dataclasses
 from typing import TYPE_CHECKING
-from json import dumps as json_dumps
 
 from mcstatus import JavaServer, BedrockServer
 from mcstatus.responses import JavaStatusResponse
@@ -22,10 +25,33 @@ def _motd(motd: Motd) -> str:
 
 
 def ping(server: SupportedServers) -> int:
-    # this method supports both Java and Bedrock.
-    # only Java supports the `ping` packet, and even then not always:
-    # https://github.com/py-mine/mcstatus/issues/850
-    print(f"{server.status().latency}")
+    notsup = "notsup"
+
+    # handle java and bedrock differences, as well as non-conformant servers
+    # which require a 'status' packet.
+
+    try:
+        ping_res = server.ping() if isinstance(server, JavaServer) else notsup
+    except Exception as e:
+        ping_res = e
+
+    # at this point, ping_res is NOTSUP for Bedrock, otherwise it is either a float or an Exception.
+
+    if isinstance(ping_res, (float, int)):
+        latency = ping_res
+    else:
+        latency = server.status().latency
+
+        if ping_res != notsup:
+            addr = f"{server.address.host}:{server.address.port}"
+            warnings.warn(
+                f"contacting {addr} failed with a 'ping' packet but succeeded with a 'status' packet,\n  "
+                f"this is likely a bug in the server-side implementation.\n  "
+                f"for more details, see: https://mcstatus.readthedocs.io/en/stable/pages/faq/\n",
+                stacklevel=1,
+            )
+
+    print(f"{latency}")
     return 0
 
 
@@ -52,35 +78,38 @@ def status(server: SupportedServers) -> int:
 
 
 def json(server: SupportedServers) -> int:
-    data = {}
-    data["online"] = False
-    data["kind"] = server.kind()
-    # Build data with responses and quit on exception
+    data = {"online": False, "kind": server.kind()}
+
+    status_res = query_res = None
     try:
         status_res = server.status(tries=1)
-        java_res = status_res if isinstance(status_res, JavaStatusResponse) else None
-        data["version"] = status_res.version.name
-        data["protocol"] = status_res.version.protocol
-        data["motd"] = status_res.motd.to_minecraft()
-        data["player_count"] = status_res.players.online
-        data["player_max"] = status_res.players.max
-        data["players"] = []
-        if java_res and java_res.players.sample is not None:
-            data["players"] = [{"name": player.name, "id": player.id} for player in java_res.players.sample]
-
-        data["ping"] = status_res.latency
-        data["online"] = True
-
         if isinstance(server, JavaServer):
             query_res = server.query(tries=1)
-            data["host_ip"] = query_res.raw["hostip"]
-            data["host_port"] = query_res.raw["hostport"]
-            data["map"] = query_res.map
-            data["plugins"] = query_res.software.plugins
-    except Exception:  # TODO: Check what this actually excepts
-        pass
-
-    print(json_dumps(data))
+    except Exception as e:
+        if status_res is None:
+            data["error"] = str(e)
+
+    # construct 'data' dict outside try/except to ensure data processing errors
+    # are noticed.
+    data["online"] = bool(status_res or query_res)
+    if status_res is not None:
+        data["status"] = dataclasses.asdict(status_res)
+
+        # XXX: hack to fixup MOTD serialisation. should be implemented elsewhere.
+        assert "motd" in data["status"]
+        data["status"]["motd"] = {"raw": status_res.motd.to_minecraft()}
+
+    if query_res is not None:
+        # TODO: QueryResponse is not (yet?) a dataclass
+        data["query"] = qdata = {}
+
+        qdata["host_ip"] = query_res.raw["hostip"]
+        qdata["host_port"] = query_res.raw["hostport"]
+        qdata["map"] = query_res.map
+        qdata["plugins"] = query_res.software.plugins
+        qdata["raw"] = query_res.raw
+
+    _json.dump(data, sys.stdout)
     return 0
 
 
@@ -139,11 +168,11 @@ def main(argv: list[str]) -> int:
 
     args = parser.parse_args(argv)
     lookup = JavaServer.lookup if not args.bedrock else BedrockServer.lookup
-    server = lookup(args.address)
 
     try:
+        server = lookup(args.address)
         return args.func(server)
-    except (socket.timeout, socket.gaierror, ValueError) as e:
+    except (socket.timeout, socket.gaierror, dns.resolver.NoNameservers) as e:
         # catch and hide traceback for expected user-facing errors
         print(f"Error: {e}", file=sys.stderr)
         return 1