shu-san-scripts 0.2.0 → 0.2.1

data/lib/SANStore/cli/commands/new_vol.rb

@@ -0,0 +1,134 @@
+# Copyright (c) 2009 Denis Defreyne, 2010-2011 David Love
+#
+# Permission to use, copy, modify, and/or distribute this software for 
+# any purpose with or without fee is hereby granted, provided that the 
+# above copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+# Volume names are based on RFC 4122 UUIDs
+require "uuidtools"
+
+# Use the ANSI library to report the status to the user
+require "ansi/code"
+
+# Use the Socket API to get the first IPv4 address
+require "socket"
+
+# Use the ZFS library
+require "SANStore/zfs/zfs"
+
+# Use the COMStar iSCSI library
+require "SANStore/iSCSI/comstar.rb"
+
+module SANStore::CLI::Commands
+
+  # @author David Love
+  #
+  # The +new_vol+ command adds a new ZFS volume to the specified volume
+  # store, and sets it up as an iSCSI target. Defaults are supplied to
+  # all arguments, but can be overridden by the user for slightly
+  # customised set-up of the volume store. However, the user interface
+  # should be kept as simple as possible. 
+  class NewVol < Cri::Command
+
+    # The name of the sub-command (as it appears in the command line app)
+    def name
+      'new_vol'
+    end
+
+    # The aliases this sub-command is known by
+    def aliases
+      [
+        "new", "add", "add_vol"
+      ]
+    end
+
+    # A short help text describing the purpose of this command
+    def short_desc
+      'Create a new iSCSI volume in the SAN volume store.'
+    end
+
+    # A longer description, detailing both the purpose and the
+    # use of this command
+    def long_desc
+      'By default, this command creates a 20G ZFS volume, and marks it for ' +
+      'sharing as an iSCSI target on the local network.' + "\n\n" +
+      'Warning: By default this commands sets up the iSCSI target with NO ' +
+      'security. This is fine for testing and use in the labs, but obviously ' +
+      'is not ideal if you care about the data stored on this new volume...'
+    end
+
+    # Show the user the basic syntax of this command
+    def usage
+      "store new_volume [--volume-store ZFS_PATH][--name GUID] [--size INTEGER]"
+    end
+    
+    # Define the options for this command
+    def option_definitions
+      [
+        { :short => 'v', :long => 'volume_store', :argument => :optional,
+          :desc => 'specifify the ZFS root of the new iSCSI volume. Defaults to "store/volumes".'
+        },
+        { :short => 'n', :long => 'name', :argument => :optional,
+          :desc => 'the name of the new volume. This must be a valid ZFS volume name, and defaults to ' +
+            'an RFC 4122 GUID.'
+        },
+        { :short => 's', :long => 'size', :argument => :optional,
+          :desc => 'the size of the new iSCSI volume. Note that while ZFS allows you to change the size ' +
+            'of the new volume relatively easily, because the iSCSI initiator sees this volume as a raw ' +
+            'device changing the size later may be very easy or very difficult depending on the initiators ' +
+            'operating system (and the specific file system being used). In other words, choose with care: ' +
+            'by default this command uses a size of 20G, which should be enough for most tasks in the labs.'  
+        },
+      ]
+    end
+
+    # Execute the command
+    def run(options, arguments)
+
+      # Look at the options, and if we don't find any (or some are
+      # missing), set them to the default values
+      if options[:volume_store].nil? or options[:volume_store].empty? then
+        volume_store = "store/volumes"
+        options[:volume_store] = volume_store
+      end
+      
+      if options[:name].nil? or options[:name].empty? then
+        name = UUIDTools::UUID.timestamp_create
+        options[:name] = name.to_s
+      end
+      
+      if options[:size].nil? or options[:size].empty? then
+        size = "20G" 
+        options[:size] = size
+      end
+      
+      SANStore::CLI::Logger.instance.log_level(:low, :info, "Using #{options[:name]} as the volume identifier")
+
+      # Ask for a new volume
+      ZFS.new_volume(options[:volume_store] + "/" + options[:name], options[:size]) 
+
+      # Set the volume up as an iSCSI target
+      target_name = COMStar.new_target(options[:volume_store] + "/" + options[:name], options[:name])
+
+      # Tell the caller what the new volume name is
+      text = "\n"
+      text << "A new iSCSI target has been created with the following properties\n"
+      text << "\n" 
+      text << sprintf("    %-25s %s\n", ANSI.red{ "Name:" }, target_name.wrap_and_indent(78, 20).lstrip)
+      text << sprintf("    %-25s %s\n", ANSI.red{ "IPv4 Address:" }, Socket::getaddrinfo(Socket.gethostname,"echo",Socket::AF_INET)[0][3])
+      text << "\n" 
+
+      puts text
+    end
+
+  end
+
+end

data/lib/SANStore/cli/logger.rb

@@ -0,0 +1,92 @@
+# Copyright (c) 2009 Denis Defreyne, 2010-2011 David Love
+#
+# Permission to use, copy, modify, and/or distribute this software for 
+# any purpose with or without fee is hereby granted, provided that the 
+# above copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 
+# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 
+# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 
+# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 
+# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN 
+# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF 
+# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+#
+
+require 'singleton'
+require 'facets'
+
+module SANStore::CLI
+
+  # SANStore::CLI::Logger is a singleton class responsible for generating
+  # feedback in the terminal.
+  class Logger
+
+    # ANSI console codes (escape sequences) for highlighting particular
+    # log outputs.
+    ACTION_COLORS = {
+      :create         => "\e[1m" + "\e[32m", # bold + green
+      :delete         => "\e[1m" + "\e[31m", # bold + red
+      :error          => "\e[1m" + "\e[31m", # bold + red
+      :identical      => "\e[1m" + "\e[34m", # bold + blue
+      :info           => "\e[1m" + "\e[34m", # bold + blue
+      :update         => "\e[1m" + "\e[33m", # bold + yellow
+      :warning        => "\e[1m" + "\e[33m", # bold + yellow
+    }
+
+    include Singleton
+
+    # The log level, which can be :high, :low or :off (which will log all
+    # messages, only high-priority messages, or no messages at all,
+    # respectively).
+    attr_accessor :level
+
+    # Whether to use color in log messages or not
+    attr_accessor :color
+    alias_method :color?, :color
+
+    def initialize
+      @level = :high
+      @color = true
+    end
+
+    # Logs a messsage, using appropriate colours to highlight different
+    # levels.
+    #
+    # +level+:: The importance of this action. Can be :high or :low.
+    #
+    # +action+:: The kind of file action. Can be :create, :update or
+    #            :identical.
+    #
+    # +message+:: The identifier of the item the action was performed on.
+    def log_level(level, action, message)
+      log(
+        level,
+        '%s%12s%s:  %s' % [
+          color? ? ACTION_COLORS[action.to_sym] : '',
+          action.to_s.capitalize,
+          color? ? "\e[0m" : '',
+          message.word_wrap(60).indent(15).lstrip
+        ]
+      )
+    end
+
+    # Logs a message.
+    #
+    # +level+:: The importance of this message. Can be :high or :low.
+    #
+    # +message+:: The message to be logged.
+    #
+    # +io+:: The IO instance to which the message will be written. Defaults to
+    #        standard output.
+    def log(level, message, io=$stdout)
+      # Don't log when logging is disabled
+      return if @level == :off
+
+      # Log when level permits it
+      io.puts(message) if (@level == :low or @level == level)
+    end
+
+  end
+
+end

data/lib/SANStore/cri.rb

@@ -0,0 +1,12 @@
+module Cri
+
+  # The current Cri version.
+  CRI_VERSION = '1.0'
+
+end
+
+# Load Cri
+require 'SANStore/cri/base'
+require 'SANStore/cri/command'
+require 'SANStore/cri/core_ext'
+require 'SANStore/cri/option_parser'

data/lib/SANStore/cri/base.rb

@@ -0,0 +1,153 @@
+module Cri
+
+  # Cri::Base is the central class representing a commandline tool. It has a
+  # list of commands.
+  class Base
+
+    # The CLI's list of commands (should also contain the help command)
+    attr_reader :commands
+
+    # The CLI's help command (required)
+    attr_accessor :help_command
+
+    # Creates a new instance of the commandline tool.
+    def initialize(tool_name)
+      @tool_name = tool_name
+
+      @commands = []
+    end
+
+    # Parses the given commandline arguments and executes the requested
+    # command.
+    def run(args)
+      # Check arguments
+      if args.length == 0
+        @help_command.run([], [])
+        exit 1
+      end
+
+      # Partition options
+      opts_before_command         = []
+      command_name                = nil
+      opts_and_args_after_command = []
+      stage = 0
+      args.each do |arg|
+        # Update stage if necessary
+        stage = 1 if stage == 0 && !is_option?(arg)
+
+        # Add
+        opts_before_command << arg         if stage == 0
+        command_name = arg                 if stage == 1
+        opts_and_args_after_command << arg if stage == 2
+
+        # Update stage if necessary
+        stage = 2 if stage == 1
+      end
+
+      # Handle options before command
+      begin
+        parsed_arguments = Cri::OptionParser.parse(opts_before_command, global_option_definitions)
+      rescue Cri::OptionParser::IllegalOptionError => e
+        $stderr.puts "illegal option -- #{e}"
+        exit 1
+      end
+      parsed_arguments[:options].keys.each do |option|
+        handle_option(option)
+      end
+
+      # Get command
+      if command_name.nil?
+        $stderr.puts "no command given"
+        exit 1
+      end
+      command = command_named(command_name)
+      if command.nil?
+        $stderr.puts "no such command: #{command_name}"
+        exit 1
+      end
+
+      # Parse arguments
+      option_definitions = command.option_definitions + global_option_definitions
+      begin
+        parsed_arguments = Cri::OptionParser.parse(opts_and_args_after_command, option_definitions)
+      rescue Cri::OptionParser::IllegalOptionError => e
+        $stderr.puts "illegal option -- #{e}"
+        exit 1
+      rescue Cri::OptionParser::OptionRequiresAnArgumentError => e
+        $stderr.puts "option requires an argument -- #{e}"
+        exit 1
+      end
+
+      # Handle global options
+      global_options = global_option_definitions.map { |o| o[:long] }
+      global_options.delete_if { |o| !parsed_arguments[:options].keys.include?(o.to_sym) }
+      global_options.each { |o| handle_option(o.to_sym) }
+
+      if parsed_arguments[:options].has_key?(:help)
+        # Show help for this command
+        show_help(command)
+      else
+        # Run command
+        command.run(parsed_arguments[:options], parsed_arguments[:arguments])
+      end
+    end
+
+    # Returns the command with the given name.
+    def command_named(name)
+      # Find by exact name or alias
+      command = @commands.find { |c| c.name == name or c.aliases.include?(name) }
+      return command unless command.nil?
+
+      # Find by approximation
+      commands = @commands.select { |c| c.name[0, name.length] == name }
+      if commands.length > 1
+        $stderr.puts "#{@tool_name}: '#{name}' is ambiguous:"
+        $stderr.puts "  #{commands.map { |c| c.name }.join(' ') }"
+        exit 1
+      elsif commands.length == 0
+        $stderr.puts "#{@tool_name}: unknown command '#{name}'\n"
+        show_help
+        exit 1
+      else
+        return commands[0]
+      end
+    end
+
+    # Shows the help text for the given command, or shows the general help
+    # text if no command is given.
+    def show_help(command=nil)
+      if command.nil?
+        @help_command.run([], [])
+      else
+        @help_command.run([], [ command.name ])
+      end
+    end
+
+    # Returns the list of global option definitionss.
+    def global_option_definitions
+      []
+    end
+
+    # Adds the given command to the list of commands. Adding a command will
+    # also cause the command's +base+ to be set to this instance.
+    def add_command(command)
+      @commands << command
+      command.base = self
+    end
+
+    # Handles the given optio
+    def handle_option(option)
+      false
+    end
+
+  private
+
+    # Returns true if the given string is an option (i.e. -foo or --foo),
+    # false otherwise.
+    def is_option?(string)
+      string =~ /^-/
+    end
+
+  end
+
+end

data/lib/SANStore/cri/command.rb

@@ -0,0 +1,104 @@
+module Cri
+
+  # Cri::Command represents a command that can be executed on the commandline.
+  # It is an abstract superclass for all commands.
+  class Command
+
+    attr_accessor :base
+
+    # Returns a string containing the name of thi command. Subclasses must
+    # implement this method.
+    def name
+      raise NotImplementedError.new("Command subclasses should override #name")
+    end
+
+    # Returns an array of strings containing the aliases for this command.
+    # Subclasses must implement this method.
+    def aliases
+      raise NotImplementedError.new("Command subclasses should override #aliases")
+    end
+
+    # Returns a string containing this command's short description, which
+    # should not be longer than 50 characters. Subclasses must implement this
+    # method.
+    def short_desc
+      raise NotImplementedError.new("Command subclasses should override #short_desc")
+    end
+
+    # Returns a string containing this command's complete description, which
+    # should explain what this command does and how it works in detail.
+    # Subclasses must implement this method.
+    def long_desc
+      raise NotImplementedError.new("Command subclasses should override #long_desc")
+    end
+
+    # Returns a string containing this command's usage. Subclasses must
+    # implement this method.
+    def usage
+      raise NotImplementedError.new("Command subclasses should override #usage")
+    end
+
+    # Returns an array containing this command's option definitions. See the
+    # documentation for Cri::OptionParser for details on what option
+    # definitions look like. Subclasses may implement this method if the
+    # command has options.
+    def option_definitions
+      []
+    end
+
+    # Executes the command. Subclasses must implement this method
+    # (obviously... what's the point of a command that can't be run?).
+    #
+    # +options+:: A hash containing the parsed commandline options. For
+    #             example, '--foo=bar' will be converted into { :foo => 'bar'
+    #             }. See the Cri::OptionParser documentation for details.
+    #
+    # +arguments+:: An array of strings representing the commandline arguments
+    #               given to this command.
+    def run(options, arguments)
+      raise NotImplementedError.new("Command subclasses should override #run")
+    end
+
+    # Returns the help text for this command.
+    def help
+      text = ''
+
+      # Append usage
+      text << usage + "\n"
+
+      # Append aliases
+      unless aliases.empty?
+        text << "\n"
+        text << "aliases: #{aliases.join(' ')}\n"
+      end
+
+      # Append short description
+      text << "\n"
+      text << short_desc + "\n"
+
+      # Append long description
+      text << "\n"
+      text << long_desc.wrap_and_indent(78, 4) + "\n"
+
+      # Append options
+      unless option_definitions.empty?
+        text << "\n"
+        text << "options:\n"
+        text << "\n"
+        option_definitions.sort { |x,y| x[:long] <=> y[:long] }.each do |opt_def|
+          text << sprintf("    -%1s --%-10s %s\n\n", opt_def[:short], opt_def[:long], opt_def[:desc].wrap_and_indent(78, 20).lstrip)
+        end
+      end
+
+      # Return text
+      text
+    end
+
+    # Compares this command's name to the other given command's name.
+    def <=>(other)
+      self.name <=> other.name
+    end
+
+  end
+
+end