silver_spurs 0.0.8 → 1.0.0

data/lib/silver_spurs.rb

@@ -1,5 +1,6 @@
 require 'silver_spurs/version'
 require 'silver_spurs/app'
+require 'silver_spurs/asyncifier'
 
 module SilverSpurs
   # I'm a module! Everything important is elsewhere

data/lib/silver_spurs/app.rb

@@ -1,7 +1,7 @@
 require 'sinatra/base'
 require 'silver_spurs/knife_interface'
 require 'json'
-
+require 'silver_spurs/asyncifier'
 
 module SilverSpurs
   class App < Sinatra::Base
@@ -9,8 +9,8 @@ module SilverSpurs
     set :deployment_key, "/etc/chef/deployment_key.pem"
     set :deployment_user, "silverspurs"
     # sane setting for AD subdomain
-    set :node_name_filter, /^[-A-Za-z0-9]{3,15}$/ 
-        
+    set :node_name_filter, /^[-A-Za-z0-9]{3,15}$/
+    
     get '/' do
       %q| Ride 'em, cowboy |
     end
@@ -35,18 +35,56 @@ module SilverSpurs
       node_name = params[:node_name].strip
       return 406, {:bad_params => :node_name}.to_json unless node_name =~ settings.node_name_filter
 
-      bootstrap_options = Hash[KnifeInterface.supported_arguments.map do |arg|
-                                 value = params[arg]
-                                 next if value.nil?
-                                 [arg, params[arg]]
-                               end]
+      process_name = "knife_bootstrap_#{params[:ip].strip.gsub '.', '_'}"
+
+      unless Asyncifier.has_lock? process_name
+        logger.info "Asynchronously spawning knife command. process_name = [#{process_name}]"
+        bootstrap_options = Hash[KnifeInterface.supported_arguments.map do |arg|
+                                   value = params[arg]
+                                   next if value.nil?
+                                   [arg, params[arg]]
+                                 end]
       
-      result = KnifeInterface.bootstrap(params[:ip], node_name, settings.deployment_user, settings.deployment_key, bootstrap_options)
-      status_code = result[:exit_code] == 0 ? 201 : 500
+        command = KnifeInterface.bootstrap_command(
+                                                   params[:ip],
+                                                   node_name,
+                                                   settings.deployment_user,
+                                                   settings.deployment_key,
+                                                   bootstrap_options)
+        logger.debug "knife command: #{command}"
+        Asyncifier.spawn_process process_name, command
+      end
       
-      return status_code, result.to_json
+      redirect to("/bootstrap/query/#{process_name}"), 303
     end
 
+    head '/bootstrap/query/:process_id' do
+      return 404 unless Asyncifier.exists? params[:process_id]
+      Asyncifier.reap_old_process params[:process_id]
+      return 202 if Asyncifier.has_lock? params[:process_id]
+      if Asyncifier.success? params[:process_id]
+        return 201
+      else
+        return 550
+      end
+    end
+
+    get '/bootstrap/query/:process_id' do
+      return 404 unless Asyncifier.exists? params[:process_id]
+      Asyncifier.reap_old_process params[:process_id]
+
+      headers 'Content-Type' => 'text/plain'
+      body Asyncifier.get_log params[:process_id]
+      if Asyncifier.success? params[:process_id]
+        status 201
+      elsif Asyncifier.has_lock? params[:process_id]
+        status 202
+      else
+        status 550
+      end
+    end
+    
+
     def required_vars?(params, requirement_list)
       requirement_list.none? { |required_param| params[required_param].nil? }
     end

data/lib/silver_spurs/asyncifier.rb

@@ -0,0 +1,100 @@
+require 'singleton'
+require 'forwardable'
+
+module SilverSpurs
+  class Asyncifier
+    include Singleton
+    extend SingleForwardable
+
+    attr_writer :base_path, :timeout
+    def_delegators :instance, :has_lock?, :base_path, :base_path=, :timeout=, :timeout, :spawn_process, :has_lock?, :success?, :get_log, :reap_orphaned_lock, :reap_process, :reap_old_process, :exists?
+    
+    def timeout
+      @timeout ||= 60 * 60
+    end
+          
+    def base_path
+      @base_path ||= './silver_spurs_async'
+    end
+
+    def spawn_process(process_name, command)
+      create_directory_tree
+      logged_command = "#{command} &> #{log_file_path process_name} && touch #{success_file_path process_name}"
+      pid = Process.spawn logged_command
+      File.open(pid_file_path(process_name), 'wb') { |f| f.write pid }
+      Process.detach pid
+    end
+        
+    def has_lock?(process_name)
+      return false unless File.exists? pid_file_path(process_name)
+      
+      pid = File.read(pid_file_path(process_name)).to_i
+      `ps -o command -p #{pid}`.split("\n").count == 2
+    end
+
+    def success?(process_name)
+      return false unless File.exists? success_file_path(process_name)
+      return true unless File.exists? pid_file_path(process_name)
+      File.mtime(success_file_path(process_name)) >= File.mtime(pid_file_path(process_name))
+    end
+    
+    def get_log(process_name)
+      return nil unless File.exists? log_file_path(process_name)
+      File.read log_file_path(process_name)
+    end
+
+    def reap_orphaned_lock(process_name)
+      File.delete pid_file_path(process_name) unless has_lock? process_name
+    end
+
+    def reap_process(process_name)
+      if has_lock? process_name
+        pid = File.read(pid_file_path(process_name)).to_i
+        Process.kill 'KILL', pid
+        sleep 1
+        Process.kill('TERM', pid) if has_lock? process_name
+      end
+      reap_lock_if_done process_name
+    end
+
+    def reap_old_process(process_name)
+      if has_lock? process_name
+        launch_time = File.mtime pid_file_path(process_name)
+        reap_process process_name if Time.now - launch_time > timeout
+      end
+    end
+
+    def exists?(process_name)
+      return true if has_lock? process_name
+      File.exists? log_file_path(process_name)
+    end
+    
+    private
+
+    def log_file_path(process_name)
+      filename = "#{process_name}.log"
+      File.join base_path, 'logs', filename
+    end
+        
+    def success_file_path(process_name)
+      filename = "#{process_name}.success"
+      File.join base_path, 'status', filename
+    end
+          
+    def pid_file_path(process_name)
+      filename = "#{process_name}.pid"
+      File.join base_path, 'lockfiles', filename
+    end
+    
+    def create_directory_tree
+      Dir.mkdir base_path unless Dir.exists? base_path
+      
+      ['logs', 'lockfiles', 'status'].each do |directory|
+        path = File.join(base_path, directory)
+        Dir.mkdir path unless Dir.exists? path
+      end
+    end
+    
+  end
+end
+

data/lib/silver_spurs/client.rb

@@ -3,23 +3,31 @@ require 'addressable/uri'
 require 'json'
 require 'silver_spurs/knife_interface'
 require 'silver_spurs/client/exceptions'
+require 'silver_spurs/client/bootstrap_run'
 
 module SilverSpurs
   class Client
     def initialize(host_url, options={})
       @host_url = host_url
-      @timeout = options[:timeout] || 60 * 60
+      @timeout = options[:timeout] || 2 * 60
     end
 
-    def bootstrap(ip, node_name, options = {})
+    def start_bootstrap(ip, node_name, options = {})
       params = extract_extra_params(options).merge({:node_name => node_name})
       payload = parameterize_hash params
       headers = {:accept => :json, :content_type=> 'application/x-www-form-urlencoded'}
 
-      response = spur_host["bootstrap/#{ip}"].put(payload, headers)
-      throw ClientException("unexpected response", response) unless response.code == 201
+      response = spur_host["bootstrap/#{ip}"].put(payload, headers) do |response, &block|
+        if response.code == 303
+          response
+        else
+          response.return! &block
+        end
+      end
+      
+      throw ClientException.new("unexpected response", response) unless response.code == 303
 
-      JSON.parse response.body
+      BootstrapRun.new(response.headers[:location], :timeout => @timeout)
     end
 
     private

data/lib/silver_spurs/client/bootstrap_run.rb

@@ -0,0 +1,55 @@
+require 'rest-client'
+require 'silver_spurs/client/exceptions'
+
+module SilverSpurs
+  class BootstrapRun
+    def initialize(async_url, options={})
+      @async_url = async_url
+      @timeout = options[:timeout] || 2 * 60
+    end
+
+    def status
+      response = RestClient.head @async_url, &method(:no_exception_for_550)
+      
+      case response.code
+      when 201
+        :success
+      when 202
+        :processing
+      when 550
+        :failed
+      when 404
+        throw ClientException.new("the server doesn't know anything about this knife run", response)
+      else
+        throw ClientException.new("unexpected response", response)
+      end
+    end
+
+    def log
+      response = RestClient.get @async_url, &method(:no_exception_for_550)
+      
+      case response.code
+      when 201, 202, 550
+        response.body
+      when 404
+        throw ClientException.new("the server doesn't know anything about this knife run", response)
+      else
+        throw ClientException.new("unexpected response", response)
+      end
+    end
+
+    private
+    def no_exception_for_550(response, origin, orig_result, &block)
+      if response.code == 550
+        response
+      else
+        response.return! &block
+      end
+    end
+        
+  end
+end
+
+
+    
+    

data/lib/silver_spurs/knife_interface.rb

@@ -28,7 +28,7 @@ module SilverSpurs
       end.reject {|arg| arg.nil?}              
     end
         
-    def self.bootstrap(ip, node_name, deployment_user, deployment_key, options = {})      
+    def self.bootstrap_command(ip, node_name, deployment_user, deployment_key, options = {})      
       bootstrap_options = {
         :identity_file => deployment_key,
         :ssh_user => deployment_user,
@@ -36,30 +36,8 @@ module SilverSpurs
       }.merge options
 
       arguments = expand_bootstrap_args bootstrap_options
-      logger.debug "Knife arguments: #{arguments.join ', '}"
-      
-      strap_r, strap_w = IO.pipe
 
-      command = ['knife', 'bootstrap', *arguments, ip].join ' '
-      logger.debug "Knife command line: #{command}"
-      knife_pid = spawn(command, :err => :out, :out => strap_w)
-      
-      Process.waitpid(knife_pid)
-      exitcode = $?.exitstatus
-      
-      strap_w.close
-      loglines = strap_r.read
-      logger.debug "Knife log lines: #{loglines}"
-      strap_r.close
-
-      {
-        :exit_code => exitcode,
-        :log_lines => loglines
-      }
-    end
-
-    def self.logger
-      @logger ||= Logger.new(STDERR)
+      command = ['knife', 'bootstrap', *arguments, ip].join ' '      
     end
     
   end

data/lib/silver_spurs/version.rb

@@ -1,3 +1,3 @@
 module SilverSpurs
-  VERSION = "0.0.8"
+  VERSION = "1.0.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: silver_spurs
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-15 00:00:00.000000000 Z
+date: 2013-03-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sinatra
@@ -187,7 +187,9 @@ files:
 - Rakefile
 - lib/silver_spurs.rb
 - lib/silver_spurs/app.rb
+- lib/silver_spurs/asyncifier.rb
 - lib/silver_spurs/client.rb
+- lib/silver_spurs/client/bootstrap_run.rb
 - lib/silver_spurs/client/exceptions.rb
 - lib/silver_spurs/knife_interface.rb
 - lib/silver_spurs/version.rb