stork 0.1.0.pre

data/lib/stork/resource/interface.rb

@@ -0,0 +1,125 @@
+module Stork
+  module Resource
+    class Interface < Base
+      attr_accessor :ethtool
+      attr_accessor :ip
+      attr_accessor :mtu
+      attr_accessor :bootproto
+      attr_accessor :onboot
+      attr_accessor :ipv4
+      attr_accessor :ipv6
+      attr_accessor :dns
+      attr_accessor :defroute
+      attr_accessor :network
+
+      def setup
+        @network = Network.new
+        @bootproto = :dhcp
+        @ip = nil
+        @mtu = nil
+        @onboot = true
+        @ipv4 = true
+        @ipv6 = false
+        @defroute = true
+        @ethtool = nil
+      end
+
+      def validate!
+
+      end
+
+      def netmask
+        network.netmask
+      end
+
+      def gateway
+        network.gateway
+      end
+
+      def nameservers
+        network.nameservers
+      end
+
+      def search_paths
+        network.search_paths
+      end
+
+      def noipv4
+        !ipv4
+      end
+
+      def noipv6
+        !ipv6
+      end
+
+      def nodns
+        !dns
+      end
+
+      def nodefroute
+        !defroute
+      end
+
+      def static?
+        @bootproto == :static
+      end
+
+      def hashify
+        {
+          'ip' => ip,
+          'bootproto' => bootproto,
+          'netmask' => netmask,
+          'gateway' => gateway,
+          'nameservers' => nameservers,
+          'search_paths' => search_paths
+        }
+      end
+
+      alias_method :device, :name
+
+      class InterfaceDelegator < Stork::Resource::Delegator
+        flag :onboot
+        flag :ipv4
+        flag :ipv6
+        flag :dns
+        flag :defroute
+
+        def ethtool(ethtool)
+          delegated.ethtool = ethtool
+        end
+
+        def ip(ip)
+          delegated.ip = ip
+        end
+
+        def mtu(mtu)
+          delegated.mtu = mtu
+        end
+
+        def bootproto(bootproto)
+          delegated.bootproto = bootproto
+        end
+
+        def network(network)
+          delegated.network = get_collection_item(:network, network)
+        end
+
+        def netmask(netmask)
+          delegated.network.netmask = netmask
+        end
+
+        def gateway(gateway)
+          delegated.network.gateway = gateway
+        end
+
+        def nameserver(nameserver)
+          delegated.network.nameservers << nameserver
+        end
+
+        def search_path(search_path)
+          delegated.network.search_paths << search_path
+        end
+      end
+    end
+  end
+end

data/lib/stork/resource/layout.rb

@@ -0,0 +1,50 @@
+module Stork
+  module Resource
+    class Layout < Base
+      attr_accessor :zerombr
+      attr_accessor :clearpart
+      attr_accessor :partitions
+      attr_accessor :volume_groups
+      # attr_accessor :raid_groups
+
+      def setup
+        @zerombr = false
+        @clearpart = false
+        @partitions = Array.new
+        @volume_groups = Array.new
+      end
+
+      def validate!
+        if partitions.empty?
+          fail SyntaxError, 'You must supply a partition block'
+        end
+      end
+
+      def hashify
+        {
+          'partitions' => partitions.map{|p| p.hashify},
+          'volume_groups' => volume_groups.map{|v| v.hashify}
+        }
+      end
+
+      class LayoutDelegator < Stork::Resource::Delegator
+        flag :zerombr
+        flag :clearpart
+
+        def partition(name, options = {}, &block)
+          fail SyntaxError, 'You must supply a block to partition' unless block_given?
+          @delegated.partitions << Partition.build(name, options, &block)
+        end
+
+        alias_method :part, :partition
+
+        def volume_group(name, options = {}, &block)
+          fail SyntaxError, 'You must supply a block to volume_group' unless block_given?
+          @delegated.volume_groups << VolumeGroup.build(name, options, &block)
+        end
+
+        alias_method :volgroup, :volume_group
+      end
+    end
+  end
+end

data/lib/stork/resource/logical_volume.rb

@@ -0,0 +1,49 @@
+module Stork
+  module Resource
+    class LogicalVolume < Base
+      attr_accessor :path
+      attr_accessor :size
+      attr_accessor :type
+      attr_accessor :primary
+      attr_accessor :grow
+      attr_accessor :recommended
+
+      def setup
+        @size = 1
+        @type = 'ext4'
+        @grow = false
+        @recommended = true
+        @path = '/'
+      end
+
+      def hashify
+        {
+          'path' => path,
+          'size' => size,
+          'type' => type,
+          'primary' => primary,
+          'grow' => grow,
+          'recommended' => recommended
+        }
+      end
+
+      class LogicalVolumeDelegator < Stork::Resource::Delegator
+        flag :grow
+        flag :recommended
+
+        def path(path)
+          delegated.path = path
+        end
+
+        def size(size)
+          delegated.size = size
+          delegated.recommended = false
+        end
+
+        def type(type)
+          delegated.type = type
+        end
+      end
+    end
+  end
+end

data/lib/stork/resource/network.rb

@@ -0,0 +1,36 @@
+module Stork
+  module Resource
+    class Network < Base
+      attr_accessor :netmask
+      attr_accessor :gateway
+      attr_accessor :nameservers
+      attr_accessor :search_paths
+
+      def setup
+        @netmask = "255.255.255.0"
+        @gateway = nil
+        @nameservers = Array.new
+        @search_paths = Array.new
+      end
+
+      class NetworkDelegator < Stork::Resource::Delegator
+        def netmask(netmask)
+          delegated.netmask = netmask
+        end
+
+        def gateway(gateway)
+          delegated.gateway = gateway
+        end
+
+        def nameserver(nameserver)
+          delegated.nameservers << nameserver
+        end
+
+        def search_path(search_path)
+          delegated.search_paths << search_path
+        end
+      end
+
+    end
+  end
+end

data/lib/stork/resource/partition.rb

@@ -0,0 +1,47 @@
+module Stork
+  module Resource
+    class Partition < Base
+      attr_accessor :size
+      attr_accessor :type
+      attr_accessor :primary
+      attr_accessor :grow
+      attr_accessor :recommended
+
+      def setup
+        @size = 1
+        @type = 'ext4'
+        @grow = false
+        @primary = false
+        @recommended = false
+      end
+
+      def hashify
+        {
+          'path' => path,
+          'size' => size,
+          'type' => type,
+          'primary' => primary,
+          'grow' => grow,
+          'recommended' => recommended
+        }
+      end
+
+      alias_method :path, :name
+
+      class PartitionDelegator < Stork::Resource::Delegator
+        flag :primary
+        flag :grow
+        flag :recommended
+
+        def size(size)
+          delegated.size = size
+          delegated.recommended = false
+        end
+
+        def type(type)
+          delegated.type = type
+        end
+      end
+    end
+  end
+end

data/lib/stork/resource/password.rb

@@ -0,0 +1,26 @@
+module Stork
+  module Resource
+    class Password
+      def random_encrypted_password
+        salt = rand(36**8).to_s(36)
+        random_password.crypt('$6$' + salt)
+      end
+
+      def random_password
+        SecureRandom.urlsafe_base64(40)
+      end
+
+      def value
+        random_encrypted_password
+      end
+
+      def locked?
+        false
+      end
+
+      def encrypted
+        true
+      end
+    end
+  end
+end

data/lib/stork/resource/repo.rb

@@ -0,0 +1,29 @@
+module Stork
+  module Resource
+    class Repo < Base
+      attr_accessor :baseurl
+      attr_accessor :mirrorlist
+
+      def setup
+        @baseurl = options.key?(:baseurl) ? options[:baseurl] : nil
+        @mirrorlist = options.key?(:mirrorlist) ? options[:mirrorlist] : nil
+      end
+
+      def validate!
+        unless baseurl || mirrorlist
+          fail SyntaxError, 'One of baseurl or mirrorlist must be specified.'
+        end
+
+        if baseurl && mirrorlist
+          fail SyntaxError, 'You may use only baseurl or mirrorlist but not both.'
+        end
+      end
+
+      def is_local?
+        !(baseurl && mirrorlist)
+      end
+
+      class RepoDelegator < Stork::Resource::Delegator ; end
+    end
+  end
+end

data/lib/stork/resource/snippet.rb

@@ -0,0 +1,20 @@
+module Stork
+  module Resource
+    class Snippet
+      attr_reader :name
+      attr_reader :content
+
+      def initialize(path)
+        @name = File.basename(path, '.erb')
+        @content = read_content(path)
+      end
+
+      alias_method :id, :name
+
+    private
+      def read_content(path)
+        File.read(path)
+      end
+    end
+  end
+end

data/lib/stork/resource/template.rb

@@ -0,0 +1,24 @@
+module Stork
+  module Resource
+    class Template
+      attr_reader :name
+      attr_reader :content
+
+      def initialize(path)
+        @name = File.basename(path, '.ks.erb')
+        @content = read_content(path)
+      end
+
+      def hashify
+        {'name' => name}
+      end
+
+      alias_method :id, :name
+
+    private
+      def read_content(path)
+        File.read(path)
+      end
+    end
+  end
+end

data/lib/stork/resource/timezone.rb

@@ -0,0 +1,31 @@
+module Stork
+  module Resource
+    class Timezone < Base
+      attr_accessor :utc
+      attr_accessor :ntp
+      attr_accessor :ntpservers
+
+      def setup
+        @utc = false
+        @ntp = true
+        @ntpservers = %w(
+          0.pool.ntp.org
+          1.pool.ntp.org
+          2.pool.ntp.org
+          3.pool.ntp.org
+        )
+      end
+
+      alias_method :zone, :name
+
+      class TimezoneDelegator < Stork::Resource::Delegator
+        flag :utc
+        flag :ntp
+
+        def ntpserver(ntpserver)
+          delegated.ntpservers << ntpserver
+        end
+      end
+    end
+  end
+end

data/lib/stork/resource/volume_group.rb

@@ -0,0 +1,31 @@
+module Stork
+  module Resource
+    class VolumeGroup < Base
+      attr_reader :name
+      attr_accessor :partition
+      attr_accessor :logical_volumes
+
+      def setup
+        @partition = options.key?(:part) ? options[:part] : nil
+        @logical_volumes = Array.new
+      end
+
+      def hashify
+        {
+          'partition' => partition,
+          'logical_volumes' => logical_volumes.map{|l| l.hashify}
+        }
+      end
+
+      class VolumeGroupDelegator < Stork::Resource::Delegator
+        def partition(partition)
+
+        end
+
+        def logical_volume(name, options = {}, &block)
+          @delegated.logical_volumes << LogicalVolume.build(name, options, &block)
+        end
+      end
+    end
+  end
+end

data/lib/stork/resources.rb

@@ -0,0 +1,17 @@
+require 'stork/resource/delegator'
+require 'stork/resource/base'
+require 'stork/resource/chef'
+require 'stork/resource/distro'
+require 'stork/resource/partition'
+require 'stork/resource/logical_volume'
+require 'stork/resource/volume_group'
+require 'stork/resource/layout'
+require 'stork/resource/network'
+require 'stork/resource/interface'
+require 'stork/resource/firewall'
+require 'stork/resource/password'
+require 'stork/resource/timezone'
+require 'stork/resource/snippet'
+require 'stork/resource/template'
+require 'stork/resource/repo'
+require 'stork/resource/host'

data/lib/stork/server/application.rb

@@ -0,0 +1,127 @@
+require 'sinatra'
+
+module Stork
+  module Server
+    class Application < Sinatra::Base
+      configure do
+        enable :logging
+        mime_type :plain, 'text/plain'
+        mime_type :json, 'application/json'
+      end
+
+      before do
+        logger.datetime_format = '%Y/%m/%d @ %H:%M:%S '
+        logger.level = Logger::INFO
+      end
+
+      get '/' do
+        info 'GET /'
+        json_halt 200, 200, "Stork Version #{VERSION} - #{CODENAME}"
+      end
+
+      get '/api/v1/hosts' do
+        h = {'hosts' => hosts.hashify}
+        json_halt_ok_with_content(h.to_json)
+      end
+
+      get '/api/v1/host/:host' do |host|
+        h = hosts.get(host)
+        json_halt_ok_with_content(h.hashify.to_json)
+      end
+
+      get '/host/:host' do |host|
+        info "#{host} requested kickstart"
+
+        h = hosts.get(host)
+
+        if h
+          # 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
+          json_halt_not_found
+        end
+      end
+
+      get '/host/:host/installed' do |host|
+        info "#{host} has notified completed install"
+        h = hosts.get(host)
+
+        if h
+          set_localboot(h)
+          json_halt_ok
+        else
+          json_halt_not_found
+        end
+      end
+
+      get '/host/:host/install' do |host|
+        info "install requested for #{host}"
+        h = hosts.get(host)
+
+        if h
+          set_install(h)
+          json_halt_ok
+        else
+          json_halt_not_found
+        end
+      end
+
+      not_found do
+        json_halt_not_found
+      end
+
+      helpers do
+        def hosts
+          @hosts ||= settings.collection.hosts
+        end
+
+        def config
+          @config ||= settings.config
+        end
+
+        def set_localboot(host)
+          pxe(host).localboot
+        end
+
+        def set_install(host)
+          pxe(host).install
+        end
+
+        def pxe(host)
+          Stork::PXE.new(host, host.stork, config.port)
+        end
+
+        def info(msg)
+          logger.info "[#{request.ip}] INFO: #{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}\" }"
+        end
+
+        def json_halt_ok
+          content_type :json
+          json_halt 200, 200, 'OK'
+        end
+
+        def json_halt_ok_with_content(content)
+          content_type :json
+          halt 200, { 'Content-Type' => 'application/json' }, content
+        end
+
+        def json_halt_internal_error
+          content_type :json
+          json_halt 500, 500, 'Internal error'
+        end
+
+        def json_halt_not_found
+          content_type :json
+          json_halt 404, 404, 'not found'
+        end
+      end
+    end
+  end
+end

data/lib/stork/server/control.rb

@@ -0,0 +1,38 @@
+require 'sinatra'
+require 'json'
+require 'rack'
+require 'thin'
+
+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
+        else
+          puts '!!! Running in test mode'
+        end
+        @thin.start
+      end
+
+      def self.stop(configuration, collection)
+        puts 'Stoping the stork server.'
+        Thin::Server.kill(configuration.pid_file)
+      end
+
+      def self.restart(configuration, collection)
+        stop(configuration, collection)
+        start(configuration, collection)
+      end
+    end
+  end
+end

data/lib/stork/version.rb

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

data/lib/stork.rb

@@ -0,0 +1,30 @@
+require 'erb'
+require 'json'
+require 'securerandom'
+
+require 'stork/version'
+require 'stork/configuration'
+require 'stork/collections'
+require 'stork/resources'
+
+require 'stork/builder'
+
+require 'stork/deploy/command'
+require 'stork/deploy/section'
+require 'stork/deploy/snippet_binding'
+require 'stork/deploy/kickstart_binding'
+require 'stork/deploy/install_script'
+
+require 'stork/pxe'
+
+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)
+end
+
+# Also make sure we allow a .stork/plugins dir