Support both libssh and paramiko

* Swap to `get_file` and `copy_file` from `Connection` in `network_cli.py` to support both `libssh` and `paramiko`
* Restore the `network_cli` check
* Add diff mode support
* Add check mode support

Author: timway

plugins/action/net_put.py

@@ -10,13 +10,55 @@
 import os
 import tempfile
 
+from ansible.module_utils.common.text.converters import to_bytes, to_text
 from ansible.plugins.action import ActionBase
+from ansible.plugins.loader import lookup_loader
 from ansible.utils.display import Display
 from ansible.utils.hashing import checksum
 
 
 display = Display()
 
+# def _get_binary_src_file(self, src):
+
+#     if not os.path.exists(source):
+#         raise ValueError("path specified in src not found")
+
+#     return source
+
+# def _handle_src_option(self, convert_data=True):
+#     else:
+#         source = self._loader.path_dwim_relative(working_path, "templates", src)
+#         if not source:
+#             source = self._loader.path_dwim_relative(working_path, src)
+
+#     if not os.path.exists(source):
+#         raise AnsibleError("path specified in src not found")
+
+#     try:
+#         with open(source, "r") as f:
+#             template_data = to_text(f.read())
+#     except IOError as e:
+#         raise AnsibleError(
+#             "unable to load src file {0}, I/O error({1}): {2}".format(
+#                 source, e.errno, e.strerror
+#             )
+#         )
+
+#     # Create a template search path in the following order:
+#     # [working_path, self_role_path, dependent_role_paths, dirname(source)]
+#     searchpath = [working_path]
+#     if self._task._role is not None:
+#         searchpath.append(self._task._role._role_path)
+#         if hasattr(self._task, "_block:"):
+#             dep_chain = self._task._block.get_dep_chain()
+#             if dep_chain is not None:
+#                 for role in dep_chain:
+#                     searchpath.append(role._role_path)
+#     searchpath.append(os.path.dirname(source))
+#     self._templar.environment.loader.searchpath = searchpath
+#     self._task.args["src"] = self._templar.template(template_data)
+
 
 class ActionModule(ActionBase):
 
@@ -28,6 +70,20 @@ def __init__(self, *args, **kwargs):
     def run(self, tmp=None, task_vars=None):
         result = super(ActionModule, self).run(task_vars=task_vars)
 
+        if "changed" not in result:
+            result["changed"] = False
+
+        persistent_connection = self._play_context.connection.split(".")[-1]
+        if persistent_connection != "network_cli":
+            # It is supported only with network_cli
+            return {
+                "failed": True,
+                "msg": (
+                    "connection type %s is not valid for net_put module, please use fully "
+                    "qualified name of network_cli connection type" % self._play_context.connection
+                ),
+            }
+
         try:
             self._src = self._task.args.get("src")
         except KeyError as exc:
@@ -42,21 +98,31 @@ def run(self, tmp=None, task_vars=None):
         self._mode = self._task.args.get("mode", "binary")
         self._protocol = self._task.args.get("protocol", "scp")
 
-        self._src_real_file = self._loader.get_real_file(self._src, decrypt=self._decrypt)
+        working_path = self._get_working_path()
+        if os.path.isabs(self._src):
+            self._src_real_file = self._loader.get_real_file(self._src, decrypt=self._decrypt)
+        elif self._loader.path_dwim_relative(working_path, "templates", self._src) != "":
+            self._src_real_file = self._loader.path_dwim_relative(
+                working_path, "templates", self._src
+            )
+        elif self._loader.path_dwim_relative(working_path, self._src):
+            self._src_real_file = self._loader.path_dwim_relative(working_path, self._src)
 
         try:
             fetched_fd, fetched_fp = tempfile.mkstemp(prefix="")
             rendered_fd, rendered_fp = tempfile.mkstemp(prefix="")
 
-            if self._mode == "binary":
+            if "binary" == self._mode:
                 self._rendered_real_file = self._src_real_file
-            elif self._mode == "text":
+            elif "text" == self._mode:
                 self._rendered_real_file = rendered_fp
-                template_result = self._execute_module(
-                    module_name="ansible.builtin.template",
-                    module_args={"dest": self._rendered_real_file, "src": self._src_real_file},
-                    task_vars=task_vars,
+                lookup = lookup_loader.get(
+                    "ansible.builtin.template", loader=self._loader, templar=self._templar
                 )
+                template_result = lookup.run([self._src], variables=task_vars)
+
+                with open(self._rendered_real_file, "wb") as fh:
+                    fh.write(to_bytes(template_result[0]))
             self._rendered_checksum = checksum(self._rendered_real_file)
 
             display.vv(
@@ -65,29 +131,46 @@ def run(self, tmp=None, task_vars=None):
             )
 
             try:
-                self._connection._ssh_type_conn.fetch_file(self._dest, fetched_fp, self._protocol)
+                self._connection.get_file(self._dest, fetched_fp, self._protocol)
             except Exception as exc:
+                error = to_text(exc).lower()
                 if not (
-                    "Error receiving information about file" in exc.message
-                    and "No such file or directory" in exc.message
+                    "error receiving information about file" in error
+                    or "no such file or directory" in error
                 ):
                     raise exc
-                display.vv("The file is not present on the remote device")
-            finally:
-                self._connection._ssh_type_conn.reset()
-                self._dest_checksum = checksum(fetched_fp)
-
-            try:
-                if self._dest_checksum != self._rendered_checksum:
-                    self._connection._ssh_type_conn.put_file(
+            self._dest_checksum = checksum(fetched_fp)
+
+            if self._dest_checksum != self._rendered_checksum:
+                result["changed"] = True
+
+                if self._task._diff:
+                    if "binary" == self._mode:
+                        result["diff"] = {
+                            "before": self._dest_checksum,
+                            "after": self._rendered_checksum,
+                        }
+                    elif "text" == self._mode:
+                        with open(fetched_fp, "r") as fh:
+                            result["diff"] = {
+                                "before": to_text(fh.read()),
+                                "after": template_result[0],
+                            }
+
+                if not self._task.check_mode:
+                    self._connection.copy_file(
                         self._loader.get_real_file(self._rendered_real_file),
                         self._dest,
                         self._protocol,
                     )
-            finally:
-                self._connection._ssh_type_conn.reset()
 
             return result
         finally:
             os.remove(fetched_fp)
             os.remove(rendered_fp)
+
+    def _get_working_path(self):
+        cwd = self._loader.get_basedir()
+        if self._task._role is not None:
+            cwd = self._task._role._role_path
+        return cwd

plugins/connection/libssh.py

@@ -630,6 +630,8 @@ def fetch_file(self, in_path, out_path, proto="sftp"):
                 scp.get(in_path, out_path)
             except LibsshSCPException as exc:
                 raise AnsibleError("Error transferring file from %s: %s" % (out_path, to_text(exc)))
+            finally:
+                self.reset()
         else:
             raise AnsibleError("Don't know how to transfer file over protocol %s" % proto)