tyrantmanager 1.0.9

data/spec/spec_helper.rb

@@ -0,0 +1,58 @@
+require 'rubygems'
+require 'spec'
+require 'logging'
+
+$:.unshift File.expand_path( File.join( File.dirname( __FILE__ ),"..","lib"))
+
+
+Logging::Logger['TyrantManager'].level = :all
+
+module Spec
+  module Log
+    def self.io
+      @io ||= StringIO.new
+    end
+    def self.appender
+      @appender ||= Logging::Appenders::IO.new( "speclog", io )
+    end
+
+    Logging::Logger['TyrantManager'].add_appenders( Log.appender )
+
+    def self.layout
+      @layout ||= Logging::Layouts::Pattern.new(
+        :pattern      => "[%d] %5l %6p %c : %m\n",
+        :date_pattern => "%Y-%m-%d %H:%M:%S"
+      )
+    end
+
+    Log.appender.layout = layout
+  end
+
+  module Helpers
+    require 'tmpdir'
+    def temp_dir( unique_id = $$ )
+      dirname = File.join( Dir.tmpdir, "tyrant-spec-#{unique_id}" )
+      FileUtils.mkdir_p( dirname ) unless File.directory?( dirname )
+      # for osx
+      dirname = Dir.chdir( dirname ) { Dir.pwd }
+    end
+
+    def spec_log
+      Log.io.string
+    end
+  end
+end
+
+Spec::Runner.configure do |config|
+  config.include Spec::Helpers
+
+  config.before do
+    Spec::Log.io.rewind
+    Spec::Log.io.truncate( 0 )
+  end
+
+  config.after do
+    Spec::Log.io.rewind
+    Spec::Log.io.truncate( 0 )
+  end
+end

data/spec/tyrant_instance_spec.rb

@@ -0,0 +1,83 @@
+require File.expand_path(File.join(File.dirname(__FILE__),"spec_helper.rb"))
+
+require 'tyrant_manager'
+require 'tyrant_manager/tyrant_instance'
+
+describe TyrantManager::TyrantInstance  do
+  before( :each ) do
+    @tdir = File.join( temp_dir, 'tyrant' )
+    TyrantManager::Log.silent {
+      @mgr = TyrantManager.setup( @tdir )
+      @idir   = @mgr.instances_path( "test" )
+      @tyrant = TyrantManager::TyrantInstance.setup( @idir )
+      @tyrant.manager = @mgr
+    }
+  end
+
+  after( :each ) do
+    FileUtils.rm_rf @tdir
+  end
+
+  it "raises an exception if given an invalid directory on initialization" do
+    lambda { TyrantManager::TyrantInstance.new( "/tmp" ) }.should raise_error( TyrantManager::Error, /tmp is not a valid archive/ )
+  end
+
+  it "#config_file" do
+    @tyrant.config_file.should == File.join( @tdir, "instances", "test", "config.rb" )
+    File.exist?( @tyrant.config_file ).should == true
+  end
+
+  it "#configuration" do
+    @tyrant.configuration.should_not == nil
+  end
+
+  it "#pid_file" do
+    @tyrant.pid_file.should == File.join( @tdir, "instances", "test", "test.pid" )
+  end
+
+  it "#log_file" do
+    @tyrant.log_file.should == File.join( @tdir, "instances", "test", "log", "test.log" )
+  end
+
+  it "#replication_timestamp_file" do
+    @tyrant.replication_timestamp_file.should == File.join( @tdir, "instances", "test", "test.rts" )
+  end
+
+  it "#lua_extension_file" do
+    @tyrant.lua_extension_file.should == File.join( @tdir, "instances", "test", "lua", "test.lua" )
+  end
+
+  it "#data_dir" do
+    @tyrant.data_dir.should == File.join( @tdir, "instances", "test", "data" )
+  end
+
+
+  describe "database types" do
+    { 'memory-hash' => "*",
+      'memory-tree' => "+",
+      'hash'        => "tch",
+      'tree'        => "tcb",
+      'fixed'       => "tcf",
+      'table'       => "tct"
+    }.each_pair do |db_type, db_ext|
+      it "db_type of #{db_type} is db file with ext #{db_ext}" do
+        f = @tyrant.db_file( db_type )
+        if f.size == 1 then
+          f.should == db_ext
+        else
+          f.should == File.join( @tdir, "instances", "test", "data", "test.#{db_ext}" )
+        end
+      end
+    end
+  end
+
+  it "#ulog_dir" do
+    @tyrant.ulog_dir.should == File.join( @tdir, "instances", "test", "ulog" )
+  end
+
+
+  it "#start_command" do
+    @tyrant.start_command.should =~ /^ttserver/
+  end
+
+end

data/spec/tyrant_manager_spec.rb

@@ -0,0 +1,69 @@
+require File.expand_path(File.join(File.dirname(__FILE__),"spec_helper.rb"))
+
+require 'tyrant_manager'
+
+describe TyrantManager do
+  before( :each ) do
+    @tdir = File.join( temp_dir, 'tyrant' )
+    TyrantManager::Log.silent {
+      @mgr  = TyrantManager.setup( @tdir )
+    }
+    #TyrantManager::Log.level = :debug
+  end
+
+  after( :each ) do
+    #puts spec_log
+    FileUtils.rm_rf @tdir
+  end
+
+  describe "#default_directory" do
+    it "uses the current working directory" do
+      Dir.chdir( @tdir ) do |d|
+        TyrantManager.default_directory.should == d
+      end
+    end
+
+    it "uses the TYRANT_MANAGER_HOME environment variable" do
+      ENV['TYRANT_MANAGER_HOME'] = @tdir
+      TyrantManager.default_directory.should == @tdir
+    end
+  end
+
+  it "initializes with an existing directory" do
+    t = TyrantManager.new( @tdir )
+    t.config_file.should == File.join( @tdir, "config.rb" )
+  end
+
+  it "raises an error if attempting to initialize from a non-existent tyrnat home" do
+    lambda { TyrantManager.new( "/tmp" ) }.should raise_error( TyrantManager::Error, /\/tmp is not a valid archive/ )
+  end
+
+  it "#config_file" do
+    @mgr.config_file.should == File.join( @tdir, "config.rb" )
+    File.exist?( @mgr.config_file ).should == true
+  end
+
+  it "#configuration" do
+    @mgr.configuration.should_not == nil
+  end
+
+  it "has the location of the ttserver command" do
+    @mgr.configuration.ttserver.should == "ttserver"
+  end
+
+  it "knows all its instances" do
+    3.times do |x|
+      idir   = @mgr.instances_path( "test#{x}" )
+      TyrantManager::TyrantInstance.setup( idir )
+    end
+
+    @mgr.instances.size.should == 3
+    names = []
+    @mgr.each_instance do |i|
+      i.name.should =~ /test\d/
+      names << i.name
+    end
+
+    names.sort.should == %w[ test0 test1 test2 ]
+  end
+end

data/spec/version_spec.rb

@@ -0,0 +1,16 @@
+require File.expand_path(File.join(File.dirname(__FILE__),"spec_helper.rb"))
+
+describe "TyrantManager::Version" do
+
+  it "should have a version string" do
+    TyrantManager::Version.to_s.should =~ /\d+\.\d+\.\d+/
+    TyrantManager::VERSION.should =~ /\d+\.\d+\.\d+/
+  end
+
+  it "should have a version hash" do
+    h = TyrantManager::Version.to_hash
+    [ :major, :minor, :build ].each do |k|
+      h[k].should_not be_nil
+    end
+  end
+end

data/tasks/announce.rake

@@ -0,0 +1,43 @@
+require 'tasks/config'
+#-------------------------------------------------------------------------------
+# announcement methods
+#-------------------------------------------------------------------------------
+
+proj_config = Configuration.for('project')
+namespace :announce do
+  desc "create email for ruby-talk"
+  task :email do
+    info = Utils.announcement
+
+    File.open("email.txt", "w") do |mail|
+      mail.puts "From: #{proj_config.author} <#{proj_config.email}>"
+      mail.puts "To: ruby-talk@ruby-lang.org"
+      mail.puts "Date: #{Time.now.rfc2822}"
+      mail.puts "Subject: [ANN] #{info[:subject]}"
+      mail.puts
+      mail.puts info[:title]
+      mail.puts 
+      mail.puts "{{ Release notes for Version #{TyrantManager::VERSION} }}"
+      mail.puts 
+      mail.puts info[:release_notes]
+      mail.puts
+      mail.puts "  #{info[:urls]}"
+      mail.puts
+      mail.puts "=== Installation"
+      mail.puts
+      mail.puts "  gem install #{TyrantManager::GEM_SPEC.name}"
+      mail.puts
+      mail.puts "=== Description"
+      mail.puts
+      mail.puts info[:description]
+      mail.puts
+    end 
+    puts "Created the following as email.txt:"
+    puts "-" * 72
+    puts File.read("email.txt")
+    puts "-" * 72
+  end 
+
+  CLOBBER << "email.txt"
+end
+

data/tasks/config.rb

@@ -0,0 +1,99 @@
+require 'configuration'
+
+require 'rake'
+require 'tasks/utils'
+
+#-----------------------------------------------------------------------
+# General project configuration
+#-----------------------------------------------------------------------
+Configuration.for('project') {
+  name          "tyrantmanager"
+  version       TyrantManager::VERSION
+  author        "Jeremy Hinegardner"
+  email         "jeremy@copiousfreetime.org"
+  homepage      "http://copiousfreetime.rubyforge.org/tyrantmanager/"
+  description   Utils.section_of("README", "description")
+  summary       description.split(".").first
+  history       "HISTORY"
+  license       FileList["LICENSE"]
+  readme        "README"
+}
+
+#-----------------------------------------------------------------------
+# Packaging 
+#-----------------------------------------------------------------------
+Configuration.for('packaging') {
+  # files in the project 
+  proj_conf = Configuration.for('project')
+  files {
+    bin       FileList["bin/*"]
+    ext       FileList["ext/*.{c,h,rb}"]
+    lib       FileList["lib/**/*.rb"]
+    test      FileList["spec/**/*.rb", "test/**/*.rb"]
+    data      FileList["data/**/*"]
+    tasks     FileList["tasks/**/*.r{ake,b}"]
+    rdoc      FileList[proj_conf.readme, proj_conf.history,
+                       proj_conf.license] + lib
+    all       bin + ext + lib + test + data + rdoc + tasks 
+  }
+
+  # ways to package the results
+  formats {
+    tgz true
+    zip true
+    rubygem Configuration::Table.has_key?('rubygem')
+  }
+}
+
+#-----------------------------------------------------------------------
+# Gem packaging
+#-----------------------------------------------------------------------
+Configuration.for("rubygem") {
+  spec "gemspec.rb"
+  Configuration.for('packaging').files.all << spec
+}
+
+#-----------------------------------------------------------------------
+# Testing
+#   - change mode to 'testunit' to use unit testing
+#-----------------------------------------------------------------------
+Configuration.for('test') {
+  mode      "spec"
+  files     Configuration.for("packaging").files.test
+  options   %w[ --format specdoc --color ]
+  ruby_opts %w[ ]
+}
+
+#-----------------------------------------------------------------------
+# Rcov 
+#-----------------------------------------------------------------------
+Configuration.for('rcov') {
+  output_dir  "coverage"
+  libs        %w[ lib ]
+  rcov_opts   %w[ --html ]
+  ruby_opts   %w[ ]
+  test_files  Configuration.for('packaging').files.test
+}
+
+#-----------------------------------------------------------------------
+# Rdoc 
+#-----------------------------------------------------------------------
+Configuration.for('rdoc') {
+  files       Configuration.for('packaging').files.rdoc
+  main_page   files.first
+  title       Configuration.for('project').name
+  options     %w[ ]
+  output_dir  "doc"
+}
+
+#-----------------------------------------------------------------------
+# Rubyforge 
+#-----------------------------------------------------------------------
+Configuration.for('rubyforge') {
+  project       "copiousfreetime"
+  user          "jjh"
+  host          "rubyforge.org"
+  rdoc_location "#{user}@#{host}:/var/www/gforge-projects/#{project}/tyrantmanager/"
+}
+
+

data/tasks/distribution.rake

@@ -0,0 +1,38 @@
+require 'tasks/config'
+
+#-------------------------------------------------------------------------------
+# Distribution and Packaging
+#-------------------------------------------------------------------------------
+if pkg_config = Configuration.for_if_exist?("packaging") then
+
+  require 'gemspec'
+  require 'rake/gempackagetask'
+  require 'rake/contrib/sshpublisher'
+
+  namespace :dist do
+
+    Rake::GemPackageTask.new(TyrantManager::GEM_SPEC) do |pkg|
+      pkg.need_tar = pkg_config.formats.tgz
+      pkg.need_zip = pkg_config.formats.zip
+    end
+
+    desc "Install as a gem"
+    task :install => [:clobber, :package] do
+      sh "sudo gem install pkg/#{TyrantManager::GEM_SPEC.full_name}.gem"
+    end
+
+    desc "Uninstall gem"
+    task :uninstall do 
+      sh "sudo gem uninstall -x #{TyrantManager::GEM_SPEC.name}"
+    end
+
+    desc "dump gemspec"
+    task :gemspec do
+      puts TyrantManager::GEM_SPEC.to_ruby
+    end
+
+    desc "reinstall gem"
+    task :reinstall => [:uninstall, :repackage, :install]
+
+ end
+end

data/tasks/documentation.rake

@@ -0,0 +1,32 @@
+require 'tasks/config'
+
+#-----------------------------------------------------------------------
+# Documentation
+#-----------------------------------------------------------------------
+
+if rdoc_config = Configuration.for_if_exist?('rdoc') then
+
+  namespace :doc do
+
+    require 'rdoc'
+    require 'rake/rdoctask'
+
+    # generating documentation locally
+    Rake::RDocTask.new do |rdoc|
+      rdoc.rdoc_dir   = rdoc_config.output_dir
+      rdoc.options    = rdoc_config.options
+      rdoc.rdoc_files = rdoc_config.files
+      rdoc.title      = rdoc_config.title
+      rdoc.main       = rdoc_config.main_page
+    end 
+
+    if rubyforge_config = Configuration.for_if_exist?('rubyforge') then
+      desc "Deploy the RDoc documentation to #{rubyforge_config.rdoc_location}"
+      task :deploy => :rerdoc do
+        sh "rsync -zav --delete #{rdoc_config.output_dir}/ #{rubyforge_config.rdoc_location}"
+      end 
+    end 
+
+  end 
+end
+

data/tasks/rspec.rake

@@ -0,0 +1,29 @@
+
+require 'tasks/config'
+
+#--------------------------------------------------------------------------------
+# configuration for running rspec.  This shows up as the test:default task
+#--------------------------------------------------------------------------------
+if spec_config = Configuration.for_if_exist?("test") then
+  if spec_config.mode == "spec" then
+    namespace :test do
+
+      task :default => :spec
+
+      require 'spec/rake/spectask'
+      Spec::Rake::SpecTask.new do |r| 
+        r.ruby_opts   = spec_config.ruby_opts
+        r.libs        = [ TyrantManager.lib_path, 
+                          TyrantManager.install_dir ]
+        r.spec_files  = spec_config.files 
+        r.spec_opts   = spec_config.options
+
+        if rcov_config = Configuration.for_if_exist?('rcov') then
+          r.rcov      = true
+          r.rcov_dir  = rcov_config.output_dir
+          r.rcov_opts = rcov_config.rcov_opts
+        end
+      end
+    end
+  end
+end

data/tasks/rubyforge.rake

@@ -0,0 +1,51 @@
+require 'tasks/config'    
+
+#-----------------------------------------------------------------------
+# Rubyforge additions to the task library
+#-----------------------------------------------------------------------
+if rf_conf = Configuration.for_if_exist?("rubyforge") then
+
+  abort("rubyforge gem not installed 'gem install rubyforge'") unless Utils.try_require('rubyforge')
+  
+  proj_conf = Configuration.for('project')
+
+  namespace :dist do
+    desc "Release files to rubyforge"
+    task :rubyforge => [:clean, :package] do
+
+      rubyforge = RubyForge.new
+
+      config = {}
+      config["release_notes"]     = proj_conf.description
+      config["release_changes"]   = Utils.release_notes_from(proj_conf.history)[TyrantManager::VERSION]
+      config["Prefomatted"]       = true
+
+      rubyforge.configure
+
+      # make sure this release doesn't already exist
+      releases = rubyforge.autoconfig['release_ids']
+      if releases.has_key?(TyrantManager::GEM_SPEC.name) and releases[TyrantManager::GEM_SPEC.name][TyrantManager::VERSION] then
+        abort("Release #{TyrantManager::VERSION} already exists! Unable to release.")
+      end
+
+      puts "Uploading to rubyforge..."
+      files = FileList[File.join("pkg","#{TyrantManager::GEM_SPEC.name}-#{TyrantManager::VERSION}*.*")].to_a
+      rubyforge.login
+      rubyforge.add_release(TyrantManager::GEM_SPEC.rubyforge_project, TyrantManager::GEM_SPEC.name, TyrantManager::VERSION, *files)
+      puts "done."
+    end
+  end
+
+  namespace :announce do
+    desc "Post news of #{proj_conf.name} to #{rf_conf.project} on rubyforge"
+    task :rubyforge do
+      info = Utils.announcement
+      rubyforge = RubyForge.new
+      rubyforge.configure
+      rubyforge.login
+      rubyforge.post_news(rf_conf.project, info[:subject], "#{info[:title]}\n\n#{info[:urls]}\n\n#{info[:release_notes]}")
+      puts "Posted to rubyforge"
+    end
+
+  end
+end

data/tasks/utils.rb

@@ -0,0 +1,80 @@
+require 'tyrant_manager/version'
+
+#-------------------------------------------------------------------------------
+# Additions to the Configuration class that are useful
+#-------------------------------------------------------------------------------
+class Configuration
+  class << self
+    def exist?( name )
+      Configuration::Table.has_key?( name )
+    end
+
+    def for_if_exist?( name )
+      if self.exist?( name ) then
+        self.for( name )
+      end
+    end
+  end
+end
+
+#-------------------------------------------------------------------------------
+# some useful utilitiy methods for the tasks
+#-------------------------------------------------------------------------------
+module Utils
+  class << self
+
+    # Try to load the given _library_ using the built-in require, but do not
+    # raise a LoadError if unsuccessful. Returns +true+ if the _library_ was
+    # successfully loaded; returns +false+ otherwise.
+    #
+    def try_require( lib ) 
+      require lib
+      true 
+    rescue LoadError 
+      false 
+    end 
+
+    # partition an rdoc file into sections, and return the text of the section
+    # given.  
+    def section_of(file, section_name) 
+      File.read(file).split(/^(?==)/).each do |section|
+        lines = section.split("\n")
+        return lines[1..-1].join("\n").strip if lines.first =~ /#{section_name}/i
+      end
+      nil
+    end
+
+    # Get an array of all the changes in the application for a particular
+    # release.  This is done by looking in the history file and grabbing the
+    # information for the most recent release.  The history file is assumed to
+    # be in RDoc format and version release are 2nd tier sections separated by
+    # '== Version X.Y.Z'
+    #
+    # returns:: A hash of notes keyed by version number
+    #
+    def release_notes_from(history_file)
+      releases = {}
+      File.read(history_file).split(/^(?==)/).each do |section|
+        lines = section.split("\n")
+        md = %r{Version ((\w+\.)+\w+)}.match(lines.first)
+        next unless md
+        releases[md[1]] = lines[1..-1].join("\n").strip
+      end
+      return releases
+    end
+
+    # return a hash of useful information for the latest release
+    # urls, subject, title, description and latest release notes
+    #
+    def announcement
+      cfg = Configuration.for("project") 
+      { 
+        :subject        => "#{cfg.name} #{TyrantManager::VERSION} Released",
+        :title          => "#{cfg.name} version #{TyrantManager::VERSION} has been released.",
+        :urls           => "#{cfg.homepage}",
+        :description    => "#{cfg.description.rstrip}",
+        :release_notes  => Utils.release_notes_from(cfg.history)[TyrantManager::VERSION].rstrip 
+      }
+    end
+  end
+end # << self