stork 0.1.0.pre → 0.2.0.pre

data/lib/stork/server/application.rb

@@ -5,6 +5,7 @@ module Stork
     class Application < Sinatra::Base
       configure do
         enable :logging
+        disable :show_exceptions
         mime_type :plain, 'text/plain'
         mime_type :json, 'application/json'
       end
@@ -15,10 +16,23 @@ module Stork
       end
 
       get '/' do
-        info 'GET /'
+        loginfo 'GET /'
         json_halt 200, 200, "Stork Version #{VERSION} - #{CODENAME}"
       end
 
+      get '/api/v1/reload' do
+        reload_collection
+      end
+
+      get '/api/v1/actions' do
+        h = {'hosts' => database.hosts}
+        json_halt_ok_with_content(h.to_json)
+      end
+
+      get '/api/v1/sync' do
+        sync_collection
+      end
+
       get '/api/v1/hosts' do
         h = {'hosts' => hosts.hashify}
         json_halt_ok_with_content(h.to_json)
@@ -26,26 +40,32 @@ module Stork
 
       get '/api/v1/host/:host' do |host|
         h = hosts.get(host)
-        json_halt_ok_with_content(h.hashify.to_json)
+        if h
+          json_halt_ok_with_content(h.hashify.to_json)
+        else
+          json_halt_not_found
+        end
       end
 
       get '/host/:host' do |host|
-        info "#{host} requested kickstart"
+        loginfo "#{host} requested kickstart"
 
         h = hosts.get(host)
 
-        if h
+        if h && is_installable?(host)
+          loginfo "Returned kickstart to #{host}"
           # hmm, should the host deploy?
           ks = Stork::Deploy::InstallScript.new(h) # we will be passing the type in shortly
           content_type :plain
           ks.render
         else
+          logerr "Was not able to return kickstart"
           json_halt_not_found
         end
       end
 
       get '/host/:host/installed' do |host|
-        info "#{host} has notified completed install"
+        loginfo "#{host} has notified completed install"
         h = hosts.get(host)
 
         if h
@@ -57,7 +77,7 @@ module Stork
       end
 
       get '/host/:host/install' do |host|
-        info "install requested for #{host}"
+        loginfo "install requested for #{host}"
         h = hosts.get(host)
 
         if h
@@ -68,35 +88,77 @@ module Stork
         end
       end
 
+      get '/public/:filename' do |file|
+        send_file public_path(file)
+      end
+
       not_found do
         json_halt_not_found
       end
 
+      error do
+        json_halt_internal_error
+      end
+
       helpers do
         def hosts
-          @hosts ||= settings.collection.hosts
+          settings.collection.hosts
         end
 
         def config
-          @config ||= settings.config
+          settings.config
+        end
+
+        def collection
+          settings.collection
+        end
+
+        def database
+          settings.database
+        end
+
+        def is_installable?(host)
+          database.host(host)[:action] == 'install'
+        end
+
+        def reload_collection
+          settings.collection = Stork::Builder.load.collection
+          json_halt 200, 200, 'OK'
+        end
+
+        def sync_collection
+          # make sure we reload the collection to pick up changes
+          settings.collection = Stork::Builder.load.collection
+          settings.database.sync_hosts(hosts)
+          json_halt 200, 200, 'OK'
         end
 
         def set_localboot(host)
+          database.boot_local(host.name)
           pxe(host).localboot
         end
 
         def set_install(host)
+          database.boot_install(host.name)
           pxe(host).install
         end
 
         def pxe(host)
-          Stork::PXE.new(host, host.stork, config.port)
+          Stork::PXE.new(host, host.stork, Configuration.port)
         end
 
-        def info(msg)
+        def public_path(filename)
+          File.join(Configuration.public_path, filename)
+        end
+
+        def loginfo(msg)
           logger.info "[#{request.ip}] INFO: #{msg}"
         end
 
+        def logerr(msg)
+          logger.error "[#{request.ip}] ERROR: #{msg}"
+        end
+
         def json_halt(request_status, op_status, message)
           content_type :json
           halt request_status, { 'Content-Type' => 'application/json' }, "{ \"status\":\"#{op_status}\", \"message\": \"#{message}\" }"
@@ -112,14 +174,14 @@ module Stork
           halt 200, { 'Content-Type' => 'application/json' }, content
         end
 
-        def json_halt_internal_error
+        def json_halt_internal_error(content="Internal error")
           content_type :json
-          json_halt 500, 500, 'Internal error'
+          json_halt 500, 500, content
         end
 
         def json_halt_not_found
           content_type :json
-          json_halt 404, 404, 'not found'
+          json_halt 404, 404, 'Not found'
         end
       end
     end

data/lib/stork/server/control.rb

@@ -1,37 +1,98 @@
 require 'sinatra'
 require 'json'
 require 'rack'
-require 'thin'
+require 'webrick'
 
 module Stork
   module Server
     class Control
-      def self.start(configuration, collection)
-        puts "Starting stork server on port #{configuration.port}."
-        app = Stork::Server::Application
-        app.set :collection, collection
-        app.set :config, configuration
-
-        @thin = Thin::Server.new(configuration.bind, configuration.port, app)
-        @thin.tag = "Stork #{VERSION}"
-        unless ENV['RACK_ENV'] == 'test'
-          @thin.pid_file = configuration.pid_file
-          @thin.log_file = configuration.log_file
-          @thin.daemonize
+      def initialize(options)
+        @app = Stork::Server::Application
+        @daemonize = options.daemonize
+      end
+
+      def start
+        @collection = Stork::Builder.load.collection
+        
+        @db = Stork::Database.load(Configuration[:db_path])
+        @db.sync_hosts(@collection.hosts)
+
+        @app.set :collection, @collection
+        @app.set :database, @db
+
+        unless is_daemon?
+          puts <<-EOH.gsub(/^ {12}/, '')
+            >> Starting Stork Server (#{Stork::VERSION})...
+            >> WEBrick (#{WEBrick::VERSION}) with Rack (#{Rack.release}) is listening on #{Configuration[:bind]}:#{Configuration[:port]}
+            >> Press CTRL+C to stop
+
+          EOH
         else
-          puts '!!! Running in test mode'
+          emit_process_id
+        end
+
+        thread = start_background
+        %w[INT TERM].each { |signal| trap_signal(signal) }
+        thread.join
+      end
+
+      def emit_process_id
+        File.open(Configuration[:pid_file], 'w') { |f| f.write(Process.pid) }
+      end
+
+      def trap_signal(signal)
+        Signal.trap(signal) do
+          puts "\n>> Stopping Stork..."
+          @server.shutdown
         end
-        @thin.start
       end
 
-      def self.stop(configuration, collection)
-        puts 'Stoping the stork server.'
-        Thin::Server.kill(configuration.pid_file)
+      ####
+      # Basic start management borrowed from chef-zero.  Thanks for the
+      # heavy lifting!  Could there be a way to utilize any light http 
+      # servers (thin, puma, unicorn)?
+      ####
+      def start_background
+        @server = WEBrick::HTTPServer.new(
+          :BindAddress => Configuration[:bind],
+          :Port =>        Configuration[:port],
+          :AccessLog =>   [],
+          :Logger =>      WEBrick::Log.new(StringIO.new, 7),
+          :StartCallback => proc { @running = true }
+        )
+        @server.mount('/', Rack::Handler::WEBrick, @app)
+
+        @thread = Thread.new do
+          begin
+            Thread.current.abort_on_exception = true
+            @server.start
+          ensure
+            @running = false
+          end
+        end
+        
+        while !@running && @thread.alive?
+          sleep(0.01)
+        end
+        @thread
+      end
+
+      def is_daemon?
+        @daemonize
+      end
+
+      def stop
+        pid = File.read(Configuration[:pid_file]).to_i
+        Process.kill('TERM', pid)
+      rescue Errno::ENOENT
+        puts "Process ID file not present."
+      rescue Errno::ESRCH
+        puts "Stork is not running."
       end
 
-      def self.restart(configuration, collection)
-        stop(configuration, collection)
-        start(configuration, collection)
+      def restart
+        stop
+        start
       end
     end
   end

data/lib/stork/version.rb

@@ -1,4 +1,4 @@
 module Stork
-  VERSION = '0.1.0.pre'
+  VERSION = '0.2.0.pre'
   CODENAME = 'Psychotic Hamster'
 end

data/lib/stork.rb

@@ -16,15 +16,16 @@ require 'stork/deploy/kickstart_binding'
 require 'stork/deploy/install_script'
 
 require 'stork/pxe'
+require 'stork/database'
 
 require 'stork/server/application'
 require 'stork/server/control'
 
 require 'stork/plugin'
-Dir[File.join('./lib/stork/client/plugins', '*.rb')].each do |plugin|
-  require plugin
 
-  Stork.add_plugin(plugin)
+path = File.expand_path(File.dirname(__FILE__))
+Dir[File.join(path, '/stork/client/plugins', '*.rb')].each do |plugin|
+  require plugin
 end
 
 # Also make sure we allow a .stork/plugins dir

data/specs/builder_spec.rb

@@ -1,8 +1,12 @@
 require File.dirname(__FILE__) + '/spec_helper'
 
 describe "Stork::Builder" do
+  before(:each) do
+    load_config
+  end
+
   it "must load everything" do
-    builder = Stork::Builder.load(configuration)
+    builder = Stork::Builder.load
     collection = builder.collection
     collection.hosts.size.must_equal 11
     collection.chefs.size.must_equal 1

data/specs/configuration_spec.rb

@@ -10,141 +10,24 @@ describe "Stork::Configuration" do
     FileUtils.rm_rf(Dir.glob("#{@path}/tmp/*"))
   end
 
-  it "should respond to path accessors" do
-    Stork::Configuration.new.must_respond_to :path
-    Stork::Configuration.new.must_respond_to :path=
-  end
-
-  it "should respond to bundles accessors" do
-    Stork::Configuration.new.must_respond_to :bundle_path
-    Stork::Configuration.new.must_respond_to :bundle_path=
-  end
-
-  it "should respond to hosts_path" do
-    Stork::Configuration.new.must_respond_to :hosts_path
-  end
-
-  it "should respond to snippets_path" do
-    Stork::Configuration.new.must_respond_to :snippets_path
-  end
-
-  it "should respond to layouts_path accessors" do
-    Stork::Configuration.new.must_respond_to :layouts_path
-  end
-
-  it "should respond to networks_path accessors" do
-    Stork::Configuration.new.must_respond_to :networks_path
-  end
-
-  it "should respond to distros_path accessors" do
-    Stork::Configuration.new.must_respond_to :distros_path
-  end
-
-  it "should respond to templates_path accessors" do
-    Stork::Configuration.new.must_respond_to :templates_path
-  end
-
-  it "should respond to chefs_path accessors" do
-    Stork::Configuration.new.must_respond_to :chefs_path
-  end
-
-  it "should respond to authorized_keys_file accessors" do
-    Stork::Configuration.new.must_respond_to :authorized_keys_file
-    Stork::Configuration.new.must_respond_to :authorized_keys_file=
-  end
-
-  it "should respond to pxe_path accessors" do
-    Stork::Configuration.new.must_respond_to :pxe_path
-    Stork::Configuration.new.must_respond_to :pxe_path=
-  end
-
-  it "should respond to log_file accessors" do
-    Stork::Configuration.new.must_respond_to :log_file
-    Stork::Configuration.new.must_respond_to :log_file=
-  end
-
-  it "should respond to pid_file accessors" do
-    Stork::Configuration.new.must_respond_to :pid_file
-    Stork::Configuration.new.must_respond_to :pid_file=
-  end
-
-  it "should respond to server accessors" do
-    Stork::Configuration.new.must_respond_to :server
-    Stork::Configuration.new.must_respond_to :server=
-  end
-
-  it "should respond to port accessors" do
-    Stork::Configuration.new.must_respond_to :port
-    Stork::Configuration.new.must_respond_to :port=
-  end
-
-  it "should respond to bind accessors" do
-    Stork::Configuration.new.must_respond_to :bind
-    Stork::Configuration.new.must_respond_to :bind=
-  end
-
-  it "should respond to timezone accessors" do
-    Stork::Configuration.new.must_respond_to :timezone
-    Stork::Configuration.new.must_respond_to :timezone=
-  end
-
-  it "should have the defaults" do
-    config = Stork::Configuration.new
-    config.path.must_equal                  "/etc/stork"
-    config.bundle_path.must_equal           "/etc/stork/bundles"
-    config.hosts_path.must_equal            "/etc/stork/bundles/hosts"
-    config.layouts_path.must_equal          "/etc/stork/bundles/layouts"
-    config.snippets_path.must_equal         "/etc/stork/bundles/snippets"
-    config.networks_path.must_equal         "/etc/stork/bundles/networks"
-    config.distros_path.must_equal          "/etc/stork/bundles/distros"
-    config.chefs_path.must_equal            "/etc/stork/bundles/chefs"
-    config.templates_path.must_equal        "/etc/stork/bundles/templates"
-    config.authorized_keys_file.must_equal  "/etc/stork/authorized_keys"
-    config.pxe_path.must_equal              "/var/lib/tftpboot/pxelinux.cfg"
-    config.log_file.must_equal              "/var/log/stork.log"
-    config.pid_file.must_equal              "/var/run/stork.pid"
-    config.server.must_equal                "localhost"
-    config.port.must_equal                  9293
-    config.bind.must_equal                  "0.0.0.0"
-    config.timezone.must_equal              "America/Los_Angeles"
-  end
-
-    it "should load from file" do
-    config = Stork::Configuration.from_file("./specs/stork/config.rb")
-    config.path.must_equal                  "./specs/stork"
-    config.bundle_path.must_equal           "./specs/stork/bundles"
-    config.hosts_path.must_equal            "./specs/stork/bundles/hosts"
-    config.layouts_path.must_equal          "./specs/stork/bundles/layouts"
-    config.snippets_path.must_equal         "./specs/stork/bundles/snippets"
-    config.networks_path.must_equal         "./specs/stork/bundles/networks"
-    config.distros_path.must_equal          "./specs/stork/bundles/distros"
-    config.chefs_path.must_equal            "./specs/stork/bundles/chefs"
-    config.templates_path.must_equal        "./specs/stork/bundles/templates"
-    config.authorized_keys_file.must_equal  "./specs/stork/authorized_keys"
-    config.pxe_path.must_equal              "./specs/tmp/pxeboot"
-    config.log_file.must_equal              "./specs/tmp/stork.log"
-    config.pid_file.must_equal              "./specs/tmp/stork.pid"
-    config.server.must_equal                "localhost"
-    config.port.must_equal                  5000
-    config.bind.must_equal                  "0.0.0.0"
-    config.timezone.must_equal              "America/New_York"
-  end
-
   it "should create a file if the configuration file does not exist" do
-    config = Stork::Configuration.from_file("./specs/tmp/config.rb")
+    Stork::Configuration.reset
+    Stork::Configuration.to_file("./specs/tmp/config.rb")
+    Stork::Configuration.from_file("./specs/tmp/config.rb")
     File.exist?("./specs/tmp/config.rb").must_equal true
-    expected_content = <<-EOS
-# Stork configuration file"
-path                    "/etc/stork"
-bundle_path             "/etc/stork/bundles"
-authorized_keys_file    "/etc/stork/authorized_keys"
-pxe_path                "/var/lib/tftpboot/pxelinux.cfg"
-log_file                "/var/log/stork.log"
-pid_file                "/var/run/stork.pid"
-server                  "localhost"
-port                    9293
-bind                    "0.0.0.0"
-timezone                "America/Los_Angeles"
+    expected_content = <<-EOS.gsub(/^ {6}/, '')
+      # Stork configuration file
+      path                    "/etc/stork"
+      bundle_path             "/etc/stork/bundles"
+      authorized_keys_file    "/etc/stork/authorized_keys"
+      pxe_path                "/var/lib/tftpboot/pxelinux.cfg"
+      db_path                 "/var/lib/stork"
+      log_file                "/var/log/stork.log"
+      pid_file                "/var/run/stork.pid"
+      server                  "localhost"
+      port                    9293
+      bind                    "0.0.0.0"
+      timezone                "America/Los_Angeles"
     EOS
     File.read("./specs/tmp/config.rb").must_equal expected_content
   end

data/specs/database_spec.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'fileutils'
+
+describe "Stork::PXE" do
+  before(:each) do
+    @db = Stork::Database.load('./specs/tmp')
+    @db.sync_hosts(collection.hosts)
+  end
+
+  after(:each) do
+    FileUtils.rm_rf(Dir.glob('./specs/tmp/*'))
+  end
+
+  it "contains and can access all of the hosts" do
+    collection.hosts.each do |host|
+      result = @db.host(host.name)
+      result[:name].must_equal host.name
+      result[:action].must_equal 'localboot'
+    end
+  end
+
+  it "can change the boot action and then change it back" do
+    @db.boot_install('c013.example.org')
+    result = @db.host('c013.example.org')
+    result[:name].must_equal 'c013.example.org'
+    result[:action].must_equal 'install'
+
+    @db.boot_local('c013.example.org')
+    result = @db.host('c013.example.org')
+    result[:name].must_equal 'c013.example.org'
+    result[:action].must_equal 'localboot'
+  end
+end

data/specs/deploy_snippet_binding_spec.rb

@@ -0,0 +1,15 @@
+
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe "Stork::Deploy::SnippetBinding" do
+  before(:each) do
+    load_config
+  end
+
+  it "must create a valid first boot file for chef" do
+    host = collection.hosts.get("server.example.org")
+    binding = Stork::Deploy::SnippetBinding.new(host)
+    first_boot_content = "{\"run_list\":[\"role[base]\",\"recipe[apache]\"]}"
+    binding.first_boot_content.must_equal first_boot_content
+  end
+end

data/specs/kickstart_spec.rb

@@ -2,6 +2,7 @@ require File.dirname(__FILE__) + '/spec_helper'
 
 describe "Stork::Deploy::Kickstart" do
   before(:each) do
+    load_config
     @host = collection.hosts.get("server.example.org")
     @path = File.dirname(__FILE__)
     FileUtils.mkdir_p "#{@path}/tmp"

data/specs/pxe_spec.rb

@@ -22,7 +22,7 @@ TIMEOUT 0
 TOTALTIMEOUT 0
 ONTIMEOUT local
 LABEL local
-        LOCALBOOT -1
+        LOCALBOOT 0
     EOS
     File.read("#{@path}/01-00-11-22-33-44-55").must_equal expected_content
   end
@@ -36,7 +36,7 @@ TIMEOUT 0
 TOTALTIMEOUT 0
 ONTIMEOUT local
 LABEL local
-        LOCALBOOT -1
+        LOCALBOOT 0
     EOS
     File.read("#{@path}/01-00-11-22-33-44-55").must_equal expected_content
   end