stork 0.1.0.pre

data/lib/stork/client/plugins/host_install.rb

@@ -0,0 +1,19 @@
+module HostInstallPlugin
+  class HostInstall < Stork::Plugin
+    banner "stork host install HOST (options)"
+
+    def run
+      host = args.shift
+      raise SyntaxError, "A host must be supplied" if host.nil?
+      
+      response = RestClient.get "#{stork}/host/#{host}/install"
+      if response.code == 200
+        puts "OK"
+      else
+        data = JSON.parse(response)
+        puts "Error: #{data['message']}"
+        exit 1
+      end
+    end
+  end
+end

data/lib/stork/client/plugins/host_list.rb

@@ -0,0 +1,12 @@
+module HostListPlugin
+  class HostList < Stork::Plugin
+    banner "stork host list (options)"
+
+    def run
+      data = fetch('/hosts')
+      data['hosts'].sort.each do |host|
+        puts host
+      end
+    end
+  end
+end

data/lib/stork/client/plugins/host_localboot.rb

@@ -0,0 +1,19 @@
+module HostLocalbootPlugin
+  class HostLocalboot < Stork::Plugin
+    banner "stork host localboot HOST (options)"
+
+    def run
+      host = args.shift
+      raise SyntaxError, "A host must be supplied" if host.nil?
+      
+      response = RestClient.get "#{stork}/host/#{host}/installed"
+      if response.code == 200
+        puts "OK"
+      else
+        data = JSON.parse(response)
+        puts "Error: #{data['message']}"
+        exit 1
+      end
+    end
+  end
+end

data/lib/stork/client/plugins/host_show.rb

@@ -0,0 +1,19 @@
+module HostShowPlugin
+  class HostShow < Stork::Plugin
+    banner "stork host show HOST (options)"
+
+    def run
+      host = args.shift
+      raise SyntaxError, "A host must be supplied" if host.nil?
+      data = fetch("/host/#{host}")
+      show('name', data)
+      show('distro', data)
+      show('template', data)
+      show('chef', data)
+      show('run_list', data)
+      show('pre_snippets', data)
+      show('post_snippets', data)
+      show('packages', data)
+    end
+  end
+end

data/lib/stork/collection/base.rb

@@ -0,0 +1,45 @@
+module Stork
+  module Collection
+    class Base
+      include Enumerable
+
+      def initialize(*objs)
+        @objects = objs
+      end
+
+      def size
+        @objects.size
+      end
+
+      def add(*objs)
+        objs.each do |obj|
+          validate(obj)
+          @objects << obj
+        end
+      end
+
+      def each(&block)
+        @objects.each do |obj|
+          block.call(obj)
+        end
+      end
+
+      def validate(obj)
+        true
+      end
+
+      # Need to check for nil and raise
+      def get(id)
+        find { |obj| obj.id == id }
+      end
+
+      def hashify
+        objs = []
+        @objects.each do |obj|
+          objs << obj.name
+        end
+        objs
+      end
+    end
+  end
+end

data/lib/stork/collection/chefs.rb

@@ -0,0 +1,6 @@
+module Stork
+  module Collection
+    class Chefs < Base
+    end
+  end
+end

data/lib/stork/collection/distros.rb

@@ -0,0 +1,6 @@
+module Stork
+  module Collection
+    class Distros < Base
+    end
+  end
+end

data/lib/stork/collection/hosts.rb

@@ -0,0 +1,6 @@
+module Stork
+  module Collection
+    class Hosts < Base
+    end
+  end
+end

data/lib/stork/collection/layouts.rb

@@ -0,0 +1,6 @@
+module Stork
+  module Collection
+    class Layouts < Base
+    end
+  end
+end

data/lib/stork/collection/networks.rb

@@ -0,0 +1,6 @@
+module Stork
+  module Collection
+    class Networks < Base
+    end
+  end
+end

data/lib/stork/collection/snippets.rb

@@ -0,0 +1,6 @@
+module Stork
+  module Collection
+    class Snippets < Base
+    end
+  end
+end

data/lib/stork/collection/templates.rb

@@ -0,0 +1,6 @@
+module Stork
+  module Collection
+    class Templates < Base
+    end
+  end
+end

data/lib/stork/collections.rb

@@ -0,0 +1,38 @@
+require 'stork/collection/base'
+require 'stork/collection/chefs'
+require 'stork/collection/distros'
+require 'stork/collection/hosts'
+require 'stork/collection/layouts'
+require 'stork/collection/networks'
+require 'stork/collection/snippets'
+require 'stork/collection/templates'
+
+module Stork
+  class Collections
+    attr_reader :hosts
+    attr_reader :layouts
+    attr_reader :networks
+    attr_reader :chefs
+    attr_reader :distros
+    attr_reader :snippets
+    attr_reader :templates
+
+    def initialize
+      @hosts = Stork::Collection::Hosts.new
+      @layouts = Stork::Collection::Layouts.new
+      @networks = Stork::Collection::Networks.new
+      @chefs = Stork::Collection::Chefs.new
+      @distros = Stork::Collection::Distros.new
+      @snippets = Stork::Collection::Snippets.new
+      @templates = Stork::Collection::Templates.new
+    end
+
+    alias_method :network, :networks
+    alias_method :layout, :layouts
+    alias_method :host, :hosts
+    alias_method :chef, :chefs
+    alias_method :distro, :distros
+    alias_method :snippet, :snippets
+    alias_method :template, :templates
+  end
+end

data/lib/stork/configuration.rb

@@ -0,0 +1,98 @@
+module Stork
+  class Configuration
+    attr_accessor :path
+    attr_accessor :bundle_path
+    attr_accessor :authorized_keys_file
+    attr_accessor :pxe_path
+    attr_accessor :log_file
+    attr_accessor :pid_file
+    attr_accessor :server
+    attr_accessor :port
+    attr_accessor :bind
+    attr_accessor :timezone
+
+    def initialize
+      @path                 = '/etc/stork'
+      @authorized_keys_file = path + '/authorized_keys'
+      @bundle_path          = path + '/bundles'
+
+      @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'
+    end
+
+    def hosts_path
+      bundle_path + '/hosts'
+    end
+
+    def snippets_path
+      bundle_path + '/snippets'
+    end
+
+    def layouts_path
+      bundle_path + '/layouts'
+    end
+
+    def networks_path
+      bundle_path + '/networks'
+    end
+
+    def distros_path
+      bundle_path + '/distros'
+    end
+
+    def templates_path
+      bundle_path + '/templates'
+    end
+
+    def chefs_path
+      bundle_path + '/chefs'
+    end
+
+    def to_file
+      <<-EOS
+# Stork configuration file"
+path                    "#{path}"
+bundle_path             "#{bundle_path}"
+authorized_keys_file    "#{authorized_keys_file}"
+pxe_path                "#{pxe_path}"
+log_file                "#{log_file}"
+pid_file                "#{pid_file}"
+server                  "#{server}"
+port                    #{port}
+bind                    "#{bind}"
+timezone                "#{timezone}"
+      EOS
+    end
+
+    def self.from_file(filename)
+      find_or_create(filename)
+    end
+
+    def self.find_or_create(filename)
+      config = new
+      if File.exist?(filename)
+        delegator = ConfigDelegator.new(config)
+        delegator.instance_eval(File.read(filename), filename)
+      else
+        File.open(filename, 'w') { |file| file.write(config.to_file) }
+      end
+      config
+    end
+
+    class ConfigDelegator
+      def initialize(obj)
+        @delegated = obj
+      end
+
+      def method_missing(meth, *args)
+        @delegated.send("#{meth}=", *args)
+      end
+    end
+  end
+end

data/lib/stork/deploy/command.rb

@@ -0,0 +1,59 @@
+module Stork
+  module Deploy
+    class Command
+      def initialize(name, value)
+        @name = name
+        @value = value
+        @options = Array.new
+      end
+
+      def to_s
+        command_str = @name
+        command_str << " #{@value}" if @value
+        if @options.empty?
+          command_str << "\n"
+        else
+          command_str << " #{@options.join(' ')}\n"
+        end
+      end
+
+      def boolean(opt, value)
+        @options << "--#{opt}" if value
+      end
+
+      def option(opt, value)
+        if value.is_a?(Array)
+          @options << "--#{opt}=#{value.join(',')}" unless value.empty?
+        else
+          @options << "--#{opt}=#{value}" if value
+        end
+      end
+
+      def yes_no(opt, value)
+        @options << "--#{opt}=#{value ? 'yes' : 'no'}" if value
+      end
+
+      def either_or(opt, alt, value)
+        @options << "--#{value ? opt : alt}"
+      end
+
+      def multi(opt, values)
+        values.each do |value|
+          @options << "--#{opt}=#{value}"
+        end
+      end
+
+      def value(value)
+        @value = value
+      end
+
+      def self.create(name, value=nil, &block)
+        command = new(name, value)
+        yield command if block_given?
+        # puts "COMM: #{command.inspect}"
+        # puts "COMS: #{command.to_s}"
+        command.to_s
+      end
+    end
+  end
+end

data/lib/stork/deploy/install_script.rb

@@ -0,0 +1,39 @@
+module Stork
+  module Deploy
+    class InstallScript
+      attr_reader :type, :host, :configuration
+
+      def initialize(host, type=:kickstart)
+        @host = host
+        @type = type
+        @configuration = host.configuration
+      end
+
+      def render
+        renderer = ERB.new(host.template.content)
+        binding = InstallScriptBinding.new(type, host).get_binding
+        renderer.result(binding)
+      end
+
+      require 'forwardable'
+      class InstallScriptBinding
+        extend Forwardable
+        def_delegators :@builder, :url, :network, :password, :firewall,
+          :timezone, :selinux, :layout, :partitions, :repos, :volume_groups,
+          :packages, :pre_snippets, :post_snippets
+        attr_reader :host, :configuration
+
+        def initialize(type, host)
+          # puts Stork::Deploy::Commands.constants.inspect
+          @builder = Stork::Deploy.const_get("#{type.to_s.capitalize}Binding").new(host)
+          @configuration = configuration
+          @host = host.configuration
+        end
+
+        def get_binding
+          binding
+        end
+      end
+    end
+  end
+end

data/lib/stork/deploy/kickstart_binding.rb

@@ -0,0 +1,222 @@
+module Stork
+  module Deploy
+    class KickstartBinding
+      attr_reader :host, :configuration
+
+      def initialize(host)
+        @host = host
+        @configuration = host.configuration
+      end
+
+      def url
+        Command.create 'url' do |c|
+          c.option 'url', host.distro.url
+        end
+      end
+
+      def network
+        commands = []
+        host.interfaces.each do |i|
+          commands << interface(i)
+        end
+        commands.join
+      end
+
+      def interface(interface)
+        Command.create 'network' do |c|
+          c.option 'device', interface.device
+          c.option 'bootproto', interface.bootproto
+          if interface.static?
+            c.option 'ip', interface.ip
+            c.option 'netmask', interface.netmask
+            c.option 'gateway', interface.gateway
+            c.option 'nameserver', interface.nameservers
+          end
+          c.yes_no 'onboot', interface.onboot
+          c.boolean 'noipv4', !interface.ipv4
+          c.boolean 'noipv6', !interface.ipv6
+          c.boolean 'nodefroute', !interface.defroute
+          c.boolean 'nodns', !interface.dns
+          c.option 'ethtool', interface.ethtool
+          c.option 'mtu', interface.mtu
+        end
+      end
+
+      def password
+        Command.create 'rootpw' do |c|
+          c.value host.password.value
+
+          if host.password.locked?
+            c.boolean 'lock', true
+          else
+            c.either_or 'iscrypted', 'plaintext', host.password.encrypted
+          end
+        end
+      end
+
+      def firewall
+        fw = host.firewall
+        Command.create 'firewall' do |c|
+          c.either_or 'enabled', 'disabled', fw.enabled
+          if fw.enabled
+            c.boolean 'ssh', fw.ssh
+            c.boolean 'telnet', fw.telnet
+            c.boolean 'smtp', fw.smtp
+            c.boolean 'http', fw.http
+            c.boolean 'ftp', fw.ftp
+            c.option 'port', fw.allowed_ports
+            c.multi 'trust', fw.trusted_devices
+          end
+        end
+      end
+
+      def timezone
+        tz = host.timezone
+        Command.create 'timezone' do |c|
+          c.value tz.zone
+          # c.boolean 'utc', tz.utc
+          # c.boolean 'ntp', tz.ntp
+          # c.option 'ntpservers', tz.ntpservers
+        end
+      end
+
+      def selinux
+        Command.create 'selinux' do |c|
+          c.boolean host.selinux, true
+        end
+      end
+
+      def layout
+        commands = []
+        commands << bootloader
+        commands << zerombr
+        commands << clearpart
+        commands << partitions
+        commands << volume_groups
+        commands.join
+      end
+
+      def bootloader
+        Command.create 'bootloader' do |c|
+          c.option 'location', 'mbr'
+        end
+      end
+
+      def zerombr
+        Command.create 'zerombr' if host.layout.zerombr
+      end
+
+      def clearpart
+        Command.create 'clearpart' do |c|
+          c.boolean 'all', true
+          c.boolean 'initlabel', true
+        end if host.layout.clearpart
+      end
+
+      def repos
+        commands = []
+        host.repos.each do |repo|
+          command = Command.create 'repo' do |c|
+            c.option 'name', repo.name
+            c.option 'baseurl', repo.baseurl
+            c.option 'mirrorlist', repo.mirrorlist
+          end
+          commands << command
+        end
+        commands.join
+      end
+
+      def volume_groups
+        commands = []
+        host.layout.volume_groups.each do |vg|
+          a = volume_group(vg)
+          commands << a
+          commands << logical_volumes(vg)
+        end
+        commands.join
+      end
+
+      def volume_group(vg)
+        Command.create 'volgroup' do |c|
+          c.value "#{vg.name} #{vg.partition}"
+        end
+      end
+
+      def logical_volumes(volume_group)
+        commands = []
+        volume_group.logical_volumes.each do |lv|
+          commands << logical_volume(volume_group, lv)
+        end
+        commands.join
+      end
+
+      def logical_volume(vg, lv)
+        Command.create 'logvol' do |c|
+          c.value lv.path
+          c.option 'vgname', vg.name
+          c.option 'name', lv.name
+          filesystem_options(lv, c)
+        end
+      end
+
+      def partitions
+        commands = []
+        host.layout.partitions.each do |part|
+          commands << partition(part)
+        end
+        commands.join
+      end
+
+      def partition(part)
+        Command.create 'part' do |c|
+          c.value part.path
+          c.boolean 'asprimary', part.primary
+          filesystem_options(part, c)
+        end
+      end
+
+      def filesystem_options(part_or_lv, command)
+        command.option 'fstype', part_or_lv.type
+        if part_or_lv.recommended
+          command.boolean 'recommended', true
+        else
+          command.option 'size', part_or_lv.size
+          command.boolean 'grow', part_or_lv.grow
+        end
+      end
+
+      def packages
+        Section.create 'packages' do |s|
+          s.content host.packages.join("\n")
+        end
+      end
+
+      def pre_snippets
+        Section.create 'pre' do |s|
+          s.content render_snippets(host.pre_snippets)
+        end
+      end
+
+      def post_snippets
+        Section.create 'post', log: '/root/midwife-post.log' do |s|
+          s.content render_snippets(host.post_snippets)
+        end
+      end
+
+      private
+
+      def render_snippets(snippets)
+        lines = []
+        snippets.each do |snippet|
+          # Render me!!!
+          renderer = ERB.new(snippet.content, nil, '-')
+          lines << renderer.result(
+            Stork::Deploy::SnippetBinding.new(
+              @configuration, host).get_binding
+            )
+        end
+        lines.join("\n")
+      end
+    end
+  end
+end

data/lib/stork/deploy/section.rb

@@ -0,0 +1,30 @@
+module Stork
+  module Deploy
+    class Section
+      def initialize(name, options)
+        @name = name
+        @options = options
+        @contents = Array.new
+      end
+
+      def to_s
+        str = "%#{@name}"
+        @options.each { |key, value| str += " --#{key}=#{value}" }
+        str += "\n"
+        str += @contents.join("\n")
+        str += "\n%end"
+        str
+      end
+
+      def content(content)
+        @contents << content
+      end
+
+      def self.create(name, opts={}, &block)
+        section = new(name, opts)
+        yield section if block_given?
+        section.to_s
+      end
+    end
+  end
+end