pyinfra 3.0b0__py2.py3-none-any.whl → 3.0b1__py2.py3-none-any.whl

pyinfra_cli/prints.py

@@ -217,7 +217,7 @@ def pretty_op_name(op_meta):
 
 def print_meta(state: "State"):
     rows: List[Tuple[Callable, Union[List[str], str]]] = [
-        (logger.info, ["Operation", "Hosts"]),
+        (logger.info, ["Operation", "Change", "Conditional Change"]),
     ]
 
     for op_hash in state.get_op_order():
@@ -237,14 +237,18 @@ def print_meta(state: "State"):
                 logger.info,
                 [
                     pretty_op_name(state.op_meta[op_hash]),
-                    "{0}{1}/{2} ({3})".format(
+                    "-"
+                    if len(hosts_in_op) == 0
+                    else "{0} ({1})".format(
                         len(hosts_in_op),
-                        f"-{len(hosts_maybe_in_op)}" if hosts_maybe_in_op else "",
-                        len(state.inventory),
-                        truncate(", ".join(sorted(hosts_in_op + hosts_maybe_in_op)), 48),
-                    )
-                    if hosts_in_op or hosts_maybe_in_op
-                    else "No hosts with changes at this time",
+                        truncate(", ".join(sorted(hosts_in_op)), 48),
+                    ),
+                    "-"
+                    if len(hosts_maybe_in_op) == 0
+                    else "{0} ({1})".format(
+                        len(hosts_maybe_in_op),
+                        truncate(", ".join(sorted(hosts_maybe_in_op)), 48),
+                    ),
                 ],
             )
         )
@@ -261,23 +265,21 @@ def print_results(state: "State"):
         hosts_in_op = 0
         hosts_in_op_success: list[str] = []
         hosts_in_op_error: list[str] = []
-        hosts_in_op_no_attempt: list[str] = []
+        hosts_in_op_no_change: list[str] = []
         for host in state.inventory.iter_activated_hosts():
             if op_hash not in state.ops[host]:
                 continue
 
             hosts_in_op += 1
 
-            result = state.ops[host][op_hash].operation_meta.did_succeed()
-            if result is True:
-                hosts_in_op_success.append(host.name)
-            elif result is False:
-                hosts_in_op_error.append(host.name)
+            op_meta = state.ops[host][op_hash].operation_meta
+            if op_meta.did_succeed():
+                if op_meta._did_change():
+                    hosts_in_op_success.append(host.name)
+                else:
+                    hosts_in_op_no_change.append(host.name)
             else:
-                hosts_in_op_no_attempt.append(host.name)
-
-        # if not hosts_in_op:
-        #     continue
+                hosts_in_op_error.append(host.name)
 
         row = [
             pretty_op_name(state.op_meta[op_hash]),
@@ -292,95 +294,11 @@ def print_results(state: "State"):
             row.append(f"{len(hosts_in_op_error)}")
         else:
             row.append("-")
-        if hosts_in_op_no_attempt:
-            row.append(f"{len(hosts_in_op_no_attempt)}")
+        if hosts_in_op_no_change:
+            row.append(f"{len(hosts_in_op_no_change)}")
         else:
             row.append("-")
 
         rows.append((logger.info, row))
 
     print_rows(rows)
-
-
-def get_fucked(state: "State"):
-    group_combinations = _get_group_combinations(state.inventory.iter_activated_hosts())
-    rows: List[Tuple[Callable, Union[List[str], str]]] = []
-
-    for i, (groups, hosts) in enumerate(group_combinations.items(), 1):
-        if not hosts:
-            continue
-
-        if groups:
-            rows.append(
-                (
-                    logger.info,
-                    "Groups: {0}".format(
-                        click.style(" / ".join(groups), bold=True),
-                    ),
-                ),
-            )
-        else:
-            rows.append((logger.info, "Ungrouped:"))
-
-        for host in hosts:
-            # Didn't connect to this host?
-            if host not in state.activated_hosts:
-                rows.append(
-                    (
-                        logger.info,
-                        [
-                            host.style_print_prefix("red", bold=True),
-                            click.style("No connection", "red"),
-                        ],
-                    ),
-                )
-                continue
-
-            results = state.results[host]
-
-            meta = state.meta[host]
-            success_ops = results.success_ops
-            partial_ops = results.partial_ops
-            # TODO: type meta object
-            changed_ops = success_ops - meta.ops_no_change  # type: ignore
-            error_ops = results.error_ops
-            ignored_error_ops = results.ignored_error_ops
-
-            host_args = ("green",)
-            host_kwargs = {}
-
-            # If all ops got complete
-            if results.ops == meta.ops:
-                # We had some errors - but we ignored them - so "warning" color
-                if error_ops != 0:
-                    host_args = ("yellow",)
-
-            # Ops did not complete!
-            else:
-                host_args = ("red",)
-                host_kwargs["bold"] = True
-
-            changed_str = "Changed: {0}".format(click.style(f"{changed_ops}", bold=True))
-            if partial_ops:
-                changed_str = f"{changed_str} ({partial_ops} partial)"
-
-            error_str = "Errors: {0}".format(click.style(f"{error_ops}", bold=True))
-            if ignored_error_ops:
-                error_str = f"{error_str} ({ignored_error_ops} ignored)"
-
-            rows.append(
-                (
-                    logger.info,
-                    [
-                        host.style_print_prefix(*host_args, **host_kwargs),
-                        changed_str,
-                        "No change: {0}".format(click.style(f"{meta.ops_no_change}", bold=True)),
-                        error_str,
-                    ],
-                ),
-            )
-
-        if i != len(group_combinations):
-            rows.append((lambda m: click.echo(m, err=True), []))
-
-    print_rows(rows)

tests/test_api/test_api_deploys.py

@@ -40,7 +40,7 @@ class TestDeploysApi(PatchSSHTestCase):
         run_ops(state)
 
         first_op_hash = op_order[0]
-        assert state.op_meta[first_op_hash].names == {"test_deploy | Server/Shell"}
+        assert state.op_meta[first_op_hash].names == {"test_deploy | server.shell"}
         assert state.ops[somehost][first_op_hash].operation_meta._commands == [
             StringCommand("echo first command"),
         ]
@@ -49,7 +49,7 @@ class TestDeploysApi(PatchSSHTestCase):
         ]
 
         second_op_hash = op_order[1]
-        assert state.op_meta[second_op_hash].names == {"test_deploy | Server/Shell"}
+        assert state.op_meta[second_op_hash].names == {"test_deploy | server.shell"}
         assert state.ops[somehost][second_op_hash].operation_meta._commands == [
             StringCommand("echo second command"),
         ]
@@ -104,21 +104,21 @@ class TestDeploysApi(PatchSSHTestCase):
         run_ops(state)
 
         first_op_hash = op_order[0]
-        assert state.op_meta[first_op_hash].names == {"test_deploy | Server/Shell"}
+        assert state.op_meta[first_op_hash].names == {"test_deploy | server.shell"}
         assert state.ops[somehost][first_op_hash].operation_meta._commands == [
             StringCommand("echo first command"),
         ]
 
         second_op_hash = op_order[1]
         assert state.op_meta[second_op_hash].names == {
-            "test_deploy | test_nested_deploy | Server/Shell",
+            "test_deploy | test_nested_deploy | server.shell",
         }
         assert state.ops[somehost][second_op_hash].operation_meta._commands == [
             StringCommand("echo nested command"),
         ]
 
         third_op_hash = op_order[2]
-        assert state.op_meta[third_op_hash].names == {"test_deploy | Server/Shell"}
+        assert state.op_meta[third_op_hash].names == {"test_deploy | server.shell"}
         assert state.ops[somehost][third_op_hash].operation_meta._commands == [
             StringCommand("echo second command"),
         ]

tests/test_api/test_api_operations.py

@@ -78,7 +78,7 @@ class TestOperationsApi(PatchSSHTestCase):
         first_op_hash = op_order[0]
 
         # Ensure the op name
-        assert state.op_meta[first_op_hash].names == {"Files/File"}
+        assert state.op_meta[first_op_hash].names == {"files.file"}
 
         # Ensure the global kwargs (same for both hosts)
         somehost_global_arguments = state.ops[somehost][first_op_hash].global_arguments
@@ -433,11 +433,11 @@ class TestNestedOperationsApi(PatchSSHTestCase):
 
         try:
             outer_result = server.shell(commands="echo outer")
-            assert outer_result._combined_output_lines is None
+            assert outer_result._combined_output is None
 
             def callback():
                 inner_result = server.shell(commands="echo inner")
-                assert inner_result._combined_output_lines is not None
+                assert inner_result._combined_output is not None
 
             python.call(function=callback)
 
@@ -447,7 +447,7 @@ class TestNestedOperationsApi(PatchSSHTestCase):
 
             assert len(state.get_op_order()) == 3
             assert state.results[somehost].success_ops == 3
-            assert outer_result._combined_output_lines is not None
+            assert outer_result._combined_output is not None
 
             disconnect_all(state)
         finally:

tests/test_connectors/test_ssh.py

@@ -1001,3 +1001,55 @@ class TestSSHConnector(TestCase):
                     "not-another-file",
                     print_output=True,
                 )
+
+    @patch("pyinfra.connectors.ssh.SSHClient")
+    @patch("time.sleep")
+    def test_ssh_connect_fail_retry(self, fake_sleep, fake_ssh_client):
+        for exception_class in (
+            SSHException,
+            gaierror,
+            socket_error,
+            EOFError,
+        ):
+            inventory = make_inventory(
+                hosts=("unresposivehost",), override_data={"ssh_connect_retries": 1}
+            )
+            State(inventory, Config())
+
+            unresposivehost = inventory.get_host("unresposivehost")
+            assert unresposivehost.data.ssh_connect_retries == 1
+
+            fake_ssh = MagicMock()
+            fake_ssh.connect.side_effect = exception_class()
+            fake_ssh_client.return_value = fake_ssh
+
+            with self.assertRaises(ConnectError):
+                unresposivehost.connect(show_errors=False, raise_exceptions=True)
+            assert fake_sleep.called_once()
+            assert fake_ssh_client.connect.called_twice()
+
+    @patch("pyinfra.connectors.ssh.SSHClient")
+    @patch("time.sleep")
+    def test_ssh_connect_fail_success(self, fake_sleep, fake_ssh_client):
+        for exception_class in (
+            SSHException,
+            gaierror,
+            socket_error,
+            EOFError,
+        ):
+            inventory = make_inventory(
+                hosts=("unresposivehost",), override_data={"ssh_connect_retries": 1}
+            )
+            State(inventory, Config())
+
+            unresposivehost = inventory.get_host("unresposivehost")
+            assert unresposivehost.data.ssh_connect_retries == 1
+
+            connection = MagicMock()
+            fake_ssh = MagicMock()
+            fake_ssh.connect.side_effect = [exception_class(), connection]
+            fake_ssh_client.return_value = fake_ssh
+
+            unresposivehost.connect(show_errors=False, raise_exceptions=True)
+            assert fake_sleep.called_once()
+            assert fake_ssh_client.connect.called_twice()

tests/test_connectors/test_terraform.py

@@ -7,20 +7,23 @@ from pyinfra.connectors.terraform import TerraformInventoryConnector
 
 
 class TestTerraformConnector(TestCase):
-    def test_make_names_data_no_output_key(self):
-        with self.assertRaises(InventoryError) as context:
-            list(TerraformInventoryConnector.make_names_data())
-
-        assert context.exception.args[0] == "No Terraform output key!"
-
     @patch("pyinfra.connectors.terraform.local.shell")
     def test_make_names_data_no_output(self, fake_shell):
-        fake_shell.return_value = json.dumps({})
+        fake_shell.return_value = json.dumps(
+            {
+                "hello": {
+                    "world": [],
+                },
+            },
+        )
 
         with self.assertRaises(InventoryError) as context:
             list(TerraformInventoryConnector.make_names_data("output_key"))
 
-        assert context.exception.args[0] == "No Terraform output with key: `output_key`"
+        assert (
+            context.exception.args[0]
+            == "No Terraform output with key: `output_key`, valid keys:\n   - hello.world"
+        )
 
     @patch("pyinfra.connectors.terraform.local.shell")
     def test_make_names_data_invalid_output(self, fake_shell):

tests/test_connectors/test_vagrant.py

@@ -69,7 +69,7 @@ class TestVagrantConnector(TestCase):
     )
     @patch("pyinfra.connectors.vagrant.path.exists", lambda path: True)
     def test_make_names_data_with_options(self):
-        data = VagrantInventoryConnector.make_names_data()
+        data = list(VagrantInventoryConnector.make_names_data())
 
         assert data == [
             (
@@ -103,7 +103,7 @@ class TestVagrantConnector(TestCase):
         ]
 
     def test_make_names_data_with_limit(self):
-        data = VagrantInventoryConnector.make_names_data(limit=("ubuntu16",))
+        data = list(VagrantInventoryConnector.make_names_data(name=("ubuntu16",)))
 
         assert data == [
             (
@@ -120,4 +120,4 @@ class TestVagrantConnector(TestCase):
 
     def test_make_names_data_no_matches(self):
         with self.assertRaises(InventoryError):
-            VagrantInventoryConnector.make_names_data(limit="nope")
+            list(VagrantInventoryConnector.make_names_data(name="nope"))

pyinfra_cli/inventory_dsl.py

@@ -1,23 +0,0 @@
-class Host:
-    name: str
-    data: dict
-
-    def __init__(self, name, **data) -> None:
-        self.name = name
-        self.data = data
-
-
-class Group:
-    hosts: list[Host]
-    data: dict
-
-    def __init__(self, *hosts: Host, **data) -> None:
-        self.hosts = list(hosts)
-        self.data = data
-
-    def __iter__(self):
-        for host in self.hosts:
-            yield host
-
-    def append(self, *hosts: Host) -> None:
-        self.hosts.extend(hosts)