dctl 1.0.0

data/CHANGELOG

@@ -0,0 +1,14 @@
+*1.0.0* (07th April, 2005)		Bruno Carnazzi		<mailto:bcarnazzi@gmail.com>
+	* Full rewrite from scratch
+	* Multiple daemon instances does not exists anymore
+	* Load option does not exists anymore
+	* Strongly unit-tested (I hope so)
+	* Smaller, better, stronger :)
+	* Added a 'setup.rb' script
+	* Added a 'rakefile'
+	* Added a bit of docs
+	* ...
+
+*0.0.8* (14th March, 2005)		Bruno Carnazzi		<mailto:bcarnazzi@gmail.com>
+	* initial release
+	* so ugly...

data/README

@@ -0,0 +1,63 @@
+= dctl - a daemon controller written in Ruby
+
+dctl is a small script for providing daemon functionnalty (start, stop, ...)
+to non-daemon process or script, with automatic handling of pidfiles.
+dctl is mainly an extended rewrite of the daemons[http://rubyforge.org/projects/daemons/]
+project for learning purpose.
+It is designed to be small and smart and I try to apply XP's good practice (unit test)
+
+Major features:
+* Convert any executable file with endless lifecycle into a controllable daemon
+* Automatic handling of pidfiles
+* Command-oriented style (dctl requires cmdparser)
+
+
+== Examples
+
+=== Start a daemon with redirection of stdout
+  % dctl start -oout test/infinite.sh
+
+=== Get the status of a daemon
+  % dctl status test/infinite.sh
+
+=== Stop a daemon
+  % dctl stop test/infinite.sh
+
+
+== Download
+
+The latest version of dctl can be found at :
+* http://rubyforge.org/projects/dctl/
+
+
+== Installation
+
+The prefered method of installing dctl is currently through its setup.rb file.
+As dctl stands on cmdparser, you need to have cmdparser installed before.
+I plan to make a GEM for dctl soon.
+
+from dctl distribution directory:
+  % [sudo] ruby setup.rb
+
+=== Notes
+If you installed cmdparser as a gem, please check your RUBYOPTS which should looks like:
+  % echo $RUBYOPTS
+ -rubygems
+
+If not, do the following :
+  % export RUBYOPTS="-rubygems"
+
+
+== Author
+
+Written in 2005 by Bruno Carnazzi <mailto:bcarnazzi@gmail.com>
+
+== License
+
+dctl is free software. You can redistribute it under the terms specified in
+the COPYING file of the Ruby distribution.
+
+
+== Feedback and other resources
+
+At http://rubyforge.org/projects/dctl/

data/Rakefile

@@ -0,0 +1,211 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rake/rdoctask'
+require 'rake/packagetask'
+require 'rake/gempackagetask'
+require 'rake/contrib/rubyforgepublisher'
+require 'lib/dctl/metainf'
+
+
+PKG_BUILD     = ENV['PKG_BUILD'] ? '.' + ENV['PKG_BUILD'] : ''
+PKG_NAME      = 'dctl'
+PKG_VERSION   = Dctl::VERSION.join('.') + PKG_BUILD
+PKG_FILE_NAME = "#{PKG_NAME}-#{PKG_VERSION}"
+
+RELEASE_NAME  = "REL #{PKG_VERSION}"
+
+RUBY_FORGE_PROJECT = "dctl"
+RUBY_FORGE_USER    = "bcarnazzi"
+
+PKG_FILES = FileList[
+    "lib/**/*", "test/*", "bin/*", "CHANGELOG", "README", "setup.rb", "Rakefile", "TODO"
+].exclude(/\bCVS\b|~$/)
+
+
+desc "Default Task"
+task :default => [ :test ]
+
+# Run the unit tests
+
+Rake::TestTask.new("test") do |t|
+  t.libs << "test"
+  t.test_files = FileList['test/dctl_test.rb']
+  t.verbose = true
+end
+
+# Generate the RDoc documentation
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.rdoc_dir = 'html'
+  rdoc.title    = "dctl - a daemon controller written in Ruby"
+  rdoc.options << '--line-numbers --inline-source --accessor cattr_accessor=object'
+  rdoc.template = "#{ENV['template']}.rb" if ENV['template']
+  rdoc.rdoc_files.include('README', 'TODO', 'CHANGELOG')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+# Create compressed packages
+
+dist_dirs = [ "lib", "bin", "test" ]
+
+spec = Gem::Specification.new do |s|
+  s.name = PKG_NAME
+  s.version = PKG_VERSION
+  s.platform = Gem::Platform::RUBY
+  s.summary = "dctl - a daemon controller written in Ruby"
+  s.description = %q{dctl is a small script for providing daemon functionnalty (start, stop, ...) to non-daemon process or script, with automatic handling of pidfiles.}
+
+  s.files = [ "Rakefile", "setup.rb", "README", "TODO", "CHANGELOG" ]
+  dist_dirs.each do |dir|
+    s.files = s.files + Dir.glob( "#{dir}/**/*" ).delete_if { |item| item.include?( "\.svn" ) }
+  end
+  s.executables = ['dctl']
+  s.bindir = 'bin'
+  
+  # s.test_suite_file = 'test/dctl_test.rb'
+  
+  s.add_dependency('cmdparse', '= 1.0.0')
+
+  s.require_path = 'lib'
+  s.autorequire = 'dctl'
+
+  s.has_rdoc = true
+  s.extra_rdoc_files = %w( README TODO CHANGELOG )
+  s.rdoc_options.concat ['--main',  'README']
+
+  s.author = "Bruno Carnazzi"
+  s.email = "bcarnazzi@gmail.com"
+  s.homepage = "http://rubyforge.org/project/dctl/"
+  s.rubyforge_project = "dctl"
+end
+  
+Rake::GemPackageTask.new(spec) do |p|
+  p.gem_spec = spec
+  p.need_tar = true
+  p.need_zip = true
+end
+
+
+# Publishing ------------------------------------------------------
+
+desc "Publish the API documentation"
+task :pdoc => [:rdoc] do 
+  Rake::RubyForgePublisher.new(RUBY_FORGE_PROJECT, RUBY_FORGE_USER).upload
+end
+
+desc "Publish the release files to RubyForge."
+task :release => [:package] do
+  files = ["gem", "tgz", "zip"].map { |ext| "pkg/#{PKG_FILE_NAME}.#{ext}" }
+
+  if RUBY_FORGE_PROJECT then
+    require 'net/http'
+    require 'open-uri'
+
+    project_uri = "http://rubyforge.org/projects/#{RUBY_FORGE_PROJECT}/"
+    project_data = open(project_uri) { |data| data.read }
+    group_id = project_data[/[?&]group_id=(\d+)/, 1]
+    raise "Couldn't get group id" unless group_id
+
+    # This echos password to shell which is a bit sucky
+    if ENV["RUBY_FORGE_PASSWORD"]
+      password = ENV["RUBY_FORGE_PASSWORD"]
+    else
+      print "#{RUBY_FORGE_USER}@rubyforge.org's password: "
+      password = STDIN.gets.chomp
+    end
+
+    login_response = Net::HTTP.start("rubyforge.org", 80) do |http|
+      data = [
+        "login=1",
+        "form_loginname=#{RUBY_FORGE_USER}",
+        "form_pw=#{password}"
+      ].join("&")
+      http.post("/account/login.php", data)
+    end
+
+    cookie = login_response["set-cookie"]
+    raise "Login failed" unless cookie
+    headers = { "Cookie" => cookie }
+
+    release_uri = "http://rubyforge.org/frs/admin/?group_id=#{group_id}"
+    release_data = open(release_uri, headers) { |data| data.read }
+    package_id = release_data[/[?&]package_id=(\d+)/, 1]
+    raise "Couldn't get package id" unless package_id
+
+    first_file = true
+    release_id = ""
+
+    files.each do |filename|
+      basename  = File.basename(filename)
+      file_ext  = File.extname(filename)
+      file_data = File.open(filename, "rb") { |file| file.read }
+
+      puts "Releasing #{basename}..."
+
+      release_response = Net::HTTP.start("rubyforge.org", 80) do |http|
+        release_date = Time.now.strftime("%Y-%m-%d %H:%M")
+        type_map = {
+          ".zip"    => "3000",
+          ".tgz"    => "3110",
+          ".gz"     => "3110",
+          ".gem"    => "1400"
+        }; type_map.default = "9999"
+        type = type_map[file_ext]
+        boundary = "rubyqMY6QN9bp6e4kS21H4y0zxcvoor"
+
+        query_hash = if first_file then
+          {
+            "group_id" => group_id,
+            "package_id" => package_id,
+            "release_name" => RELEASE_NAME,
+            "release_date" => release_date,
+            "type_id" => type,
+            "processor_id" => "8000", # Any
+            "release_notes" => "",
+            "release_changes" => "",
+            "preformatted" => "1",
+            "submit" => "1"
+          }
+        else
+          {
+            "group_id" => group_id,
+            "release_id" => release_id,
+            "package_id" => package_id,
+            "step2" => "1",
+            "type_id" => type,
+            "processor_id" => "8000", # Any
+            "submit" => "Add This File"
+          }
+        end
+
+        query = "?" + query_hash.map do |(name, value)|
+          [name, URI.encode(value)].join("=")
+        end.join("&")
+
+        data = [
+          "--" + boundary,
+          "Content-Disposition: form-data; name=\"userfile\"; filename=\"#{basename}\"",
+          "Content-Type: application/octet-stream",
+          "Content-Transfer-Encoding: binary",
+          "", file_data, ""
+          ].join("\x0D\x0A")
+
+        release_headers = headers.merge(
+          "Content-Type" => "multipart/form-data; boundary=#{boundary}"
+        )
+
+        target = first_file ? "/frs/admin/qrs.php" : "/frs/admin/editrelease.php"
+        http.post(target + query, data, release_headers)
+      end
+
+      if first_file then
+        release_id = release_response.body[/release_id=(\d+)/, 1]
+        raise("Couldn't get release id") unless release_id
+      end
+
+      first_file = false
+    end
+  end
+end

data/TODO

@@ -0,0 +1,5 @@
+- write a *real* todo file -> DONE (05/04/05)
+- write a bit of rdoc -> DONE (05/04/05)
+- write a 'status' command -> DONE (05/04/05)
+- write a 'rakefile'
+- package as a gem

data/bin/dctl

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+begin
+  require 'dctl'
+rescue LoadError
+  require 'rubygems'
+  require_gem 'dctl'
+end
+DctlApp.new.run

data/lib/dctl.rb

@@ -0,0 +1,19 @@
+#!/usr/bin/env ruby
+
+require 'dctl/cmdparser'
+
+class DctlApp
+  def run
+    begin
+      Dctl::CommandLineParser.parse!(File.basename($0, '.*'), ARGV)
+    rescue
+      puts $!
+      puts 'Use -h or --help for usage.'
+      exit 1
+    end
+  end
+end
+
+if __FILE__ == $0 then
+  DctlApp.new.run
+end

data/lib/dctl/cmdparser.rb

@@ -0,0 +1,42 @@
+begin
+  require 'rubygems'
+  require 'cmdparse' # require_gem fails !
+rescue LoadError
+  require 'cmdparse'
+end
+  
+require 'dctl/metainf'
+require 'dctl/defaults'
+require 'dctl/command'
+
+module Dctl
+
+  # This class is used to parse user command line.
+  class CommandLineParser
+    def self.parse!(program_name, argv)
+      cmd_parser = CommandParser.new
+
+      cmd_parser.options { |opt|
+        opt.program_name = program_name
+        opt.version = Dctl::VERSION
+        opt.release = Dctl::RELEASE
+        opt.separator 'args contains target program to daemonize and its arguments.'
+        opt.separator ''
+        opt.separator 'Global options:'
+        opt.on('-d', '--dir DIR', "Path where to store pidfiles (default is '#{$DIR}')") { |$DIR| }
+      }
+      
+      cmd_parser.add_command Dctl::Command::StartCommand.new
+      cmd_parser.add_command Dctl::Command::StopCommand.new
+      cmd_parser.add_command Dctl::Command::RunCommand.new
+      cmd_parser.add_command Dctl::Command::RestartCommand.new
+      cmd_parser.add_command Dctl::Command::ZapCommand.new
+      cmd_parser.add_command Dctl::Command::StatusCommand.new
+      cmd_parser.add_command CommandParser::HelpCommand.new
+      cmd_parser.add_command CommandParser::VersionCommand.new
+      
+      cmd_parser.parse! argv
+    end
+  end
+
+end

data/lib/dctl/command.rb

@@ -0,0 +1,135 @@
+begin
+  require 'rubygems'
+  require 'cmdparse' # require_gem fails !
+rescue LoadError
+  require 'cmdparse'
+end
+
+require 'dctl/defaults'
+require 'dctl/daemon'
+
+module Dctl
+
+  # This module contains all possible commands allowed by Dctl
+  module Command
+  
+    # This module is used by command that redirect their standard io streams.
+    module Redirectible
+      def std_init
+        @stdin = $IN
+        @stdout = $OUT
+        @stderr = $ERR
+        options.separator "Options:"
+        options.on('-i', '--stdin FILE', "Use FILE as stdin when daemonized (default is '#{@stdin}').") { |@stdin| }
+        options.on('-o', '--stdout FILE', "Use FILE as stdout when daemonized (default is '#{@stdout}').") { |@stdout| }
+        options.on('-e', '--stderr FILE', "Use FILE as stderr when daemonized (default is '#{@stderr}').") { |@stderr| }
+      end
+    end
+        
+    class StartCommand < CommandParser::Command
+      include Redirectible
+    
+      def initialize
+        super 'start'
+        std_init
+      end
+      
+      def description
+        'Start a new daemonized instance of a specified application.'
+      end
+      
+      def execute(cmd_parser, args)
+        cmd_args = args.slice! 1, args.length
+        cmd = args[0]
+        Dctl::Daemon.new(cmd, $DIR).start(cmd_args, @stdin, @stdout, @stderr)
+      end
+    end
+
+    class RestartCommand < CommandParser::Command
+      include Redirectible
+    
+      def initialize
+        super 'restart'
+        std_init
+      end
+      
+      def description
+        'Restart a daemonized instance of a specified application with new arguments.'
+      end
+      
+      def execute(cmd_parser, args)
+        cmd_args = args.slice! 1, args.length
+        cmd = args[0]
+        Dctl::Daemon.new(cmd, $DIR).restart(cmd_args, @stdin, @stdout, @stderr)
+      end
+    end
+    
+    class StopCommand < CommandParser::Command
+      def initialize
+        super 'stop'
+        options.separator "Options:"
+      end
+      
+      def description
+        'Stop a daemonized instance of a specified application.'
+      end
+      
+      def execute(cmd_parser, args)
+        cmd = args[0]
+        Dctl::Daemon.new(cmd, $DIR).stop
+      end
+    end
+
+    class ZapCommand < CommandParser::Command
+      def initialize
+        super 'zap'
+        options.separator "Options:"
+      end
+      
+      def description
+        "Manually set a daemonized instance of a specified application to 'stopped' state."
+      end
+      
+      def execute(cmd_parser, args)
+        cmd = args[0]
+        Dctl::Daemon.new(cmd, $DIR).zap
+      end
+    end
+
+    class RunCommand < CommandParser::Command
+      def initialize
+        super 'run'
+        options.separator "Options:"
+      end
+      
+      def description
+        'Run a new un-daemonized instance of a specified application.'
+      end
+      
+      def execute(cmd_parser, args)
+        cmd_args = args.slice! 1, args.length
+        cmd = args[0]
+        Dctl::Daemon.new(cmd, $DIR).run(cmd_args)
+      end
+    end
+    
+    class StatusCommand < CommandParser::Command
+      def initialize
+        super 'status'
+        options.separator "Options:"
+      end
+      
+      def description
+        "Get the state of a specified application."
+      end
+      
+      def execute(cmd_parser, args)
+        cmd = args[0]
+        puts "#{File.basename cmd}: #{Dctl::Daemon.new(cmd, $DIR).status}"
+      end
+    end
+
+    
+  end
+
+end