stork 0.1.0.pre

data/lib/stork/deploy/snippet_binding.rb

@@ -0,0 +1,49 @@
+module Stork
+  module Deploy
+    class SnippetBinding
+      attr_reader :host
+
+      def initialize(configuration, host)
+        @host = host
+        @configuration = configuration
+      end
+
+      def get_binding
+        binding
+      end
+
+      def chef
+        host.chef
+      end
+
+      def authorized_keys
+        File.read(@configuration.authorized_keys_file)
+      end
+
+      def first_boot_content
+        run_list = { 'run_list' => host.run_list }
+        run_list.to_json
+      end
+
+      def nameservers
+        host.interfaces.map { |x| x.nameservers }.uniq.flatten
+      end
+
+      def search_paths
+        host.interfaces.map { |x| x.search_paths }.uniq.flatten
+      end
+
+      def midwife_server
+        @configuration.server
+      end
+
+      def midwife_port
+        @configuration.port
+      end
+
+      def midwife_bind
+        @configuration.bind
+      end
+    end
+  end
+end

data/lib/stork/plugin.rb

@@ -0,0 +1,54 @@
+require 'rest-client'
+require 'highline/import'
+
+module Stork
+  def self.plugins
+    @plugins || []
+  end
+
+  def self.add_plugin(plugin)
+    plugins << plugin
+  end
+
+  class Plugin
+    attr_reader :options
+    attr_reader :args
+    attr_reader :stork
+
+    def self.banner(str)
+      @banner = str
+    end
+
+    def self.help
+      @banner
+    end
+
+    def initialize(configuration, options, args)
+      @action = nil
+      @configuration = configuration
+      @options = options
+      @args = args
+      @stork = "http://#{configuration.server}:#{configuration.port}"
+    end
+
+    def fetch(path)
+      response = RestClient.get "#{@stork}/api/v1/#{path}"
+      data = JSON.parse(response)
+    end
+
+    def show(key, data, options = {})
+      padding = options.has_key?('pad') ? options['pad'] : 16
+      name = key.split('_').map{|k| k.capitalize}.join(' ').ljust(padding)
+      if data[key].is_a?(Array)
+        value = data[key].join(', ')
+      else
+        value = data[key]
+      end
+      say("<%= color('#{name}:', CYAN) %> #{value}")
+    end
+
+    def run
+      puts "No content"
+    end
+  end
+end

data/lib/stork/pxe.rb

@@ -0,0 +1,70 @@
+module Stork
+  class PXE
+    attr_reader :initrd, :kernel, :kickstart, :path, :hostname, :mac
+
+    # def initialize(server, path, hostname, mac, kernel, initrd)
+    #   @host = hostname
+    #   @initrd = initrd
+    #   @kernel = kernel
+    #   @path = path
+    #   @mac = mac
+    #   @kickstart = "http://#{server}/ks/#{hostname}"
+    # end
+
+    def initialize(host, server, port)
+      @hostname = host.name
+      @initrd = host.distro.image
+      @kernel = host.distro.kernel
+      @path = host.configuration.pxe_path
+      @mac = host.pxemac
+      @server = server
+      @port = port
+      @kickstart = "http://#{server}:#{port}/host/#{hostname}"
+    end
+
+    def localboot
+      write localboot_content
+    end
+
+    def install
+      write install_content
+    end
+
+    alias_method :default, :localboot
+
+    private
+    def install_content
+      <<-EOS
+default install
+prompt 0
+timeout 1
+label install
+        kernel #{kernel}
+        ipappend 2
+        append initrd=#{initrd} ksdevice=bootif priority=critical kssendmac ks=#{kickstart}
+      EOS
+    end
+
+    def localboot_content
+      <<-EOS
+DEFAULT local
+PROMPT 0
+TIMEOUT 0
+TOTALTIMEOUT 0
+ONTIMEOUT local
+LABEL local
+        LOCALBOOT -1
+      EOS
+    end
+
+    def write(str)
+      File.open("#{path}/#{pxefile}", 'w') do |f|
+        f.write(str)
+      end
+    end
+
+    def pxefile
+      '01-' + @mac.gsub(/[:]/, '-')
+    end
+  end
+end

data/lib/stork/resource/base.rb

@@ -0,0 +1,42 @@
+module Stork
+  module Resource
+    class Base
+      attr_reader :name
+      attr_reader :options
+      attr_reader :configuration
+
+      def initialize(name = nil, options = {})
+        @name = name
+        @configuration = options[:configuration]
+        @options = options
+        setup
+      end
+
+      def setup
+      end
+
+      def validate!
+      end
+
+      def hashify
+        {'name' => @name}
+      end
+
+      def require_value(attr)
+        fail SyntaxError, "#{attr} is required" if send(attr).nil?
+      end
+
+      def self.build(name = nil, options = {}, &block)
+        inst = new(name, options)
+        klass_name = self.to_s.split('::').last
+        klass = const_get("#{klass_name}Delegator")
+        delegator = klass.new(inst, options)
+        delegator.instance_eval(&block) if block_given?
+        inst.validate!
+        inst
+      end
+
+      alias_method :id, :name
+    end
+  end
+end

data/lib/stork/resource/chef.rb

@@ -0,0 +1,81 @@
+module Stork
+  module Resource
+    class Chef < Base
+      attr_accessor :url
+      attr_accessor :version
+      attr_accessor :client_name
+      attr_accessor :validator_name
+      attr_accessor :client_key
+      attr_accessor :validation_key
+      attr_accessor :encrypted_data_bag_secret
+
+      def setup
+        @url = nil
+        @version = nil
+        @client_name = "root"
+        @validator_name = "chef-validator"
+        @validation_key = nil
+        @client_key = nil
+        @encrypted_data_bag_secret = nil
+      end
+
+      def validate!
+        # I should make sure that I'm at least getting the url,
+        # version, and the files.
+        require_value(:url)
+        require_value(:version)
+        require_value(:validation_key)
+        require_value(:client_key)
+      end
+
+      def client_content
+        <<-EOF
+log_level               :auto
+log_location            STDOUT
+chef_server_url         '#{url}'
+validation_client_name  '#{validator_name}'
+# Using default node name (fqdn)
+        EOF
+      end
+
+      def knife_content
+        <<-EOF
+log_level                :info
+log_location             STDOUT
+node_name                '#{client_name}'
+client_key               '/root/.chef/#{client_name}.pem'
+validation_client_name   '#{validator_name}'
+validation_key           '/etc/chef/validation.pem'
+chef_server_url          '#{url}'
+cache_type               'BasicFile'
+cache_options( :path => '/root/.chef/checksums' )
+        EOF
+      end
+
+      class ChefDelegator < Stork::Resource::Delegator
+        file :client_key
+        file :validation_key
+
+        def url(url)
+          delegated.url = url
+        end
+
+        def version(version)
+          delegated.version = version
+        end
+
+        def client_name(client_name)
+          delegated.client_name = client_name
+        end
+
+        def validator_name(validator_name)
+          delegated.validator_name = validator_name
+        end
+
+        def encrypted_data_bag_secret(secret)
+          delegated.encrypted_data_bag_secret = secret
+        end
+      end
+    end
+  end
+end

data/lib/stork/resource/delegator.rb

@@ -0,0 +1,50 @@
+module Stork
+  module Resource
+    class Delegator
+      attr_reader :collection
+      attr_reader :configuration
+      attr_reader :delegated
+
+      def initialize(inst, options)
+        @delegated = inst
+        @collection = options[:collection]
+        @configuration = options[:configuration]
+      end
+
+      def get_collection_item(name, value)
+        obj = collection.send(name).get(value)
+        raise SyntaxError, "Could not find #{value} in #{name}" unless obj
+        obj
+      end
+
+      def self.flag(name, options = {})
+        create_boolean_delegators(name, options)
+      end
+
+      def self.file(name, options = {})
+        create_file_delegators(name, options)
+      end
+
+      def self.create_boolean_delegators(name, options)
+        negate_name = options.has_key?(:negate) ? options[:negate] : "no#{name}"
+        self.class_eval <<-EOS, __FILE__, __LINE__
+          def #{name}
+            @delegated.#{name} = true
+          end
+
+          def #{negate_name}
+            @delegated.#{name} = false
+          end
+        EOS
+      end
+
+      def self.create_file_delegators(name, options)
+        self.class_eval <<-EOS, __FILE__, __LINE__
+          def #{name}(value)
+            @delegated.#{name} = ::File.read(value)
+          end
+        EOS
+      end
+    end
+  end
+end

data/lib/stork/resource/distro.rb

@@ -0,0 +1,30 @@
+module Stork
+  module Resource
+    class Distro < Base
+      attr_accessor :kernel
+      attr_accessor :image
+      attr_accessor :url
+
+      def hashify
+        attrs = {}
+        attrs['kernel'] = kernel
+        attrs['image'] = image
+        attrs['url'] = url
+      end
+
+      class DistroDelegator < Stork::Resource::Delegator
+        def kernel(kernel)
+          delegated.kernel = kernel
+        end
+
+        def image(image)
+          delegated.image = image
+        end
+
+        def url(url)
+          delegated.url = url
+        end
+      end
+    end
+  end
+end

data/lib/stork/resource/firewall.rb

@@ -0,0 +1,47 @@
+module Stork
+  module Resource
+    class Firewall < Base
+      attr_accessor :enabled
+      attr_accessor :ssh
+      attr_accessor :telnet
+      attr_accessor :smtp
+      attr_accessor :http
+      attr_accessor :ftp
+      attr_accessor :trusted_devices
+      attr_accessor :allowed_ports
+      
+      def setup
+        @enabled = true
+        @ssh = true
+        @telnet = false
+        @smtp = false
+        @http = false
+        @ftp = false
+        @trusted_devices = Array.new
+        @allowed_ports = Array.new
+      end
+
+      class FirewallDelegator < Stork::Resource::Delegator
+        flag :enabled, negate: :disable
+        flag :ssh
+        flag :telnet
+        flag :smtp
+        flag :http
+        flag :ftp
+
+        def trusted_device(device)
+          delegated.trusted_devices << device
+        end
+
+        alias_method :trusted, :trusted_device
+        alias_method :trust, :trusted_device
+
+        def allowed_port(port)
+          delegated.allowed_ports << port
+        end
+
+        alias_method :allow, :allowed_port
+      end
+    end
+  end
+end

data/lib/stork/resource/host.rb

@@ -0,0 +1,202 @@
+module Stork
+  module Resource
+    class Host < Base
+      attr_accessor :layout
+      attr_accessor :template
+      attr_accessor :chef
+      attr_accessor :pxemac
+      attr_accessor :pre_snippets
+      attr_accessor :post_snippets
+      attr_accessor :interfaces
+      attr_accessor :distro
+      attr_accessor :timezone
+      attr_accessor :firewall
+      attr_accessor :password
+      attr_accessor :selinux
+      attr_accessor :packages
+      attr_accessor :run_list
+      attr_accessor :repos
+      attr_accessor :stork
+
+      def setup
+        @layout = nil
+        @template = nil
+        @distro = nil
+
+        @chef = nil
+        @pxemac = nil
+        @selinux = 'enforcing'
+        @stork = configuration ? configuration.server : 'localhost'
+        
+        @pre_snippets = Array.new
+        @post_snippets = Array.new
+        @interfaces = Array.new
+        @run_list = Array.new
+        @repos = Array.new
+        @packages = default_packages
+        
+        @timezone = Timezone.new("America/Los_Angeles")
+        @firewall = Firewall.new # get from config
+        @password = Password.new
+      end
+
+      def hashify
+        attrs = {}
+        attrs['name'] = name
+        
+        attrs['distro'] = distro ? distro.name : ''
+        attrs['template'] = template ? template.name : ''
+        attrs['chef'] = chef ? chef.name : ''
+
+        attrs['layout'] = layout.hashify
+        attrs['interfaces'] = interfaces.map{|i| i.hashify}
+        attrs['pre_snippets'] = pre_snippets.map{|s| s.name}
+        attrs['post_snippets'] = post_snippets.map{|s| s.name}
+        
+        attrs['repos'] = repos.map{|r| r.name}
+        attrs['run_list'] = run_list
+        attrs['packages'] = packages
+        attrs['timezone'] = timezone.zone
+        attrs['selinux'] = selinux
+        attrs
+      end
+
+      def validate!
+        require_value(:layout)
+        require_value(:template)
+        require_value(:distro)
+        require_value(:layout)
+        require_value(:layout)
+      end
+
+      def default_packages
+        %w(
+          @core
+          curl
+          openssh-clients
+          openssh-server
+          finger
+          pciutils
+          yum
+          at
+          acpid
+          vixie-cron
+          cronie-noanacron
+          crontabs
+          logrotate
+          ntp
+          ntpdate
+          tmpwatch
+          rsync
+          mailx
+          which
+          wget
+          man
+        )
+      end
+
+      def deploy
+        Stork::Deploy::Kickstart.new(self, configuration)
+      end
+
+      class HostDelegator < Stork::Resource::Delegator
+        def layout(value, &block)
+          if block_given?
+            delegated.layout = Layout.build(value, &block)
+          else
+            delegated.layout = collection.layouts.get(value)
+          end
+        end
+
+        def template(value)
+          template = collection.templates.get(value)
+          unless template
+            fail SyntaxError, "The #{value} template was not found"
+          end
+          delegated.template = template
+        end
+
+        def chef(value, &block)
+          if block_given?
+            delegated.chef = Chef.build(value, &block)
+          else
+            delegated.chef = collection.chefs.get(value)
+          end
+        end
+
+        def pxemac(value)
+          delegated.pxemac = value
+        end
+
+        def stork(value)
+          delegated.stork = value
+        end
+
+        def pre_snippet(value)
+          snippet = collection.snippets.get(value)
+          unless snippet
+            fail SyntaxError, "The #{value} snippet was not found"
+          end
+          delegated.pre_snippets << snippet
+        end
+
+        def post_snippet(value)
+          snippet = collection.snippets.get(value)
+          unless snippet
+            fail SyntaxError, "The #{value} snippet was not found"
+          end
+          delegated.post_snippets << snippet
+        end
+
+        def interface(value, &block)
+          delegated.interfaces << Interface.build(value, collection: collection, &block)
+        end
+
+        def distro(value, &block)
+          if block_given?
+            delegated.distro = Distro.build(value, &block)
+          else
+            delegated.distro = collection.distros.get(value)
+          end
+        end
+
+        def firewall(&block)
+          unless block_given?
+            fail SyntaxError, 'Firewall requires a block'
+          end
+          delegated.firewall = Firewall.build(&block)
+        end
+
+        def password(&block)
+          unless block_given?
+            fail SyntaxError, 'Password requires a block'
+          end
+          delegated.password = Password.build(&block)
+        end
+
+        def selinux(value)
+          delegated.selinux = value.to_s
+        end
+
+        def run_list(value)
+          if value.is_a?(String)
+            list = value.split(',')
+          else
+            list = value
+          end
+          delegated.run_list |= list
+        end
+
+        def repo(name, args = {})
+          delegated.repos << Repo.build(name, args)
+        end
+
+        def package(name)
+          delegated.packages << name
+        end
+      end
+
+      alias_method :id, :name
+    end
+  end
+end