jackowayed-tyrantmanager 1.1.0

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/replication_status.rb

@@ -0,0 +1,92 @@
+require 'tyrant_manager/command'
+require 'socket'
+
+class TyrantManager
+  module Commands
+    #
+    # Report on the replication status of the server(s)
+    #
+    class ReplicationStatus< Command
+      def self.command_name
+        'replication-status'
+      end
+
+      def run
+        manager.each_instance do |instance|
+          ilist = options['instances']
+          if ilist  == %w[ all ] or ilist.include?( instance.name ) then
+            if instance.running? and instance.is_slave? then
+              s_stat = instance.stat
+              logger.info "#{instance.name} is replicating from #{s_stat['mhost']}:#{s_stat['mport']}"
+              if m_conn = validate_master_connection( instance ) then
+                if validate_master_master( instance.connection, m_conn ) then
+                  m_stat = m_conn.stat
+                  m_name = "#{s_stat['mhost']}:#{s_stat['mport']}"
+
+                  primary, failover = instance.connection, m_conn
+
+                  if m_stat['delay'] > s_stat['delay'] then
+                    primary, failover = m_conn, instance.connection
+                  end
+
+                  p_stat = primary.stat
+                  p_name = "#{ip_of( primary.host )}:#{primary.port}"
+
+                  f_stat = failover.stat
+                  f_name = "#{ip_of( failover.host )}:#{failover.port}"
+
+                  n_width = [ p_name.length, f_name.length ].max
+
+                  logger.info "  Primary master  : #{p_name} -> #{p_stat['rnum']} records, primary since #{(Time.now - ( Float(primary.stat['delay']))).strftime("%Y-%m-%d %H:%M:%S")}"
+                  logger.info "  Failover master : #{f_name} -> #{f_stat['rnum']} records, last replicated #{failover.stat['delay']} seconds ago"
+                end
+              end
+              logger.info ""
+            end
+          end
+        end
+      end
+
+      private
+
+      def validate_master_master( slave, master )
+        m_stat = master.stat
+        s_stat = slave.stat
+
+        if ( m_stat['mhost'] and m_stat['mport'] ) then
+          logger.info "  #{s_stat['mhost']}:#{s_stat['mport']} is replicating from #{m_stat['mhost']}:#{m_stat['mport']}"
+          mm_ip = ip_of( m_stat['mhost'] )
+          s_ip = ip_of( slave.host )
+          if ( s_ip == mm_ip ) and ( slave.port == m_stat['mport'].to_i ) then
+            #logger.info "    - this is a good master-master relationship"
+            return true 
+          else
+            logger.error "  Unsupported replication configuration!!!"
+            logger.error "  (original hostnames) #{slave.host}:#{slave.port} -> #{(master.host)}:#{master.port} -> #{m_stat['mhost']}:#{m_stat['mport']}"
+            logger.error "  (hostnames resolved) #{s_ip}:#{slave.port} -> #{ip_of(master.host)}:#{master.port} -> #{ip_of(m_stat['mhost'])}:#{m_stat['mport']}"
+            return false
+          end
+        end
+      end
+
+      def ip_of( hostname )
+        hostname = Socket.gethostname if %w[ localhost 0.0.0.0 ].include?( hostname )
+        addr_info = Socket.getaddrinfo( hostname, 1978, "AF_INET" )
+        return addr_info.first[3]
+      end
+
+      def validate_master_connection( slave ) 
+        begin
+          m_conn = slave.master_connection
+          m_stat = m_conn.stat
+          return m_conn
+        rescue => e
+          logger.error e
+          s_stat = slave.stat
+          logger.error "Master server #{s_stat["mhost"]}:#{s_stat['mport']} appears to be down."
+        end
+        return nil
+      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,24 @@
+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}"
+            stats = instance.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,26 @@
+require 'tyrant_manager/command'
+class TyrantManager
+  module Commands
+    #
+    # Report the status of one ore more tyrant intances
+    #
+    class ProcessStatus < Command
+      def self.command_name
+        'process-status'
+      end
+
+      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