Preparation work for script execution

Author: Simca

src/openstack_cli/commands/scripts/__init__.py

@@ -0,0 +1,25 @@
+#  Licensed to the Apache Software Foundation (ASF) under one or more
+#  contributor license agreements.  See the NOTICE file distributed with
+#  this work for additional information regarding copyright ownership.
+#  The ASF licenses this file to You under the Apache License, Version 2.0
+#  (the "License"); you may not use this file except in compliance with
+#  the License.  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+from openstack_cli.core.config import Configuration
+from openstack_cli.modules.apputils.discovery import CommandMetaInfo
+
+__module__ = CommandMetaInfo("scripts", item_help="Manage user scripts",
+                             default_sub_command="list", exec_with_child=True)
+
+
+def __init__(conf: Configuration, **kwargs):
+  print("Lol")
+  # raise NotImplementedCommandException()

src/openstack_cli/commands/scripts/list.py

@@ -0,0 +1,29 @@
+#  Licensed to the Apache Software Foundation (ASF) under one or more
+#  contributor license agreements.  See the NOTICE file distributed with
+#  this work for additional information regarding copyright ownership.
+#  The ASF licenses this file to You under the Apache License, Version 2.0
+#  (the "License"); you may not use this file except in compliance with
+#  the License.  You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+#  See the License for the specific language governing permissions and
+#  limitations under the License.
+
+
+from openstack_cli.core.config import Configuration
+from openstack_cli.core.dialogs import ask_open_directory
+from openstack_cli.modules.apputils.discovery import CommandMetaInfo
+
+__module__ = CommandMetaInfo("list", item_help="List available scripts")
+__args__ = __module__.arg_builder\
+  .add_default_argument("name", str, "dadad")\
+  .add_argument("test", str, "", default="dda")
+
+
+def __init__(conf: Configuration, name: str , test: str):
+  print(f"Args name: {name}; test: {test}")
+  print(ask_open_directory("Lol"))

src/openstack_cli/core/dialogs.py

@@ -32,6 +32,10 @@ class filedialog(object):
       def askopenfilename(*args, **kwargs):
         return None
 
+      @staticmethod
+      def askdirectory(*args, **kwargs):
+        return None
+
   if not tk_enabled:
     return None, None
 
@@ -48,3 +52,11 @@ def ask_open_file(title: str = "Select file", allowed_extensions=(('All files',
     return filedialog.askopenfilename(title=title, filetypes=allowed_extensions)
   else:
     return input(f"{title}: ")
+
+def ask_open_directory(title: str = "Coose folder") -> str:
+  root, filedialog = get_tk()
+
+  if filedialog:
+    return filedialog.askdirectory(title=title)
+  else:
+    return input(f"{title}: ")

src/openstack_cli/core/shell.py

@@ -39,8 +39,6 @@ def _f12_commands(channel: paramiko.Channel):
     print(f"\n Character code debugging is: {F12MENU}")
     if F12MENU:
       print("> ", end='', flush=True)
-  elif _k == FUNC_KEYS.F5.value:
-    channel.resize_pty(*get_terminal_size())
   elif _k == (99,):  # C:
     SIGINT = True
   elif _k == (105,): # I
@@ -98,12 +96,13 @@ def __buffered_reader(stdread: paramiko.ChannelFile, stdwrite: TextIO):
   import time
   channel: paramiko.Channel = stdread.channel
   while not SIGINT and not channel.exit_status_ready():
-    time.sleep(0.2)
     if channel.recv_ready():
       r, w, x = select.select([channel], [], [], 0.0)
       if len(r) > 0:
         stdwrite.buffer.write(channel.recv(1024))
         stdwrite.flush()
+    else:
+       time.sleep(0.2)
 
   SIGINT = True
 
@@ -125,16 +124,15 @@ def __window_size_change_handler(channel: paramiko.Channel):
     time.sleep(1)
     nwidth, nheight = get_terminal_size()
     if nwidth != width or nheight != height:
-      width = nwidth
-      height = nheight
+      width, height = nwidth, nheight
       channel.resize_pty(width=width, height=height)
 
 
 def shell(channel: paramiko.Channel):
   stdin: paramiko.ChannelFile = channel.makefile_stdin("wb")
   stdout: paramiko.ChannelFile = channel.makefile("r")
   stderr: paramiko.ChannelFile = channel.makefile_stderr("r")
-  print("Tip: F12 + I to show connection info, F12+C to close connection, F12+F5 force PTY size update")
+  print("Tip: F12 + I to show connection info, F12+C to close connection")
 
   stdoutReader = Thread(target=__buffered_reader, name="stdoutReader", args=(stdout, sys.stdout))
   stderrReader = Thread(target=__buffered_reader, name="stderrReader", args=(stderr, sys.stderr))
@@ -156,8 +154,11 @@ def shell(channel: paramiko.Channel):
     stdinWriter.start()
 
     stdoutReader.join()
-    print("Closing ssh session...")
-    channel.close()
   finally:
+    print("Closing ssh session...")
+    try:
+      channel.close()
+    except:
+      pass
     signal.signal(signal.SIGINT, orig_sigint)
 

src/openstack_cli/modules/apputils/discovery/__init__.py

@@ -109,42 +109,54 @@ def command_arguments(self) -> List[str]:
   def kwargs_name(self) -> List[str]:
     return list(self._options.kwargs.keys())
 
-  def _get_command(self, injected_args: dict = None, fail_on_unknown: bool = False) -> CommandModule:
+  def _get_command(self, injected_args: dict = None, fail_on_unknown: bool = False) -> List[CommandModule]:
     if not self._options.args:
       raise NoCommandException(None, "No command passed, unable to continue")
 
+    command_chain: List[CommandModule] = []
     command: CommandModule = self._modules[self._options.args[0]]  # [command name]
     command_args = self._options.args[1:]
 
+    # Process all command in sub-command chain [command1] [command2] .. [last command]
     while command_args:
       if command_args[0] not in command.subcommand_names:
         break
       command_name = command_args[0]
       command_args = command_args[1:]
 
-      command = command.get_subcommand(command_name)  # [command name] {subcommand}
+      if command.meta_info.exec_with_child:
+        command_chain.append(command)
+      command = command.get_subcommand(command_name)
 
+    # Now process the last command "default sub-command" forward if present
     if command.meta_info.default_sub_command and \
        command.meta_info.default_sub_command in command.subcommand_names:
 
-      command = command.get_subcommand(command.meta_info.default_sub_command)  # [command name] {subcommand} {sub}
+      if command.meta_info.exec_with_child:
+        command_chain.append(command)
+      command = command.get_subcommand(command.meta_info.default_sub_command)
 
+    command_chain.append(command)
     inj_args = set(injected_args.keys()) if injected_args else set()
-    command.set_argument(command_args, self._options.kwargs, inj_args, fail_on_unknown)
+    for _command in command_chain:
+     _require_transform = True if _command == command else False
+     _command.set_argument(command_args, self._options.kwargs, inj_args, fail_on_unknown, not _require_transform)
 
-    return command
+    return command_chain
 
   def execute_command(self, injected_args: dict = None):
     try:
-      command = self._get_command(injected_args)
-      command.execute(injected_args)
+      commands = self._get_command(injected_args)
+      for command in commands:
+        command.execute(injected_args)
     except CommandArgumentException as e:
       raise NoCommandException(None, f"Application arguments exception: {str(e)}\n")
 
   async def execute_command_async(self, injected_args: dict = None):
     try:
-      command = self._get_command()
-      await command.execute_async(injected_args)
+      commands = self._get_command()
+      for command in commands:
+        await command.execute_async(injected_args)
     except CommandArgumentException as e:
       raise NoCommandException(None, f"Application arguments exception: {str(e)}\n")
 
@@ -168,8 +180,9 @@ def start_application(self, kwargs: dict = None):
     # ToDO: add default command to be executed if no passed
     self.__inject_help_command()
     try:
-      command = self._get_command(injected_args=kwargs, fail_on_unknown=True)
-      command.execute(injected_args=kwargs)
+      commands = self._get_command(injected_args=kwargs, fail_on_unknown=True)
+      for command in commands:
+        command.execute(injected_args=kwargs)
     except NotImplementedCommandException:
       sys.stdout.write(generate_help(self._modules, self._options, *self.__get_modules_from_args()))
       pass

src/openstack_cli/modules/apputils/discovery/commands.py

@@ -157,12 +157,24 @@ def get_default_argument(self, index: int) -> CommandArgumentItem:
 
 
 class CommandMetaInfo(object):
-  def __init__(self, name: str, item_help: str = "", default_sub_command: str = "", **kwargs):
+  def __init__(self,
+               name: str,
+               item_help: str = "",
+               default_sub_command: str = "",
+               exec_with_child: bool = False,
+               **kwargs):
+    """
+    :arg name Name of the command
+    :arg item_help Help description of the command
+    :arg default_sub_command In case if command have sub-commands, name of sub-command to execute on requesting base command
+    :arg exec_with_child execute base command first, then sub-command. Valid to make command-wide checks.
+    """
     self._name = name
     self._arguments = CommandArgumentsBuilder()
     self._help = item_help
     self._kwargs = kwargs
     self._default_sub_command = default_sub_command
+    self._exec_with_child = exec_with_child
 
   @property
   def options(self) -> dict:
@@ -180,6 +192,15 @@ def help(self) -> str:
   def default_sub_command(self) -> str:
     return self._default_sub_command
 
+  @property
+  def exec_with_child(self) -> bool:
+    """
+    Execute base command first, then sub-command. Valid to make command-wide checks
+
+    Base command would be feeded with same commands as sub-command with disabled meta-info check
+    """
+    return self._exec_with_child
+
   @property
   def arguments(self) -> dict:
     return self._arguments.arguments
@@ -288,20 +309,38 @@ def __init__(self, meta_info: CommandMetaInfo, classpath: str, import_name: str,
     if parent:
       self.__meta_info.arg_builder.merge(parent.__meta_info.arg_builder)
 
-  def set_argument(self, args: list, kwargs: dict, injected_args: set = None, fail_on_unknown=False):
+  def set_argument(self, args: list, kwargs: dict, injected_args: set = None,
+                   fail_on_unknown=False,
+                   skip_transform: bool = False):
+    """
+
+    :arg args list of default arguments
+    :arg kwargs: list of kwargs
+    :arg injected_args: list of added argumants
+    :arg fail_on_unknown:  option to throw exception if unknown argument found
+    :arg skip_transform:  skip argument transformation according to command meta. Usefull if the command is not
+                          the last in the execution chain
+
+    """
     if not injected_args:
       injected_args = set()
 
-    args = self.__meta_info.transform_default_arguments(args, fail_on_unknown=fail_on_unknown)
-    args.update(self.__meta_info.transform_arguments(kwargs, injected_args, fail_on_unknown=fail_on_unknown))
+    if not skip_transform:
+      args = self.__meta_info.transform_default_arguments(args, fail_on_unknown=fail_on_unknown)
+      args.update(self.__meta_info.transform_arguments(kwargs, injected_args, fail_on_unknown=fail_on_unknown))
 
-    f_args = self.entry_point_args
+      f_args = self.entry_point_args
 
-    if len(f_args) - len(set(f_args) & injected_args) != len(set(args.keys()) & set(f_args)):
-      raise CommandArgumentException("Function \"{}\" from module {} doesn't implement all arguments in the"
-                                     " signature or implements unknown definition".format(
-                                       self.__entry_point.__name__, self.__classpath
-                                     ))
+      if len(f_args) - len(set(f_args) & injected_args) != len(set(args.keys()) & set(f_args)):
+        raise CommandArgumentException("Function \"{}\" from module {} doesn't implement all arguments in the"
+                                       " signature or implements unknown definition".format(
+                                         self.__entry_point.__name__, self.__classpath
+                                       ))
+    else:
+      args = {
+        '_': args
+      }
+      args.update(kwargs)
     self.__args = args
 
   def add_subcommand(self, cmds):