daemon-kit 0.1.7.12 → 0.1.8pre

data/lib/daemon_kit/vendor/thor-0.12.3/lib/thor/util.rb

@@ -0,0 +1,233 @@
+require 'rbconfig'
+
+class Thor
+  module Sandbox #:nodoc:
+  end
+
+  # This module holds several utilities:
+  #
+  # 1) Methods to convert thor namespaces to constants and vice-versa.
+  #
+  #   Thor::Utils.namespace_from_thor_class(Foo::Bar::Baz) #=> "foo:bar:baz"
+  #
+  # 2) Loading thor files and sandboxing:
+  #
+  #   Thor::Utils.load_thorfile("~/.thor/foo")
+  #
+  module Util
+
+    # Receives a namespace and search for it in the Thor::Base subclasses.
+    #
+    # ==== Parameters
+    # namespace<String>:: The namespace to search for.
+    #
+    def self.find_by_namespace(namespace)
+      namespace = "default#{namespace}" if namespace.empty? || namespace =~ /^:/
+
+      Thor::Base.subclasses.find do |klass|
+        klass.namespace == namespace
+      end
+    end
+
+    # Receives a constant and converts it to a Thor namespace. Since Thor tasks
+    # can be added to a sandbox, this method is also responsable for removing
+    # the sandbox namespace.
+    #
+    # This method should not be used in general because it's used to deal with
+    # older versions of Thor. On current versions, if you need to get the
+    # namespace from a class, just call namespace on it.
+    #
+    # ==== Parameters
+    # constant<Object>:: The constant to be converted to the thor path.
+    #
+    # ==== Returns
+    # String:: If we receive Foo::Bar::Baz it returns "foo:bar:baz"
+    #
+    def self.namespace_from_thor_class(constant, remove_default=true)
+      constant = constant.to_s.gsub(/^Thor::Sandbox::/, "")
+      constant = snake_case(constant).squeeze(":")
+      constant.gsub!(/^default/, '') if remove_default
+      constant
+    end
+
+    # Given the contents, evaluate it inside the sandbox and returns the
+    # namespaces defined in the sandbox.
+    #
+    # ==== Parameters
+    # contents<String>
+    #
+    # ==== Returns
+    # Array[Object]
+    #
+    def self.namespaces_in_content(contents, file=__FILE__)
+      old_constants = Thor::Base.subclasses.dup
+      Thor::Base.subclasses.clear
+
+      load_thorfile(file, contents)
+
+      new_constants = Thor::Base.subclasses.dup
+      Thor::Base.subclasses.replace(old_constants)
+
+      new_constants.map!{ |c| c.namespace }
+      new_constants.compact!
+      new_constants
+    end
+
+    # Returns the thor classes declared inside the given class.
+    #
+    def self.thor_classes_in(klass)
+      stringfied_constants = klass.constants.map { |c| c.to_s }
+      Thor::Base.subclasses.select do |subclass|
+        next unless subclass.name
+        stringfied_constants.include?(subclass.name.gsub("#{klass.name}::", ''))
+      end
+    end
+
+    # Receives a string and convert it to snake case. SnakeCase returns snake_case.
+    #
+    # ==== Parameters
+    # String
+    #
+    # ==== Returns
+    # String
+    #
+    def self.snake_case(str)
+      return str.downcase if str =~ /^[A-Z_]+$/
+      str.gsub(/\B[A-Z]/, '_\&').squeeze('_') =~ /_*(.*)/
+      return $+.downcase
+    end
+
+    # Receives a string and convert it to camel case. camel_case returns CamelCase.
+    #
+    # ==== Parameters
+    # String
+    #
+    # ==== Returns
+    # String
+    #
+    def self.camel_case(str)
+      return str if str !~ /_/ && str =~ /[A-Z]+.*/
+      str.split('_').map { |i| i.capitalize }.join
+    end
+
+    # Receives a namespace and tries to retrieve a Thor or Thor::Group class
+    # from it. It first searches for a class using the all the given namespace,
+    # if it's not found, removes the highest entry and searches for the class
+    # again. If found, returns the highest entry as the class name.
+    #
+    # ==== Examples
+    #
+    #   class Foo::Bar < Thor
+    #     def baz
+    #     end
+    #   end
+    #
+    #   class Baz::Foo < Thor::Group
+    #   end
+    #
+    #   Thor::Util.namespace_to_thor_class("foo:bar")     #=> Foo::Bar, nil # will invoke default task
+    #   Thor::Util.namespace_to_thor_class("baz:foo")     #=> Baz::Foo, nil
+    #   Thor::Util.namespace_to_thor_class("foo:bar:baz") #=> Foo::Bar, "baz"
+    #
+    # ==== Parameters
+    # namespace<String>
+    #
+    # ==== Errors
+    # Thor::Error:: raised if the namespace cannot be found.
+    #
+    # Thor::Error:: raised if the namespace evals to a class which does not
+    #               inherit from Thor or Thor::Group.
+    #
+    def self.namespace_to_thor_class_and_task(namespace, raise_if_nil=true)
+      if namespace.include?(?:)
+        pieces = namespace.split(":")
+        task   = pieces.pop
+        klass  = Thor::Util.find_by_namespace(pieces.join(":"))
+      end
+
+      unless klass
+        klass, task = Thor::Util.find_by_namespace(namespace), nil
+      end
+
+      raise Error, "could not find Thor class or task '#{namespace}'" if raise_if_nil && klass.nil?
+      return klass, task
+    end
+
+    # Receives a path and load the thor file in the path. The file is evaluated
+    # inside the sandbox to avoid namespacing conflicts.
+    #
+    def self.load_thorfile(path, content=nil)
+      content ||= File.binread(path)
+
+      begin
+        Thor::Sandbox.class_eval(content, path)
+      rescue Exception => e
+        $stderr.puts "WARNING: unable to load thorfile #{path.inspect}: #{e.message}"
+      end
+    end
+
+    def self.user_home
+      @@user_home ||= if ENV["HOME"]
+        ENV["HOME"]
+      elsif ENV["USERPROFILE"]
+        ENV["USERPROFILE"]
+      elsif ENV["HOMEDRIVE"] && ENV["HOMEPATH"]
+        File.join(ENV["HOMEDRIVE"], ENV["HOMEPATH"])
+      elsif ENV["APPDATA"]
+        ENV["APPDATA"]
+      else
+        begin
+          File.expand_path("~")
+        rescue
+          if File::ALT_SEPARATOR
+            "C:/"
+          else
+            "/"
+          end
+        end
+      end
+    end
+
+    # Returns the root where thor files are located, dependending on the OS.
+    #
+    def self.thor_root
+      File.join(user_home, ".thor").gsub(/\\/, '/')
+    end
+
+    # Returns the files in the thor root. On Windows thor_root will be something
+    # like this:
+    #
+    #   C:\Documents and Settings\james\.thor
+    #
+    # If we don't #gsub the \ character, Dir.glob will fail.
+    #
+    def self.thor_root_glob
+      files = Dir["#{thor_root}/*"]
+
+      files.map! do |file|
+        File.directory?(file) ? File.join(file, "main.thor") : file
+      end
+    end
+
+    # Where to look for Thor files.
+    #
+    def self.globs_for(path)
+      ["#{path}/Thorfile", "#{path}/*.thor", "#{path}/tasks/*.thor", "#{path}/lib/tasks/*.thor"]
+    end
+
+    # Return the path to the ruby interpreter taking into account multiple
+    # installations and windows extensions.
+    #
+    def self.ruby_command
+      @ruby_command ||= begin
+        ruby = File.join(Config::CONFIG['bindir'], Config::CONFIG['ruby_install_name'])
+        ruby << Config::CONFIG['EXEEXT']
+
+        # escape string in case path to ruby executable contain spaces.
+        ruby.sub!(/.*\s.*/m, '"\&"')
+        ruby
+      end
+    end
+
+  end
+end

data/lib/daemon_kit/vendor/thor-0.12.3/lib/thor/version.rb

@@ -0,0 +1,3 @@
+class Thor
+  VERSION = "0.12.3".freeze
+end

data/lib/daemon_kit/xmpp.rb

@@ -1,3 +1,6 @@
+require 'blather/client/client'
+require 'blather/client/dsl'
+
 module DaemonKit
   # Thin wrapper around the blather DSL
   class XMPP
@@ -6,18 +9,24 @@ module DaemonKit
     class << self
 
       def run( &block )
-        DaemonKit::EM.run
-
-        xmpp = new
+        DaemonKit.trap('INT') { ::EM.stop }
+        DaemonKit.trap('TERM') { ::EM.stop }
 
-        xmpp.instance_eval( &block )
+        DaemonKit::EM.run {
 
-        xmpp.run
+          xmpp = new
+          xmpp.instance_eval( &block )
+          xmpp.run
+        }
       end
     end
 
     def initialize
-      @config = DaemonKit::Config.load('jabber')
+      @config = DaemonKit::Config.load('xmpp')
+
+      if @config.enable_logging
+        Blather.logger = DaemonKit.logger
+      end
 
       jid = if @config.resource
         "#{@config.jabber_id}/#{@config.resource}"
@@ -26,6 +35,66 @@ module DaemonKit
       end
 
       setup jid, @config.password
+
+      when_ready do
+        configure_roster!
+        become_available
+      end
+
+      return if @config['require_master'] == false
+
+      message do |m|
+        trusted?( m ) ? pass : halt
+      end
+    end
+
+    def configure_roster!
+      DaemonKit.logger.debug 'Configuring roster'
+
+      my_roster.each do |(jid, item)|
+        unless contacts.include?( jid )
+          DaemonKit.logger.debug "Removing #{jid} from roster"
+
+          my_roster.delete( item.jid )
+          next
+        end
+      end
+
+      contacts.each do |jid|
+        DaemonKit.logger.debug "Adding #{jid} to roster"
+
+        my_roster.add( Blather::JID.new( jid ) )
+      end
+
+      my_roster.each do |(jid,item)|
+        item.subscription = :both
+        item.ask = :subscribe
+      end
+    end
+
+    def become_available
+      set_status( :chat, "#{DaemonKit.configuration.daemon_name} is available" )
+    end
+
+    def trusted?( message )
+      @config.masters.include?( message.from.stripped.to_s )
+    end
+
+    def contacts
+      @config.masters + @config.supporters
+    end
+
+    def run
+      client.run
+    end
+
+    def busy( message = nil, &block )
+      set_status( :dnd, message )
+
+      block.call
+
+      become_available
     end
+
   end
 end

data/lib/generators/daemon_kit/amqp/amqp_generator.rb

@@ -0,0 +1,24 @@
+module DaemonKit
+  module Generators
+    class AmqpGenerator < Base
+
+      def update_gemfile
+        append_file 'Gemfile', %q(gem 'amqp')
+      end
+
+      def create_config_files
+        directory 'config'
+      end
+
+      def create_daemon
+        directory 'libexec'
+      end
+
+      protected
+
+      def self.source_root
+        File.expand_path( File.join( File.dirname(__FILE__), 'templates') )
+      end
+    end
+  end
+end

data/lib/generators/daemon_kit/app/app_generator.rb

@@ -0,0 +1,140 @@
+module DaemonKit
+  module Generators
+    class AppGenerator < Base
+      INSTALLERS = %w( default amqp cron nanite_agent ruote xmpp )
+      DEPLOYERS  = %w( capistrano )
+      TEST_FRAMEWORKS = %w( none rspec test_unit )
+      add_shebang_option!
+
+      argument :app_path, :type => :string
+
+      class_option :installer, :type => :string, :aliases => '-i', :default => 'default',
+                   :desc => "Pre-configured daemon to generate (options: #{INSTALLERS.join(', ')})"
+
+      class_option :deployer, :type => :string, :aliases => '-d',
+                   :desc => "Select an optional deployment mechanism (options: #{DEPLOYERS.join(', ')})"
+
+      class_option :test_framework, :type => :string, :aliases => '-t', :default => 'rspec',
+                   :desc => "Select your prefered test framework (options: #{TEST_FRAMEWORKS.join(', ')})"
+
+      class_option :cucumber, :type => :boolean, :aliases => '-c', :default => false,
+                   :desc => "Install cucumber support"
+
+      def initialize( *args )
+        super
+
+        unless INSTALLERS.include?( options[:installer] )
+          raise Error, "Invalid value for --installer option. Supported installers are: #{INSTALLERS.join(', ')}"
+        end
+
+        if options[:deployer] && !DEPLOYERS.include?( options[:deployer] )
+          raise Error, "Invalid value for --deployer option. Supported deployers are: #{DEPLOYERS.join(', ')}"
+        end
+
+        unless TEST_FRAMEWORKS.include?( options[:test_framework] )
+          raise Error, "Invalid value for --test_framework option. Supported frameworks are: #{TEST_FRAMEWORKS.join(', ')}"
+        end
+      end
+
+      def create_root
+        self.destination_root = File.expand_path( app_path, destination_root )
+        empty_directory('.')
+        FileUtils.cd( destination_root )
+      end
+
+      def create_root_files
+        copy_file 'README'
+        copy_file 'Rakefile'
+        copy_file 'Gemfile'
+      end
+
+      def create_bin_files
+        empty_directory 'bin'
+        template 'bin/daemon.tt', "bin/#{app_name}" do |content|
+          "#{shebang}\n" + content
+        end
+        chmod "bin", 0755, :verbose => false
+      end
+
+      def create_config_files
+        directory 'config'
+      end
+
+      def create_script_files
+        directory 'script' do |content|
+          "#{shebang}\n" + content
+        end
+        chmod 'script', 0755, :verbose => false
+      end
+
+      def create_task_directory
+        empty_directory 'tasks'
+      end
+
+      def create_log_directory
+        empty_directory 'log'
+      end
+
+      def create_tmp_directory
+        empty_directory 'tmp'
+      end
+
+      def create_vendor_directory
+        empty_directory 'vendor'
+      end
+
+      def create_lib_files
+        directory 'lib'
+      end
+
+      def create_lib_exec
+        case options[:installer]
+        when 'default'
+          directory 'libexec'
+        when 'amqp'
+          invoke DaemonKit::Generators::AmqpGenerator
+        when 'cron'
+          invoke DaemonKit::Generators::CronGenerator
+        when 'nanite_agent'
+          invoke DaemonKit::Generators::NaniteAgentGenerator
+        when 'ruote'
+          invoke DaemonKit::Generators::RuoteGenerator
+        when 'xmpp'
+          invoke DaemonKit::Generators::XmppGenerator
+        end
+      end
+
+      def create_deployment_config
+        return unless options[:deployer]
+
+        case options[:deployer]
+        when 'capistrano'
+          invoke DaemonKit::Generators::CapistranoGenerator
+        end
+      end
+
+      def create_test_environment
+        return if options[:test_framework] == 'none'
+
+        case options[:test_framework]
+        when 'rspec'
+          invoke DaemonKit::Generators::SpecGenerator
+        when 'test_unit'
+          invoke DaemonKit::Generators::TestUnitGenerator
+        end
+      end
+
+      def create_cucumber
+        return unless options.cucumber?
+        invoke DaemonKit::Generators::CucumberGenerator
+      end
+
+      protected
+
+      def self.source_root
+        File.expand_path( File.join( File.dirname(__FILE__), 'templates') )
+      end
+
+    end
+  end
+end