tyrantmanager 1.0.9

data/lib/tyrant_manager/tyrant_instance.rb

@@ -0,0 +1,340 @@
+require 'tyrant_manager'
+require 'rufus/tokyo/tyrant'
+require 'erb'
+
+class TyrantManager
+  class TyrantInstance
+    class << TyrantInstance
+      def logger
+        Logging::Logger[self]
+      end
+      #
+      # Create all the directories needed for a tyrant
+      #
+      def setup( dir )
+        unless File.directory?( dir )
+          logger.info "Creating directory #{dir}"
+          FileUtils.mkdir_p( dir )
+        end
+
+        cfg = File.join( dir, TyrantManager.config_file_basename )
+        instance_name = File.basename( dir )
+
+        unless File.exist?( cfg )
+          template = TyrantManager::Paths.data_path( "default_instance_config.rb" )
+          logger.info "Creating default config file #{cfg}"
+          File.open( cfg, "w+" ) do |f|
+            f.write ERB.new( IO.read( template ) ).result( binding )
+          end
+        end
+
+        %w[ ulog data lua log ].each do |subdir|
+          subdir = File.join( dir, subdir )
+          unless File.directory?( subdir ) then
+            logger.info "Creating directory #{subdir}"
+            FileUtils.mkdir subdir 
+          end
+        end
+
+        return TyrantInstance.new( dir )
+      end
+    end
+
+    # the full path to the instance home directory
+    attr_reader :home_dir
+
+    # the name of this instance
+    attr_reader :name 
+
+    # the manager that is associated with this instance
+    attr_accessor :manager
+
+    #
+    # Create an instance connected to the tyrant located in the given directory
+    #
+    def initialize( dir )
+      @home_dir = File.expand_path( dir )
+      @name     = File.basename( @home_dir )
+      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 instance
+    #
+    def config_file
+      @config_file ||= File.join( home_dir, TyrantManager.config_file_basename ) 
+    end
+
+    #
+    # load the configuration
+    #
+    def configuration
+      unless @configuration then
+        eval(  IO.read( self.config_file ) )
+        @configuration = Loquacious::Configuration.for( name )
+      end
+      return @configuration
+    end
+
+    #
+    # The pid file
+    #
+    def pid_file
+      @pid_file ||= append_to_home_if_not_absolute( configuration.pid_file )
+    end
+
+    #
+    # The pid of the service
+    #
+    def pid
+      Float( IO.read( pid_file ).strip ).to_i
+    end
+
+    #
+    # The log file
+    #
+    def log_file
+      @log_file ||= append_to_home_if_not_absolute( configuration.log_file )
+    end
+
+    #
+    # The lua extension file to load on start
+    #
+    def lua_extension_file
+      @lua_extension_file ||= append_to_home_if_not_absolute( configuration.lua_extension_file )
+    end
+
+    #
+    # The lua extension file to load on start
+    #
+    def replication_timestamp_file
+      @replication_timestamp_file ||= append_to_home_if_not_absolute( configuration.replication_timestamp_file )
+    end
+
+    #
+    # The directory housing the database file
+    #
+    def data_dir
+      @data_dir ||= append_to_home_if_not_absolute( configuration.data_dir )
+    end
+
+    #
+    # The full path to the database file.
+    #
+    def db_file( type = configuration.type )
+      unless @db_file then
+        @db_file = case type
+                   when "memory-hash" then "*"
+                   when "memory-tree" then "+"
+                   when "hash"        then File.join( data_dir, "#{name}.tch" )
+                   when "tree"        then File.join( data_dir, "#{name}.tcb" )
+                   when "fixed"       then File.join( data_dir, "#{name}.tcf" )
+                   when "table"       then File.join( data_dir, "#{name}.tct" )
+                   else
+                     raise Error, "Unknown configuration type [#{configuration.type}]"
+                   end
+      end
+      return @db_file
+    end
+
+    #
+    # The directory housing the database file
+    #
+    def ulog_dir
+      @ulog_dir ||= append_to_home_if_not_absolute( configuration.ulog_dir )
+    end
+
+    #
+    # The lua extension file
+    #
+    def lua_extension_file
+      @lua_extension_file ||= append_to_home_if_not_absolute( configuration.lua_extension_file )
+    end
+
+    #
+    # The replication timestamp file
+    #
+    def replication_timestamp_file
+      @replication_timestamp_file ||= append_to_home_if_not_absolute( configuration.replication_timestamp_file )
+    end
+
+
+    #
+    # Start command.
+    #
+    # This is a bit convoluted to bring together all the options and put them
+    # into one big commandline item.  
+    #
+    def start_command
+
+      ##-- ttserver executable
+      parts = [ manager.configuration.ttserver ]
+
+      ##-- host and port
+      parts << "-host #{configuration.host}" if configuration.host
+      parts << "-port #{configuration.port}" if configuration.port
+
+      ##-- thread options
+      if thnum = cascading_config( 'thread_count' ) then
+        parts << "-thnum #{thnum}"
+      end
+      if tout = cascading_config( 'session_timeout' ) then
+        parts << "-tout #{tout}"
+      end
+
+      ##-- daemoization and pid
+      parts << "-dmn" if cascading_config( 'daemonize' )
+      parts << "-pid #{pid_file}"
+
+
+      ##-- logging
+      parts << "-log #{log_file}"
+      if log_level = cascading_config( 'log_level' ) then
+        if log_level == "error" then
+          parts << "-le"
+        elsif log_level == "debug" then
+          parts << "-ld" 
+        elsif log_level == "info" then
+          # leave it at info
+        else
+          raise Error, "Invalid log level setting [#{log_level}]"
+        end
+      end
+
+      ##-- update logs
+      parts << "-ulog #{ulog_dir}"
+      if ulim = cascading_config( 'update_log_size' )then
+        parts << "-ulim #{ulim}"
+      end
+      parts << "-uas" if cascading_config( 'update_log_async' )
+
+      ##-- replication items, server id, master, replication timestamp file
+      parts << "-sid #{configuration.server_id}"       if configuration.server_id
+      parts << "-mhost #{configuration.master_server}" if configuration.master_server
+      parts << "-mport #{configuration.master_port}"   if configuration.master_port
+      parts << "-rts #{replication_timestamp_file}" if configuration.replication_timestamp_file
+
+      ##-- lua extension
+      if configuration.lua_extension_file then
+        if File.exist?( lua_extension_file ) then
+          parts << "-ext #{lua_extension_file}" 
+          if pc = configuration.periodic_command then
+            if pc.name and pc.period then
+              parts << "-extpc #{pc.name} #{pc.period}"
+            end
+          end
+        end
+      end
+
+      ##-- command permissiosn
+      if deny = cascading_config( "deny_commands" ) then
+        parts << "-mask #{deny.join(",")}"
+      end
+
+      if allow = cascading_config( "allow_commands" ) then
+        parts << "-unmask #{allow.join(",")}"
+      end
+
+      ##-- now for the filename.  The format is
+      #  filename.ext#opts=ld#mode=wc#tuning_param=value#tuning_param=value...
+      #
+      file_pairs = []
+      file_pairs << "opts=#{configuration.opts}"
+      file_pairs << "mode=#{configuration.mode}"
+      Loquacious::Configuration::Iterator.new( configuration.tuning_params ).each do |node|
+        file_pairs << "#{node.name}=#{node.obj}" if node.obj
+      end
+
+      file_name_and_params = "#{db_file}##{file_pairs.join("#")}"
+
+      parts << file_name_and_params
+
+      return parts.join( " " )  
+    end
+
+    #
+    # Start the tyrant
+    #
+    def start
+      o = %x[ #{start_command} ]
+      logger.info o
+    end
+
+    # 
+    # kill the proc
+    #
+    def stop
+      begin
+        _pid = self.pid
+        Process.kill( "TERM" , _pid )
+        logger.info "Sent signal TERM to #{_pid}"
+      rescue Errno::EPERM
+        logger.info "Process #{_pid} is beyond my control"
+      rescue Errno::ESRCH
+        logger.info "Process #{_pid} is dead"
+      rescue => e
+        logger.error "Problem sending kill(TERM, #{_pid}) : #{e}"
+      end
+    end
+
+
+    #
+    # check if process is alive
+    #
+    def running?
+      begin
+        if File.exist?( self.pid_file ) then
+          _pid = self.pid
+          Process.kill( 0, _pid )
+          return true
+        else
+          return false
+        end
+      rescue Errno::EPERM
+        logger.info "Process #{_pid} is beyond my control"
+      rescue Errno::ESRCH
+        logger.info "Process #{_pid} is dead"
+        return false
+      rescue => e
+        logger.error "Problem sending kill(0, #{_pid}) : #{e}"
+      end
+    end
+
+    #
+    # return a network connection to this instance
+    #
+    def connection
+      Rufus::Tokyo::Tyrant.new( configuration.host, configuration.port.to_i )
+    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
+
+    #
+    # retrieve the cascading option from our config or the managers config if we
+    # don't have it.
+    #
+    def cascading_config( name )
+      configuration[name] || manager.configuration.instance_defaults[name]
+    end
+  end
+end

data/lib/tyrant_manager/version.rb

@@ -0,0 +1,27 @@
+#--
+# Copyright (c) 2009 Jeremy Hinegardner
+# All rights reserved.  See LICENSE and/or COPYING for details
+#++
+
+class TyrantManager
+  module Version
+    MAJOR   = 1
+    MINOR   = 0
+    BUILD   = 9
+
+    def to_a 
+      [MAJOR, MINOR, BUILD]
+    end
+
+    def to_s
+      to_a.join(".")
+    end
+
+    def to_hash
+      { :major => MAJOR, :minor => MINOR, :build => BUILD }
+    end
+
+    extend self
+  end
+  VERSION = Version.to_s
+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/tyrantmanager.rb

@@ -0,0 +1,2 @@
+require 'tyrant_manager'
+

data/spec/command_spec.rb

@@ -0,0 +1,37 @@
+require File.expand_path( File.join( File.dirname( __FILE__ ),"spec_helper.rb"))
+
+require 'tyrant_manager/command'
+
+class Junk < TyrantManager::Command; end
+
+describe TyrantManager::Command do
+  before( :each ) do
+    @cmd = TyrantManager::Command.new( nil )
+  end
+
+  it "has a command name" do
+    @cmd.command_name.should == "command"
+  end
+
+  it "can log" do
+    @cmd.logger.info "this is a log statement"
+    spec_log.should =~ /this is a log statement/
+  end
+
+  it "raises an error if it cannot find the class required" do
+    lambda { TyrantManager::Command.find( "foo" ) }.should raise_error( TyrantManager::Command::CommandNotFoundError, 
+                                                                       /No command for 'foo' was found./ )
+  end
+
+  it "registers inherited classes" do
+    TyrantManager::Command.list.should be_include( Junk )
+    TyrantManager::Command.list.delete( Junk )
+    TyrantManager::Command.list.should_not be_include(Junk)
+  end
+
+  it "classes cannot be run without implementing 'run'" do
+    j = Junk.new( nil )
+    j.respond_to?(:run).should == true
+    lambda { j.run }.should raise_error( NotImplementedError, /The #run method must be implemented/)
+  end
+end

data/spec/paths_spec.rb

@@ -0,0 +1,57 @@
+require File.expand_path(File.join(File.dirname(__FILE__),"spec_helper.rb"))
+
+require 'tyrant_manager/paths' 
+
+describe TyrantManager::Paths do
+  before(:each) do
+    @install_dir = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+    @install_dir += "/"
+  end
+
+  it "root dir should be correct" do
+    TyrantManager::Paths.install_dir.should == @install_dir
+  end
+
+  it "home dir should be correct" do
+    TyrantManager::Paths.home_dir.should == @install_dir
+  end
+
+  %w[ bin lib spec data log tmp ].each do |d|
+    it "#{d} path should be correct" do
+      TyrantManager::Paths.send( "#{d}_path" ).should == File.join(@install_dir, "#{d}/" )
+    end
+  end
+
+  describe "setting home_dir" do
+    before( :each ) do
+      @tmp_dir = "/some/location/#{Process.pid}"
+      TyrantManager::Paths.home_dir = @tmp_dir
+    end
+
+    %w[ log tmp instances ].each do |d|
+      check_path = "#{d}_path"
+      it "affects the location of #{check_path}" do
+        p = TyrantManager::Paths.send( check_path )
+        p.should == ( File.join( @tmp_dir, d ) + File::SEPARATOR )
+      end
+    end
+
+    %w[ bin lib spec data ].each do |d|
+      check_path = "#{d}_path"
+      it "does not affect the location of #{check_path}" do
+        p = TyrantManager::Paths.send( check_path )
+        p.should == ( File.join( @install_dir, d ) + File::SEPARATOR )
+      end
+    end
+  end
+
+  describe "Default TyrantManager home_dir" do
+    it 'has a different default home_dir for the top level TyrantManager' do
+      TyrantManager.home_dir.should == File.join( Config::CONFIG['localstatedir'], 'lib', 'tyrant' )
+    end
+    
+    it "has an instances dir" do
+      TyrantManager.default_instances_dir.should == File.join( Config::CONFIG['localstatedir'], 'lib', 'tyrant', 'instances' ) + "/"
+    end
+  end
+end