jackowayed-tyrantmanager 1.1.0

data/gemspec.rb

@@ -0,0 +1,53 @@
+require 'rubygems'
+require 'tyrant_manager/version'
+require 'tasks/config'
+
+TyrantManager::GEM_SPEC = Gem::Specification.new do |spec|
+  proj = Configuration.for('project')
+  spec.name         = proj.name
+  spec.version      = TyrantManager::VERSION
+  
+  spec.author       = proj.author
+  spec.email        = proj.email
+  spec.homepage     = proj.homepage
+  spec.summary      = proj.summary
+  spec.description  = proj.description
+  spec.platform     = Gem::Platform::RUBY
+
+  
+  pkg = Configuration.for('packaging')
+  spec.files        = pkg.files.all
+  spec.executables  = pkg.files.bin.collect { |b| File.basename(b) }
+
+  # add dependencies here
+  spec.add_dependency( "loquacious", "~> 1.3.0")
+  spec.add_dependency( "rufus-tokyo", "~> 1.0.0")
+  spec.add_dependency( "logging", "~> 1.1.4" )
+  spec.add_dependency( "main", "~> 2.8.4" )
+
+  # development dependencies
+  spec.add_development_dependency("configuration", ">= 0.0.5")
+  spec.add_development_dependency( "rake", "~> 0.8.3")
+
+  if ext_conf = Configuration.for_if_exist?("extension") then
+    spec.extensions << ext_conf.configs
+    spec.extensions.flatten!
+  end
+  
+  if rdoc = Configuration.for_if_exist?('rdoc') then
+    spec.has_rdoc         = true
+    spec.extra_rdoc_files = pkg.files.rdoc
+    spec.rdoc_options     = rdoc.options + [ "--main" , rdoc.main_page ]
+  else
+    spec.has_rdoc         = false
+  end 
+
+  if test = Configuration.for_if_exist?('testing') then
+    spec.test_files       = test.files
+  end 
+
+  if rf = Configuration.for_if_exist?('rubyforge') then
+    spec.rubyforge_project  = rf.project
+  end 
+
+end

data/lib/tyrant_manager.rb

@@ -0,0 +1,237 @@
+#--
+# Copyright (c) 2009 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details.
+#++
+
+require 'rubygems'
+require 'loquacious'
+require 'tyrant_manager/version'
+require 'tyrant_manager/paths'
+require 'tyrant_manager/log'
+
+class TyrantManager
+  include TyrantManager::Paths
+
+  class Error < StandardError; end
+
+  class << TyrantManager
+    #
+    # The basename of the default config file
+    #
+    def config_file_basename
+      "config.rb"
+    end
+
+    #
+    # The basename of the directory that holds the tyrant manager system
+    #
+    def basedir
+      "tyrant"
+    end
+
+    #
+    # is the given directory a tyrant root directory.  A tyrant root has a
+    # +config_file_basename+ file in the top level
+    #
+    def is_tyrant_root?( dir )
+      cfg = File.join( dir, config_file_basename )
+      return true if File.directory?( dir ) and File.exist?( cfg )
+      return false
+    end
+
+    #
+    # Return the path of the tyrant dir if there is one relative to the current
+    # working directory.  This means that there is a +config_file_basename+ in
+    # the current working directory.
+    #
+    # returns Dir.pwd if this is the case, nil otherwise
+    #
+    def cwd_default_directory
+      default_dir = Dir.pwd
+      return default_dir if is_tyrant_root?( default_dir )
+      return nil
+    end
+
+    # 
+    # Return the path of the tyrant dir as it pertains to the
+    # TYRANT_MANAGER_HOME environment variable.  If the directory is 
+    # a tyrant root, then return that directory, otherwise return nil
+    #
+    def env_default_directory
+      default_dir = ENV['TYRANT_MANAGER_HOME']
+      return default_dir if default_dir and is_tyrant_root?( default_dir )
+      return nil
+    end
+
+    #
+    # Return the path of the tyrant dir as it pertains to the default global
+    # setting of 'lcoalstatedir' which is /opt/local/var, /var, or similar
+    #
+    def localstate_default_directory
+      default_dir = File.join( Config::CONFIG['localstatedir'], basedir )
+      return default_dir if is_tyrant_root?( default_dir )
+      return nil
+    end
+
+    #
+    # The default tyrant directory.  It is the first of these that matches:
+    #
+    # * current directory if there is a +config_file_basename+ file in the
+    #   current dirctory
+    # * the value of the TYRANT_MANAGER_HOME environment variable
+    # * File.join( Config::CONFIG['localstatedir'], basedir )
+    #
+    def default_directory
+      defaults = [ self.cwd_default_directory,
+                   self.env_default_directory,
+                   self.localstate_default_directory ]
+      dd = nil
+      loop do
+        dd = defaults.shift
+        break if dd or defaults.empty?
+      end
+      raise Error, "No default_directory found" unless dd
+      return dd
+    end
+
+    #
+    # Return the default directory if it exists, otherwise fallback to .home_dir
+    #
+    def default_or_home_directory
+      hd = TyrantManager.home_dir
+      begin
+        hd = TyrantManager.default_directory
+      rescue => e
+        # yup, using home
+      end
+      return hd
+    end
+
+
+    #
+    # Setup the tyrant manager in the given directory.  This means creating it
+    # if it does not exist.
+    #
+    def setup( dir = default_directory )
+      unless File.directory?( dir )
+        logger.info "Creating directory #{dir}"
+        FileUtils.mkdir_p( dir )
+      end
+
+      cfg = File.join( dir, config_file_basename )
+
+      unless File.exist?( cfg )
+        template = TyrantManager::Paths.data_path( config_file_basename )
+        logger.info "Creating default config file #{cfg}"
+        FileUtils.cp( template, dir )
+      end
+
+      %w[ instances log tmp ].each do |subdir|
+        subdir = File.join( dir, subdir )
+        unless File.directory?( subdir ) then
+          logger.info "Creating directory #{subdir}"
+          FileUtils.mkdir subdir 
+        end
+      end
+      return TyrantManager.new( dir )
+    end
+  end
+
+  #
+  # Initialize the manager, which is nothing more than creating the instance and
+  # setting the home directory.
+  #
+  def initialize( directory = TyrantManager.default_directory )
+    self.home_dir = File.expand_path( directory ) 
+    if File.exist?( self.config_file ) then
+      configuration # force a load
+    else
+      raise Error, "#{home_dir} is not a valid archive. #{self.config_file} does not exist"
+    end
+  end
+
+  def logger
+    Logging::Logger[self]
+  end
+
+  #
+  # The configuration file for the manager
+  #
+  def config_file
+    @config_file ||= File.join( home_dir, TyrantManager.config_file_basename ) 
+  end
+
+  #
+  # load the configuration
+  #
+  def configuration
+    unless @configuration 
+      eval( IO.read( self.config_file ) )
+      @configuration = Loquacious::Configuration.for("manager")
+    end
+    return @configuration
+  end
+
+  #
+  # Create a runner instance with the given options
+  #
+  def runner_for( options )
+    Runner.new( self, options )
+  end
+
+  #
+  # Return the list of instances that the manager knows about
+  #
+  def instances
+    unless @instances then
+      candidates = [ self.instances_path ]
+      if configuration.instances then
+        candidates = configuration.instances
+      end
+
+      @instances = {}
+      while not candidates.empty? do
+        candidate = candidates.pop
+        cpath = append_to_home_if_not_absolute( candidate )
+        begin
+          t = TyrantInstance.new( cpath )
+          t.manager = self
+          @instances[t.name] = t
+        rescue TyrantManager::Error => e
+          if File.directory?( cpath ) then
+            Dir.glob( "#{cpath}/*" ).each do |epath|
+              if File.directory?( epath ) then
+                candidates.push epath
+              end
+            end
+          end
+        end
+      end #while 
+    end
+    return @instances
+  end
+
+  def each_instance
+    instances.keys.sort.each do |name|
+      yield instances[name]
+    end
+  end
+
+  private
+  #
+  # take the given path, and if it is not an absolute path append it 
+  # to the home directory of the instance.
+  def append_to_home_if_not_absolute( p )
+    path = Pathname.new( p )
+    unless path.absolute? then
+      path = Pathname.new( home_dir ) + path
+    end
+    return path.to_s
+  end
+
+
+end
+
+require 'tyrant_manager/cli'
+require 'tyrant_manager/runner'
+require 'tyrant_manager/tyrant_instance'

data/lib/tyrant_manager/cli.rb

@@ -0,0 +1,152 @@
+require 'main'
+require 'tyrant_manager'
+
+class TyrantManager
+  Cli = Main.create {
+    author "Copyright 2009 (c) Jeremy Hinegardner"
+    version ::TyrantManager::VERSION
+
+    description <<-txt
+    The command line tool for managing tyrant instances.
+
+    Run 'tyrantmanager help modename' for more information
+    txt
+
+    run { help! }
+
+    mode( :setup ) {
+      description "Setup an tyrant manager location"
+      argument( :home ) {
+        description "The home directory of the tyrant manager"
+        required
+        default TyrantManager.default_or_home_directory
+      }
+
+      run { 
+        TyrantManager::Log.init 
+        TyrantManager.setup( params['home'].value ) 
+      }
+    }
+
+    mode( 'create-instance' ) {
+      description <<-txt
+      Create a new tyrant instance in the specified directory
+      txt
+
+      argument( 'instance-home' ) do
+        description <<-txt
+        The home directory of the tyrant instance.  If this is a full path it 
+        will be used.  If it is a relative path, it will be relative to the 
+        manager's 'instances' configuration parameter
+        txt
+      end
+
+      mixin :option_home
+      mixin :option_log_level
+
+      run { Cli.run_command_with_params( "create-instance", params ) }
+    }
+
+    mode( 'start' ) {
+      description "Start all the tyrants listed"
+      mixin :option_home
+      mixin :option_log_level
+      mixin :argument_instances
+      option( 'dry-run' ) {
+        description "Do not start, just show the commands"
+        default false
+      }
+
+      run { Cli.run_command_with_params( 'start', params ) }
+    }
+
+
+    mode( 'stop' ) {
+      description "Stop all the tyrants listed"
+      mixin :option_home
+      mixin :option_log_level
+      mixin :argument_instances
+
+      run { Cli.run_command_with_params( 'stop', params ) }
+    }
+
+    mode('replication-status') {
+      description "Describe the replication status of those servers using replication"
+      mixin :option_home
+      mixin :option_log_level
+      mixin :argument_instances
+      run { Cli.run_command_with_params( 'replication-status', params ) }
+    }
+
+    mode('process-status') {
+      description "Check the running status of all the tyrants listed"
+      mixin :option_home
+      mixin :option_log_level
+
+      mixin :argument_instances
+
+      run { Cli.run_command_with_params( 'process-status', params ) }
+    }
+
+    mode( 'stats' ) {
+      description "Dump the database statistics of each of the tyrants listed"
+      mixin :option_home
+      mixin :option_log_level
+
+      mixin :argument_instances
+
+      run { Cli.run_command_with_params( 'stats', params ) }
+    }
+
+
+    mode('list') {
+      description "list the instances and their home directories"
+      mixin :option_home
+      mixin :option_log_level
+      mixin :argument_instances
+      run { Cli.run_command_with_params( 'list', params ) }
+    }
+
+    #--- Mixins ---
+    mixin :option_home do
+      option( :home ) do
+        description "The home directory of the tyrant manager"
+        argument :required
+        validate { |v| ::File.directory?( v ) }
+        default TyrantManager.default_or_home_directory
+      end
+    end
+
+    mixin :option_log_level do
+      option('log-level') do
+        description "The verbosity of logging, one of [ #{::Logging::LNAMES.map {|l| l.downcase}.join(", ")} ]"
+        argument :required
+        validate { |l| %w[ debug info warn error fatal off ].include?( l.downcase ) }
+      end
+    end
+
+    mixin :argument_instances do
+      argument('instances') do
+        description "A comman separated list of instance names the tyrant manager  knows about"
+        argument :required
+        cast :list
+        default 'all'
+      end
+    end
+  }
+
+  #
+  # Convert the Parameters::List that exists as the parameters from Main
+  #
+  def Cli.params_to_hash( params )
+    (hash = params.to_hash ).keys.each { |key| hash[key] = hash[key].value }
+    return hash
+  end
+
+  def Cli.run_command_with_params( command, params )
+    phash = Cli.params_to_hash( params )
+    TyrantManager::Log.init( phash )
+    tm = TyrantManager.new( phash.delete('home') )
+    tm.runner_for( phash ).run( command )
+  end 
+end

data/lib/tyrant_manager/command.rb

@@ -0,0 +1,119 @@
+require 'tyrant_manager'
+class TyrantManager
+  #
+  # The Command is the base class for any class to be used as a command
+  #
+  # All commands run within the context of an existing TyrantManager location.
+  # Before the command starts the current working directory will be inside the
+  # tyrant manager's home directory.
+  #
+  # A command has a lifecyle of:
+  #
+  # * instantiation with a TyrantManager instance and an options hash
+  # * one call to before
+  # * one call to run
+  # * one call to after
+  # 
+  # In case of an exception raised during the lifecycle, the +error+ method will
+  # be called.  The +after+ method is called no matter what at the end of the
+  # lifecycle, even if an error has occurred.
+  #
+  class Command
+    def self.command_name
+      name.split("::").last.downcase
+    end
+
+    attr_reader :options
+    attr_reader :manager
+
+    # 
+    # Instantiated and given the tyrant manager instance it is to operate
+    # through and a hash of options
+    #
+    def initialize( manager, opts = {} )
+      @manager = manager
+      @options = opts
+    end
+
+    def command_name
+      self.class.command_name
+    end
+
+    def logger
+      Logging::Logger[self]
+    end
+
+    #------------------------------------------------------------------ 
+    # lifecycle calls
+    #------------------------------------------------------------------ 
+
+    # 
+    # call-seq:
+    #   cmd.before
+    #
+    # called to allow the command to setup anything post initialization it
+    # needs to be able to +run+.
+    #
+    def before() nil ; end
+
+    #
+    # call-seq:
+    #   cmd.run
+    #
+    # Yeah, this is where the work should be done.
+    #
+    def run() 
+      raise NotImplementedError, "The #run method must be implemented"
+    end
+
+    # 
+    # call-seq:
+    #   cmd.after
+    #
+    # called no matter what, after the execution of run() or error() if there was
+    # an exception.  It is here to allow the cmd to do cleanup work.
+    #
+    def after()  nil ; end
+
+    #
+    # call-seq:
+    #   cmd.error( exception )
+    #
+    # called if there is an exception during the before() or after() calls.  It
+    # is passed in the exception that was raised.
+    #
+    def error(exception)  nil ; end
+
+    #------------------------------------------------------------------ 
+    # registration
+    #------------------------------------------------------------------ 
+    class CommandNotFoundError < ::TyrantManager::Error ; end
+    class << Command
+      def inherited( klass )
+        return unless klass.instance_of? Class
+        self.list << klass
+      end
+
+      def list
+        unless defined? @list
+          @list = Set.new
+        end
+        return @list
+      end
+
+      def find( command )
+        klass = list.find { |klass| klass.command_name == command }
+        return klass if klass
+        names = list.collect { |c| c.command_name }
+        raise CommandNotFoundError, "No command for '#{command}' was found.  Known commands : #{names.join(",")}"
+      end
+    end
+  end
+end
+require 'tyrant_manager/commands/create_instance'
+require 'tyrant_manager/commands/start'
+require 'tyrant_manager/commands/stop'
+require 'tyrant_manager/commands/status'
+require 'tyrant_manager/commands/stats'
+require 'tyrant_manager/commands/list'
+require 'tyrant_manager/commands/replication_status'