tyrantmanager 1.0.9

data/gemspec.rb

@@ -0,0 +1,51 @@
+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("rake", ">= 0.8.1")
+  spec.add_dependency( "loquacious", "~> 1.3.0")
+  spec.add_dependency( "rufus-tokyo", "~> 1.0.0")
+  
+  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/cli.rb

@@ -0,0 +1,145 @@
+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('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( '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,118 @@
+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'

data/lib/tyrant_manager/commands/create_instance.rb

@@ -0,0 +1,27 @@
+require 'pathname'
+require 'tyrant_manager/command'
+class TyrantManager
+  module Commands
+    #
+    # Create a new Tyrant instance
+    #
+    class CreateInstance < Command
+      def self.command_name
+      'create-instance'
+      end
+
+      def run
+        path = Pathname.new( options['instance-home'] )
+        unless path.absolute? then
+          path = Pathname.new( manager.instances_path ) + path
+        end
+
+        unless path.exist? then
+          logger.info "Creating instance directory #{path}"
+          TyrantManager::TyrantInstance.setup( path.to_s )
+        end
+        tt = TyrantManager::TyrantInstance.new( path.to_s )
+      end
+    end
+  end
+end

data/lib/tyrant_manager/commands/list.rb

@@ -0,0 +1,28 @@
+require 'pathname'
+require 'tyrant_manager/command'
+class TyrantManager
+  module Commands
+    #
+    # List all known instances that the manager knows about
+    #
+    class List < Command
+      def run
+        manager.each_instance do |instance|
+          ilist = options['instances']
+          if ilist  == %w[ all ] or ilist.include?( instance.name ) then
+            parts = []
+            parts << ("%20s" % instance.name)
+            parts << "port #{instance.configuration.port}"
+            parts << instance.home_dir
+
+            if instance.configuration.master_server then
+              parts << "server id #{"%2d" % instance.configuration.server_id}"
+              parts << "replicating from #{instance.configuration.master_server}:#{instance.configuration.master_port}"
+            end
+            puts parts.join(" : ")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tyrant_manager/commands/start.rb

@@ -0,0 +1,32 @@
+require 'tyrant_manager/command'
+class TyrantManager
+  module Commands
+    # 
+    # Start one ore more instances
+    #
+    class Start < Command
+      def run
+        manager.each_instance do |instance|
+          ilist = options['instances']
+          if ilist  == %w[ all ] or ilist.include?( instance.name ) then
+            parts = [ "Starting #{instance.name}" ]
+            parts << instance.start_command
+
+            if options['dry-run'] then
+              parts << "(dry-run)"
+              logger.info parts.join(" : ")
+
+            elsif not instance.running? then
+              logger.info parts.join(" : ")
+              Dir.chdir( instance.home_dir ) do
+                instance.start 
+              end
+            else
+              logger.info "Instance #{instance.name} already running"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tyrant_manager/commands/stats.rb

@@ -0,0 +1,25 @@
+require 'tyrant_manager/command'
+class TyrantManager
+  module Commands
+    #
+    # List the stats about one or more instances
+    #
+    class Stats < Command
+      def run
+        manager.each_instance do |instance|
+          ilist = options['instances']
+          if ilist  == %w[ all ] or ilist.include?( instance.name ) then
+            puts "Instance #{instance.name} at #{instance.home_dir}"
+            conn = instance.connection
+            stats = conn.stat
+            stats.keys.sort.each do |k|
+              lhs = k.ljust(10, ".")
+              puts "    #{lhs} #{stats[k]}"
+            end
+            puts
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tyrant_manager/commands/status.rb

@@ -0,0 +1,22 @@
+require 'tyrant_manager/command'
+class TyrantManager
+  module Commands
+    #
+    # Report the status of one ore more tyrant intances
+    #
+    class Status < Command
+      def run
+        manager.each_instance do |instance|
+          ilist = options['instances']
+          if ilist  == %w[ all ] or ilist.include?( instance.name ) then
+            if instance.running? then
+              logger.info "#{instance.name} is running as pid #{instance.pid}"
+            else
+              logger.info "#{instance.name} is not running, or its pid file is gone"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tyrant_manager/commands/stop.rb

@@ -0,0 +1,23 @@
+require 'tyrant_manager/command'
+class TyrantManager
+  module Commands
+    #
+    # Stop one or more tyrant instances
+    #
+    class Stop < Command
+      def run
+        manager.each_instance do |instance|
+          ilist = options['instances']
+          if ilist  == %w[ all ] or ilist.include?( instance.name ) then
+            if File.exist?( instance.pid_file ) then
+              logger.info "Stopping #{instance.name} : pid #{instance.pid}"
+              instance.stop
+            else
+              logger.info "Stopping #{instance.name} : no pid file, nothing to do"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tyrant_manager/log.rb

@@ -0,0 +1,91 @@
+require 'logging'
+require 'tyrant_manager'
+
+class TyrantManager
+  ::Logging::Logger[self].level = :info
+
+  def self.logger
+    ::Logging::Logger[self]
+  end
+
+  module Log
+    def self.init( options = {} )
+      appender = Logging.appenders.stderr 
+      appender.layout = self.console_layout
+      if options['log-file'] then
+        appender = ::Logging::Appenders::File.new(
+          'tyrant_manager',
+          :filename => options['log-file'],
+          :layout   => self.layout
+        )
+      end
+
+      TyrantManager.logger.add_appenders( appender )
+      self.level = options['log-level'] || :info
+    end
+
+    def self.logger
+      TyrantManager.logger
+    end
+
+    def self.default_level
+      :info
+    end
+
+    def self.console
+      Logging.appenders.stderr.level
+    end
+
+    def self.console=( level )
+      Logging.appenders.stderr.level = level
+    end
+
+    def self.level
+      ::Logging::Logger[TyrantManager].level
+    end
+
+    def self.level=( l )
+      ::Logging::Logger[TyrantManager].level = l
+    end
+
+    def self.layout
+      @layout ||= Logging::Layouts::Pattern.new(
+        :pattern      => "[%d] %5l %6p %c : %m\n",
+        :date_pattern => "%Y-%m-%d %H:%M:%S"
+      )
+    end
+
+    def self.console_layout
+      @layout ||= Logging::Layouts::Pattern.new(
+        :pattern      => "%d %5l : %m\n",
+        :date_pattern => "%H:%M:%S"
+      )
+    end
+
+    #   
+    # Turn off the console logging
+    #   
+    def self.silent!
+      logger.level = :off
+    end 
+
+    #   
+    # Resume logging
+    #   
+    def self.resume
+      logger.level = self.default_level
+    end 
+
+    #   
+    # Turn off logging for the execution of a block
+    #   
+    def self.silent( &block )
+      begin
+        silent!
+        block.call
+      ensure
+        resume
+      end
+    end
+  end
+end

data/lib/tyrant_manager/paths.rb

@@ -0,0 +1,77 @@
+require 'rbconfig'
+class TyrantManager
+  module Paths
+    # The installation directory of the project is considered to be the parent directory
+    # of the 'lib' directory.
+    #   
+    def install_dir
+      @install_dir ||= (
+        path_parts = ::File.expand_path(__FILE__).split(::File::SEPARATOR)
+        lib_index  = path_parts.rindex("lib")
+        path_parts[0...lib_index].join(::File::SEPARATOR) + ::File::SEPARATOR
+      )
+    end 
+
+    def install_path( sub, *args )
+      sub_path( install_dir, sub, *args )
+    end
+
+    def bin_path( *args )
+      install_path( 'bin', *args )
+    end
+
+    def lib_path( *args )
+      install_path( "lib", *args )
+    end 
+
+    def data_path( *args )
+      install_path( "data", *args )
+    end
+
+    def spec_path( *args )
+      install_path( "spec", *args )
+    end
+
+    # The home dir is the home directory of the project while it is running
+    # by default, this the same as the install_dir.  But if this value is set 
+    # then it affects other paths
+    def home_dir
+      @home_dir ||= install_dir
+    end
+
+    def home_dir=( other )
+      @home_dir = File.expand_path( other )
+    end
+
+    def home_path( sub, *args )
+      sub_path( home_dir, sub, *args )
+    end
+
+    def instances_path( *args )
+      home_path( "instances", *args )
+    end
+
+    def log_path( *args )
+      home_path( "log", *args )
+    end
+
+    def tmp_path( *args )
+      home_path( "tmp", *args )
+    end
+
+    def sub_path( parent, sub, *args )
+      sp = ::File.join( parent, sub ) + File::SEPARATOR
+      sp = ::File.join( sp, *args ) if args
+    end
+
+    extend self
+  end
+  extend Paths
+
+  # set the default home_dir for the manager to be the lib/tyrant in the local
+  # state dir directory.  Instances are below them.
+  self.home_dir = File.join( Config::CONFIG['localstatedir'], 'lib', 'tyrant' )
+  def self.default_instances_dir
+    self.home_path( "instances" )
+  end
+end

data/lib/tyrant_manager/runner.rb

@@ -0,0 +1,33 @@
+require 'tyrant_manager/command'
+
+class TyrantManager
+  class Runner
+
+    attr_reader :options
+    attr_reader :manager
+
+    def initialize( manager, opts = {} )
+      @manager = manager
+      @options = opts
+    end
+
+    def logger
+      ::Logging::Logger[self]
+    end
+
+    def run( command_name )
+      cmd = Command.find( command_name ).new( self.manager, self.options )
+      begin
+        cmd.before
+        cmd.run
+      rescue => e
+        logger.error "while running #{command_name} : #{e.message}"
+        e.backtrace.each do |l|
+          logger.warn l.strip
+        end
+      ensure
+        cmd.after
+      end
+    end
+  end
+end