cloudbox-server 0.0.1

data/lib/exec/command_option.rb

@@ -0,0 +1,222 @@
+# This file is part of cloudbox-server project
+# @author tmarmin (INGENSI)
+
+require "common/cloudbox_exceptions"
+require 'rubygems'
+require 'optparse'
+require 'pathname'
+require 'json'
+
+module Exec
+  # This class is an helper to the ParserOption class which manages ans parse options given to a linux command.
+  # @author tmarmin
+  class CommandOption
+
+    public
+    # Get the values
+    attr_reader :values
+
+    protected
+    # The OptionParser object
+    @opt_parser
+    # The options list
+    @options
+    # The argv tab
+    @argv
+    # The command name
+    @command_name
+
+    public
+    # Default constructor
+    # @author tmarmin
+    def initialize(command_name, argv)
+      @options = {}
+      @argv = argv
+      @command_name = command_name
+    end
+
+    public
+    # Declare new option
+    # @param short_name [String] Short name (String.length=1) of the option
+    # @param long_name [String] The long name of the option
+    # @param description [String] Description of the option
+    # @param mandatory [Boolean] If true verify method will raise an error if the option is not
+    # @param require_value [Boolean] If true, a value is needed for this option.
+    # @param check_format [Method] A method which take only one string in parameter and return a boolean (it will be
+    #   used to validate the option) in argv.
+    def add_option(short_name, long_name, description, mandatory, require_value = false, check_format = nil)
+      raise NameError.new("Duplicate option name") if @options.include?(long_name)
+      @options.store(long_name, Option.new(short_name, long_name, description, mandatory, require_value, check_format))
+    end
+
+    public
+    # @return The option parser help.
+    # @author tmarmin
+    def get_help
+      return @opt_parser.help
+    end
+
+    public
+    # Generate a basic usage.
+    # @note Should be overrided in inherited classes to generate a consistent banner.
+    # A banner generaly looks like :
+    # Usage: command_name -arg1 VALUE_1 [-optional1 OPT_VAL_1]
+    # @return The help banner
+    # @author tmarmin
+    def get_banner
+      usage = "Usage: #@command_name "
+      get_sorted_options().each do |option|
+        usage += option.to_usage_s + " "
+      end
+      return usage
+    end
+
+    public
+    # @return [Array<Option>] a sorted array where mandatory are in first place.
+    def get_sorted_options
+      return @options.values.sort { |x, y| y.mandatory.to_s <=> x.mandatory.to_s }
+    end
+
+    public
+    # This method verifies if given arguments are valid.
+    # @return [Hash] The arguments passed
+    # @raise ...
+    def verify()
+      initialize_option_values()
+
+      @opt_parser = OptionParser.new do |opt|
+        opt.banner = get_banner()
+        opt.separator "Options"
+
+        @options.each_value do |option|
+
+          # adding the option value
+          if option.require_value
+            opt.on("-#{option.short_name}", "--#{option.long_name} #{option.value_name}", option.description) do |value|
+              @values[option.long_name] = value
+            end
+          else
+            opt.on("-#{option.short_name}", "--#{option.long_name}", option.description) do
+              @values[option.long_name] = true
+            end
+          end
+        end
+      end
+
+      begin
+        @opt_parser.parse(@argv)
+      rescue OptionParser::InvalidArgument, OptionParser::InvalidOption => e
+        raise Common::InvalidParameter.new(e.message, @opt_parser.to_s)
+      rescue OptionParser::ParseError => e
+        raise Common::ParameterError.new(e.message, @opt_parser.to_s)
+      end
+      @options.each_value do |option|
+        if @values.include?(option.long_name) && option.require_value && !option.check_format.nil?
+          valid, msg = option.valid_value?(@values[option.long_name])
+          raise Common::InvalidParameter.new("-#{option.short_name}", "Bad Format: #{msg}") unless valid
+          #end
+        end
+      end
+
+      check_mandatory()
+
+      return @values
+    end
+
+    protected
+    # Default behaviour for commandeOption: raise an exception if a mandatory is missing.
+    # @note You should override this method to implement a custom behaviour.
+    # @raise [Common::MissingParameter] If a mandatory option is missing.
+    def check_mandatory
+      @options.each_value do |option|
+        if option.mandatory
+          raise Common::MissingParameter.new("-#{option.short_name}", "Mandatory option.") if @values[option.long_name].nil?
+        end
+      end
+      return true
+    end
+
+    public
+    # Indicates if the command has arguments.
+    # @param arg_short_name The short named arguments.
+    # @param arg_long_name The long named arguments.
+    # @return True if the command has arguments, false otherwise.
+    def has_argument(arg_short_name, arg_long_name)
+      return @argv.include?('-' + arg_short_name) || @argv.include?('--' + arg_long_name)
+    end
+
+    private
+    # Initialize the return hash
+    # @return [Hash,OptionParser] The values list and the OptionParser object
+    # @author tmarmin
+    def initialize_option_values
+      @values = {}
+
+      # set to false all boolean options which are not already set
+      @options.each_value do |option|
+        @values.store(option.long_name, false) if !option.require_value
+      end
+    end
+
+
+    protected
+    # This subclass represents a command option.
+    class Option
+
+      public
+      attr_reader :short_name
+      attr_reader :long_name
+      attr_reader :description
+      attr_reader :require_value
+      attr_reader :mandatory
+      attr_reader :check_format
+
+      # Adds _NAME to the long_name.
+      def value_name
+        @long_name.upcase + "_NAME"
+      end
+
+      public
+      def initialize(short_name, long_name, description, mandatory = false, require_value = false, check_format = nil)
+
+        raise NameError.new("Short value has to be a String of one character") unless short_name.instance_of?(String) && short_name.length == 1
+        raise NameError.new("Long value has to be a non empty String") unless long_name.instance_of?(String) && long_name.length > 0
+        raise NameError.new("Description value has to be a non empty String") unless description.instance_of?(String) && description.length > 0
+        raise NameError.new("Check format method has to be of type Method class which get one string and returns a boolean,String.") unless check_format.nil? || (check_format.instance_of?(Method) && check_format.arity == 1)
+
+        @short_name = short_name
+        @long_name = long_name
+        @description = description
+        @require_value = require_value
+        @mandatory = mandatory
+        @check_format = check_format
+      end
+
+      public
+      # @return true if given value is valid
+      def valid_value?(value)
+        msg = ""
+
+        if require_value
+          valid, msg = check_format.call(value)
+        else
+          valid = value == true || value == false
+        end
+
+        return valid, msg
+      end
+
+      public
+      # @return A string that describes option for usage generating
+      def to_usage_s
+        s = ""
+        s += "[" unless @mandatory
+        s += "-" + @short_name
+        s += " " + value_name if @require_value
+        s += "]" unless @mandatory
+        return s
+      end
+
+    end
+  end
+end

data/lib/exec/executable_command.rb

@@ -0,0 +1,194 @@
+# This file is part of cloudbox-service project
+# @author tnoguer (INGENSI)
+
+require 'common/color'
+require 'common/cloudbox_logger'
+require 'common/cloudbox_logger_mock'
+require 'common/cloudbox_exceptions'
+require 'exec/command_option'
+
+include Common
+include Common::Color
+
+module Exec
+  # Basic class of an executable command. It contains every attributes and methods all executable command needs.
+  # @abstract Subclass and override exec and set_options to implement
+  # @author tnoguer
+  class ExecutableCommand
+
+    protected
+    # The cloudbox logger object, used for logging.
+    attr_accessor :logger
+    # The name of the command.
+    attr_accessor :command_name
+    # The passed arguments when calling the command.
+    attr_accessor :argv
+    # The input stream of the command.
+    attr_accessor :stdin
+    # The output stream of the command.
+    attr_accessor :stdout
+    # The error stream of the command.
+    attr_accessor :stderr
+    # The CommandOption object which describe option behavior
+    attr_accessor :options
+    # The values Hash obtained with option passed to the command
+    attr_accessor :values
+    # The CLOUDBOX_HOME environment variable value
+    # attr_accessor :cloudbox_home
+
+    public
+    # This function is the common execution of an executable command. It loads the librairies, creater the logger,
+    # calls the setOptions function and finally calls the exec function (the effective execution of the command).
+    # @author tnoguer
+    def run
+      begin
+        begin
+
+          create_logger()
+          #check_environment_variables()
+          check_parameters()
+
+          @logger.begin_execution(self.argv)
+
+          if @values["help"]
+            @stdout.puts(@options.get_help())
+          else
+            exec()
+          end
+
+        rescue StandardError => e
+          @logger.error(e.message)
+          @logger.error(e.backtrace.join("\n"))
+          @stdout.puts(Color::color_red("Execution failed"))
+          @stdout.puts(e.message)
+          raise e
+        end
+      rescue LoadError
+        @logger.error(e.message)
+        @logger.error(e.backtrace.join("\n"))
+        exit 254
+      rescue Common::ParameterError => e
+        @stdout.puts e.usage
+        @logger.error(e.message)
+        @logger.error(e.backtrace.join("\n"))
+        exit 1
+      rescue Common::CloudboxError
+        @logger.error(e.message)
+        @logger.error(e.backtrace.join("\n"))
+        exit 2
+      rescue StandardError => e
+        @stdout.puts e.class
+        @logger.error(e.message)
+        @logger.error(e.backtrace.join("\n"))
+        exit 254
+      else
+        @logger.end_execution()
+      end
+
+      @stdout.puts(Color::color_green("Execution success"))
+
+    end
+
+    protected
+    # Default constructor of the class.
+    # @param argv The arguments of the command.
+    # @param stdin [IO] The input stream of the command.
+    # @param stdout [IO] The output stream of the command.
+    # @param stderr [IO] The error stream of the command.
+    # @param command_name [String] The name of the executed command.
+    # @param command_option_class [CommandOption] The CommandOption object.
+    # @author tnoguer
+    def initialize(argv, stdin, stdout, stderr, command_name, command_option_class = CustomCommandOption)
+      @command_name = command_name
+      @argv = argv
+      @stdin = stdin
+      @stdout = stdout
+      @stderr = stderr
+      @cloudbox_home = ENV['CLOUDBOX_HOME']
+
+      @options = command_option_class.new(@command_name, @argv)
+      @options.add_option("h", "help", "Display help.", false)
+    end
+
+    protected
+    # Declare specific options needed by the command.
+    # @note This method has to be overrided by the inheriting class to add some options.
+    # @raise [NotImplementedError] When the method is not overrided by the inheriting class.
+    # @author tmarmin
+    def set_options
+      raise NotImplementedError
+    end
+
+    # The execution of the command.
+    # @note This method must be overrided by the inheriting class.
+    # @raise [NotImplementedError] When the method is not overrided by the inheriting class.
+    # @author tnoguer
+    protected
+    def exec
+      raise NotImplementedError
+    end
+
+    protected
+    # Create a logger which logs into the default log path/command_name.
+    # If an error occurred, it will create a mocked logger.
+    # @author tmarmin
+    def create_logger
+      begin
+        Color::print_log("NONE", "Loading logger...", @stdout)
+        @logger = Common::CloudboxLogger.new(@command_name)
+        Color::echo_ok(@stdout)
+      rescue => e
+        Color::echo_fail
+        @logger = Common::CloudboxLoggerMock.new
+        Color::color_red("Init CloudboxLogger error: #{e.message}", @stdout)
+      end
+    end
+
+    protected
+    # This method just call setOptions method and assumes print infos into logger and stdout.
+    # @author tmarmin
+    def check_parameters
+      @logger.begin_main_step("parameters checking")
+      Color::print_log("NONE", "checking parameters...", @stdout)
+
+      begin
+        set_options()
+
+        @values = @options.verify()
+      rescue CloudboxError => e
+        Color::echo_fail(@stdout)
+        raise e
+      end
+
+      @logger.end_main_step("parameters checking")
+      Color::echo_ok(@stdout)
+    end
+
+    #protected
+    # This method checks if mandatory environment variables are set..
+    # @author tmarmin
+    #def check_environment_variables
+    #  @logger.begin_main_step("parameters checking")
+    #  Color::print_log("NONE", "checking environment variable...", @stdout)
+
+    #  raise Common::CloudboxError.new("CLOUDBOX_HOME environment variable is not set") if @cloudbox_home.nil?
+
+    #  Color::echo_ok(@stdout)
+    #end
+
+    private
+
+    # Inherited CommandOption used only by NodeLs.
+    class CustomCommandOption < CommandOption
+
+      protected
+      # This method overrides the default behaviour.
+      # @raise [Common::MissingParameter] Never raise exception for the moment :)
+      def check_mandatory
+        unless @values["help"]
+          super()
+        end
+      end
+    end
+  end
+end

data/lib/exec/node_destroy.rb

@@ -0,0 +1,101 @@
+# This file is part of Devcloudbox project
+# @author aboudot (INGENSI)
+
+# @todo use CommandOption to check parameters format
+# @author aboudot
+
+require 'exec/executable_command'
+require 'common/cloudbox_exceptions'
+require 'optparse'
+require 'command/node_destroy'
+
+include Exec::CheckParameter
+
+module Exec
+  # Allows the user to destroy node's of crowbar server
+  class NodeDestroy < ExecutableCommand
+
+    public
+    # Default constructor of the class.
+    # @note Overrides default constructor by passing CustomCommandOption to super().
+    # @author mbretaud
+    def initialize(argv, stdin, stdout, stderr, command_name)
+      super(argv, stdin, stdout, stderr, command_name)
+    end
+
+    private
+    # @author aboudot
+    def set_options()
+      @logger.info("Exec::NodeDestroy   Setting options")
+      @options.add_option("n", "node", "The Node name that will be Destroy.", true, true, method(:check_crowbar_node_name))
+    end
+
+    # The execution of the command.
+    # @author mbretaud
+    def exec
+      @logger.info("Exec::NodeDestroy   Executing NodeDestroy")
+      destroy_node(@values['node'])
+    end
+
+    public
+    # Destroy a node from the server Crowbar
+    # @param node_name [String] the name node
+    # @raise NodeError If the node don't exists or is not Ready
+    # @author mbretaud
+    def destroy_node(node_name)
+      @logger.info("Exec::NodeDestroy   destroy_node(#{node_name})")
+      Color::print_log("NONE", "Destroy the node '#{node_name}'...", @stdout)
+
+      output = ""
+      unless node_name.nil?
+        if if_node_exist(node_name, "Ready")
+          cmd = Command::NodeDestroy.new(node_name)
+          cmd.exec
+          #output += "Destroy the node '#{node_name}'.\n"
+        else
+          raise NodeDestroyError.new("The node '#{node_name}' doesn't exists or is not 'Ready'.")
+        end
+      else
+        raise NodeDestroyError.new("The node name is nil.")
+      end
+
+      Color::echo_ok(@stdout)
+      @logger.info(output)
+      if !output.empty? && output.length > 1
+        @stdout.print output
+      else
+        @logger.info("Exec::NodeLs   No machines available.")
+        @stdout.printf_red "No machines available.\n"
+      end
+    end
+
+    private
+    # Check if the node exists or not
+    # @param node_name [String] the name node
+    # @return [Boolean] true if the node exists, false else
+    # @todo refactor in a library
+    # @author mbretaud
+    def if_node_exist(node_name, status)
+      @logger.info("Exec::NodeDestroy   Check if the node '#{node_name}' exists or not.")
+
+      # Retrieves the list of nodes.
+      begin
+        @logger.info("Exec::NodeDestroy   Getting the nodes list.")
+        cmd = Command::CrowbarNodeList.new(@logger, status)
+        list_nodes = cmd.exec
+      rescue => e
+        raise NodeListError.new("Retrieves the list of nodes with the status '#{status}'.")
+      end
+
+      if !list_nodes.nil? && list_nodes.length > 0
+        list_nodes.each { |node|
+          if node_name == node.split(" ").at(0).strip.to_s()
+            return true
+          end
+        }
+      end
+
+      return false
+    end
+  end
+end