birr 0.1

data/lib/birr.rb

@@ -0,0 +1,5 @@
+require 'megam/version'
+require 'megam/core/exceptions'
+require 'megam/core/log'
+require 'megam/core/text'
+

data/lib/megam/app.rb

@@ -0,0 +1,190 @@
+#
+# License:: Apache License, Version 2.0
+#
+# Licensed 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.
+
+require 'pp'
+require 'megam/config'
+require 'megam/birr'
+require 'mixlib/cli'
+require 'tmpdir'
+require 'rbconfig'
+
+class Megam::App
+  include Mixlib::CLI
+  #include(a_module) is called inside a class, and adds module methods as instance methods.
+  #extend(a_module) adds all module methods to the instance it is called on.
+
+  NO_COMMAND_GIVEN = "You need to pass a command with option (e.g., birr -i <install_path>)\n"
+
+  banner "Usage: birr (options)"
+
+  option :install_file,
+    :short => "-i INSTALL",
+    :long => "--install INSTALL",
+    :required => true,
+    :description => "The installation file path to use",
+    :proc => lambda { |path| File.expand_path(path, Dir.pwd) }
+
+  verbosity_level = 0
+  option :verbosity,
+    :short => '-V',
+    :long => '--verbose',
+    :description => "More verbose output. Use twice for max verbosity",
+    :proc => Proc.new { verbosity_level += 1},
+    :default => 0
+
+  option :help,
+    :short        => "-h",
+    :long         => "--help",
+    :description  => "Show this message",
+    :on           => :tail,
+    :boolean      => true,
+    :show_options => true,
+    :exit         => 0
+
+  option :yes,
+    :short => "-y",
+    :long => "--yes",
+    :description => "Say yes to all prompts for confirmation"
+
+  option :version,
+    :short        => "-v",
+    :long         => "--version",
+    :description  => "Show birr version",
+    :boolean      => true,
+    :proc         => lambda {|v| puts "Birr: #{::Megam::VERSION}"},
+    :exit         => 0
+
+  #attr_accessors are setters/getters in ruby.  The arguments are filtered and available for use
+  #to subclasses.
+  attr_accessor :name_args
+
+  attr_accessor :text
+  def initialize
+    super # The super calls the mixlib cli.
+
+    ##Traps are being set for the following when an application starts.
+    ##SIGHUP        1       Term    Hangup detected on controlling terminal
+    ##                             or death of controlling process
+    ##SIGINT        2       Term    Interrupt from keyboard
+    ##SIGQUIT       3       Core    Quit from keyboard
+    trap("TERM") do
+      Megam::App.fatal!("SIGTERM received, stopping", 1)
+    end
+
+    trap("INT") do
+      Megam::App.fatal!("SIGINT received, stopping", 2)
+    end
+
+    trap("QUIT") do
+      Megam::Log.info("SIGQUIT received, call stack:\n  " + caller.join("\n  "))
+    end
+
+    @text ||= Megam::Text.new(STDOUT, STDERR, STDIN, {})
+
+  end
+
+  # Run the "birr app". Let it roam and stay by our side.[Go birr..Does it remind of the Hutch adv.].
+  # The first thing run does is it parses the options. Once the first level of parsing is done,
+  # ie the help, no_command, sub_command entry is verified it proceeds to call
+  # Megam_Birr with the user entered options and arguments (ARGV)
+  def run
+    Mixlib::Log::Formatter.show_time = false
+    validate_and_parse_options
+    Megam::Birr.new.run(@named_args, config)
+    exit 0
+  end
+
+  def parse_options(args)
+    super
+  rescue OptionParser::InvalidOption => e
+    puts "Error: " + e.to_s
+    puts self.opt_parser
+    exit(1)
+    end
+
+  ##A few private helper methods being used by app itself.
+  ##If you run an application for ever, you might pool all the executions and gather the stacktrace.
+  private
+
+  # A check is performed to see if an option is entered, help or version
+  def validate_and_parse_options
+    # Checking ARGV validity *before* parse_options because parse_options
+    # mangles ARGV in some situations
+    if no_command_given?
+      print_help_and_exit(1, NO_COMMAND_GIVEN)
+    elsif (want_help? || want_version?)
+      print_help_and_exit
+    else
+      @named_args = parse_options(ARGV)
+    end
+
+  end
+
+  def no_subcommand_given?
+    ARGV[0] =~ /^-/
+  end
+
+  def no_command_given?
+    ARGV.empty?
+  end
+
+  def want_help?
+    ARGV[0] =~ /^(--help|-h)$/
+  end
+
+  def want_version?
+    ARGV[0] =~ /^(--version|-v)$/
+  end
+
+  # Print the help message with the exit code.  If no command is given, then a fatal message is printed.
+  # The options are parsed by calling the parse_options present in the mixlib cli as extended by the app.
+  # A error gets caught and results in an ugly stack trace, which probably needs to be shown in an elegant way.
+  # The stacK should be logged using the debug_stacktrace method in the app class.
+  def print_help_and_exit(exitcode=1, fatal_message=nil)
+    Megam::Log.error(fatal_message) if fatal_message
+    parse_options(ARGV)
+    exit exitcode
+  end
+
+  class << self
+    #The exception in ruby carries the class, message and the trace.
+    #http://www.ruby-doc.org/core-2.0/Exception.html
+    def debug_stacktrace(e)
+      message = "#{e.class}: #{e}\n#{e.backtrace.join("\n")}"
+      megam_stacktrace_out = "Generated at #{Time.now.to_s}\n"
+      megam_stacktrace_out += message
+
+      #after the message is formulated in the variable megam_stack_trace_out, its
+      #stored in a file named megam-stacktrace.out
+      Megam::FileCache.store("megam-stacktrace.out", megam_stacktrace_out)
+
+      ##The same error is logged in the log file saying, go look at megam-stacktrace.out for error.
+      Megam::Log.fatal("Stacktrace dumped to #{Megam::FileCache.load("megam-stacktrace.out", false)}")
+      Megam::Log.debug(message)
+      true
+    end
+
+    # Log a fatal error message to both STDERR and the Logger, exit the application
+    def fatal!(msg, err = -1)
+      Megam::Log.fatal(msg)
+      Process.exit err
+    end
+
+    def exit!(msg, err = -1)
+      Megam::Log.debug(msg)
+      Process.exit err
+    end
+  end
+end

data/lib/megam/birr.rb

@@ -0,0 +1,176 @@
+#
+#
+# Licensed 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.
+#
+
+require 'pp'
+require 'megam/core/text'
+
+#Main entry for the command line, after validating the class, run the install_file
+class Megam::Birr
+
+  attr_accessor :text
+  attr_accessor :config
+  #text is used to print stuff in the terminal (message, log, info, warn etc.)
+  def self.text
+    @text ||= Megam::Text.new(STDOUT, STDERR, STDIN, {})
+  end
+
+  # I don't think we need this method. Will remove it later.
+  # We need to just call text.msg
+  def self.msg(msg="")
+    text.msg(msg)
+  end
+
+  # Create a new instance of the current class configured for the given
+  # arguments and options
+  def initialize()
+  end
+
+  # Run Birr for the given +args+ (ARGV), adding +options+ to the list of
+  # CLI options that the subcommand knows how to handle.
+  # ===Arguments
+  # args::: usually ARGV
+  # options::: A Mixlib::CLI option parser hash. These +options+ are how
+  # subcommands know about global Birr CLI options
+  def run(args=[], config={})
+    @config = config.dup
+    @text ||= Megam::Text.new(STDOUT, STDERR, STDIN, config)
+    # configure your Birr.
+    configure_birr
+  end
+
+  # configure meggy, to startwith locate the config file under .meggy/Birr.rb
+  # Once located, read the Birr.rb config file. parse them, and report any ruby syntax errors.
+  # if not merge then inside Meggy::Config object.
+  def configure_birr
+    # look for a .birr/birr.rb for configuration. Not used currently.
+    unless config[:install_file]
+      locate_install_file
+    end
+    
+    # Now load the installation file provided as input {-i} parm.
+    if config[:install_file]
+      @text.info "Using #{config[:install_file]}"
+      apply_computed_config
+      read_config_file(config[:install_file])
+    else
+      text.warn("No birr configuration file found")
+    end
+
+  end
+
+  def locate_install_file
+    # Look for $HOME/.meggy/birr.rb, this aint' supported currently
+    # the idea is to allow configuration of the options used here.
+    if ENV['HOME']
+      user_config_file =  File.expand_path(File.join(ENV['HOME'], '.birr', 'birr.rb'))
+    end
+
+    if File.exist?(user_config_file)
+      config[:install_file] = user_config_file
+    end
+  end
+
+  # Catch-all method that does any massaging needed for various config
+  # components, such as expanding file paths and converting verbosity level
+  # into log level.
+  def apply_computed_config
+  
+    case config[:verbosity]
+    when 0, nil
+      config[:log_level] = :error
+    when 1
+      config[:log_level] = :info
+    else
+    config[:log_level] = :debug
+    end
+
+    Mixlib::Log::Formatter.show_time = false
+    Megam::Log.init(config[:log_location] || STDOUT)
+    Megam::Log.level(config[:log_level] || :error)
+    
+    config.each do |key, val| 
+      Megam::Config[key] = val
+    end
+    
+  end
+
+  # load the content as provided in -i {installation_file}
+  # ruby errors get reported or else the file is executed.
+  def read_config_file(file)
+    self.instance_eval(IO.read(file), file, 1)
+  rescue SyntaxError => e
+    @text.error "You have invalid ruby syntax in your config file #{file}"
+    @text.info(text.color(e.message, :red))
+    if file_line = e.message[/#{Regexp.escape(file)}:[\d]+/]
+      line = file_line[/:([\d]+)$/, 1].to_i
+      highlight_config_error(file, line)
+    end
+    exit 1
+  rescue Exception => e
+    @text.error "You have an error in your config file #{file}"
+    @text.info "#{e.class.name}: #{e.message}"
+    filtered_trace = e.backtrace.grep(/#{Regexp.escape(file)}/)
+    filtered_trace.each {|line| text.msg(" " + text.color(line, :red))}
+    if !filtered_trace.empty?
+      line_nr = filtered_trace.first[/#{Regexp.escape(file)}:([\d]+)/, 1]
+      highlight_config_error(file, line_nr.to_i)
+    end
+
+    exit 1
+    end
+
+  #ERROR: You have invalid ruby syntax in your config file /home/ram/.meggy/Birr.rb
+  #/home/ram/.meggy/Birr.rb:9: syntax error, unexpected '='
+  #Birr[:username] > = "admin"
+  #                  ^
+  # # /home/ram/.meggy/Birr.rb
+  #  8: meggy_server_url          'http://localhost:6167'
+  #  9: Birr[:username] > = "admin"
+  # 10: Birr[:password] = "team4dog"
+  # Line 9 is marked in red, and the 3rd line where the error is show is highlighted in red.
+  #This is in case of a ruby parse error.
+  def highlight_config_error(file, line)
+    config_file_lines = []
+
+    # A file line is split into the line number (index) and the line content.
+    # The line number is converted to string (to_s), right justified 3 characters with a colon, and its trimmed (chomp)
+
+    IO.readlines(file).each_with_index {|l, i| config_file_lines << "#{(i + 1).to_s.rjust(3)}: #{l.chomp}"}
+    # mark the appropriate line with a red color, if its just one line, then mark the zeroth line.
+    # if not get the range (deducting 2), and mark the second line.
+    if line == 1
+      lines = config_file_lines[0..3]
+      lines[0] = text.color(lines[0], :red)
+    else
+      lines = config_file_lines[Range.new(line - 2, line)]
+      lines[1] = text.color(lines[1], :red)
+    end
+    text.msg ""
+    # print the name of the file in white
+    text.msg text.color(" # #{file}", :white)
+    # print the rest of the line.
+    lines.each {|l| text.msg(l)}
+    text.msg ""
+  end
+
+   
+
+  private
+
+  def self.working_directory
+    ENV['PWD'] || Dir.pwd
+  end
+
+end

data/lib/megam/birr_options.rb

@@ -0,0 +1,59 @@
+#The birr options class takes the block in the initialize method.
+#it uses the custom attr_accessors, namely (setter, varargs_setters) to 
+#inject the value by defining methods with the dsl defined ones.
+#
+class Megam
+  class BirrOptions
+    def self.setter(*method_names)
+      method_names.each do |name|
+        send :define_method, name do |data|
+          instance_variable_set "@#{name}".to_sym, data
+        end
+      end
+    end
+
+    def self.varargs_setter(*method_names)
+      method_names.each do |name|
+        send :define_method, name do |*data|
+          instance_variable_set "@#{name}".to_sym, data
+        end
+      end
+    end
+
+    setter :sudo, :start_time, :tarball
+    varargs_setter :directory, :command
+    attr_reader :commands, :sudo
+
+    def initialize(&block)
+      # defaults
+      @tarball         = nil
+      @sudo            = false
+      @directory       = []
+      @command         = []
+      @commands        = []
+      @start_time      = Time.now
+      instance_eval(&block)
+
+    end
+
+    def commands
+      @commands = @command.flatten if @command
+    end
+
+    def sudo?
+      @sudo
+    end
+
+    def tarball_file
+      @tarball_file ||= @tarball
+    end
+
+    def to_s
+      tmps = ""
+      tmps << "sudo :" + @sudo.to_s + "\n"
+      tmps << "dir  :" + @directory.to_s + "\n"
+      tmps << "cmd  :" + commands.to_s + "\n"
+      tmps << "strt :" + @start_time.to_s
+    end
+  end
+end

data/lib/megam/cmd_verb.rb

@@ -0,0 +1,48 @@
+#
+# License:: Apache License, Version 2.0
+#
+# Licensed 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.
+require "megam/core/text"
+require "megam/birr"
+
+class Megam::CmdVerb
+  
+  def initialize
+  end
+
+  # cp -r -s <from directory> <to directory>
+  def self.cp(opts={}) 
+    cp =""
+    cp << "sudo " if opts[:sudo]
+    cp << "cp"
+    cp << " -r " if opts[:recursive]
+ #   cp << " -u " if opts[:copy_on_new] #copy  only  when  the  SOURCE file is newer than
+    cp << opts[:from_dir] if opts[:from_dir] or raise Megam::Exceptions::FileNotFound
+    cp << " "
+    cp << opts[:to_dir] if opts[:to_dir] or raise Megam::Exceptions::FileNotFound
+    cp
+  end
+  
+  #gunzip -c foo.tar.gz | tar xvf -
+  def self.untar(opts={})
+    untar = "gunzip -c "
+    untar << opts[:tar_file] if opts[:tar_file] 
+    untar << " | tar xvf - -C "
+    untar << opts[:to_dir] if opts[:to_dir]
+    untar    
+  end
+
+  def to_s
+    "cmdverb -> [supports cp, untar *only]"
+  end
+end