oscar 0.2.0alpha1

data/lib/oscar/environment.rb

@@ -0,0 +1,28 @@
+require 'oscar'
+
+class Oscar::Environment
+  attr_reader :networking
+  attr_reader :config
+
+  def initialize
+    @config     = Oscar::Config.new
+    @nodes = []
+  end
+
+  def run!
+    @networking = Oscar::Networking.new(@config.data["networking"])
+    nodes       = @config.all_node_configs
+
+    # TODO make sure that the master is provisioned before any agents.
+    nodes.each do |node_attrs|
+      node = Oscar::Node.new(node_attrs)
+      @networking.register(node)
+
+      @nodes << node
+    end
+
+    Vagrant::Config.run do |config|
+      @nodes.each { |node| node.define(config) }
+    end
+  end
+end

data/lib/oscar/networking.rb

@@ -0,0 +1,47 @@
+require 'oscar'
+require 'ipaddress'
+
+class Oscar::Networking
+
+  def initialize(yaml_config)
+
+    range       = yaml_config["pool"]
+    @domainname = yaml_config["domainname"]
+    @network = IPAddress.parse(range)
+
+    @pool  = []
+    @nodes = {}
+
+    @network.each_host { |h| @pool << h }
+    @iterator = @pool.each
+
+  end
+
+  def register(node)
+    next_addr = @iterator.next.to_s
+
+    node.networking = self
+    node.address    = next_addr
+
+    @nodes[next_addr] = node
+  end
+
+  def hosts_for(node)
+    arr = []
+
+    arr << ['127.0.0.1', ['localhost']]
+    arr << ['127.0.1.1', [node.name, "#{node.name}.#{@domainname}"]]
+
+    arr << ['::1', %w{ip6-localhost ip6-loopback}]
+
+    arr << ['fe00::0', ['ip6-localnet']]
+    arr << ['ff00::0', ['ip6-mcastprefix']]
+    arr << ['ff02::1', ['ip6-allnodes']]
+    arr << ['ff02::2', ['ip6-allrouters']]
+
+    @nodes.each_pair { |address, n| arr << [address, [n.name, "#{n.name}.#{@domainname}"]] }
+
+
+    arr
+  end
+end

data/lib/oscar/node.rb

@@ -0,0 +1,91 @@
+require 'oscar'
+require 'vagrant'
+
+require 'vagrant-hosts'
+
+class Oscar::Node
+
+  class << self
+    def addrole(name, &block)
+      @roles ||= {}
+      @roles[name] = block
+    end
+
+    def getrole(name)
+      @roles[name] if @roles
+    end
+  end
+
+  addrole(:base) do |node|
+    node.vm.box = @boxname
+
+    if @forwards
+      @forwards.each { |h| node.vm.forward_port h["source"], h["dest"] }
+    end
+
+    node.vm.network :hostonly, @address
+    # Add in optional per-node configuration
+    node.vm.box_url          = @boxurl if @boxurl
+    node.vm.boot_mode        = @gui    if @gui
+
+    host_entries = @networking.hosts_for(self)
+    #node.vm.provision :shell do |shell|
+    #  shell.inline = %{grep "#{entry}" /etc/hosts || echo "#{entry}" >> /etc/hosts}
+    #end
+
+    node.vm.provision :hosts do |h|
+      host_entries.each { |(address, aliases)| h.add_host address, aliases }
+    end
+
+    node.vm.provision :puppet_enterprise_bootstrap do |pe|
+      pe.role = @role if @role
+    end
+  end
+
+  addrole(:master) do |node|
+    # Manifests and modules need to be mounted on the master via shared folders,
+    # but the default /vagrant mount has permissions and ownership that conflicts
+    # with the master and pe-puppet. We mount these folders separately with
+    # loosened permissions.
+    node.vm.share_folder 'manifests', '/manifests', './manifests', :extra => 'fmode=644,dmode=755,fmask=022,dmask=022'
+    node.vm.share_folder 'modules',   '/modules',   './modules',   :extra => 'fmode=644,dmode=755,fmask=022,dmask=022'
+
+    # Boost RAM for the master so that activemq doesn't asplode
+    node.vm.customize([ "modifyvm", :id, "--memory", "1024" ])
+  end
+
+  attr_accessor :address
+  attr_writer :networking # Callback attribute for retrieving hosts
+
+  attr_reader :name, :boxname, :boxurl, :role
+  attr_reader :forwards # really?
+
+  def initialize(yaml_attrs)
+    @attrs = yaml_attrs
+
+    @name    = @attrs["name"]
+    @address = @attrs["address"]
+    @role    = @attrs["role"].intern if @attrs["role"]
+
+    @boxurl   = @attrs["boxurl"]
+    @boxname  = @attrs["boxname"]
+    @forwards = @attrs["forwards"]
+    @gui      = @attrs["gui"]
+  end
+
+  def define(config)
+
+    blk = lambda do |config|
+      config.vm.define @name do |node|
+
+        instance_exec(node, &(self.class.getrole(:base)))
+
+        if (blk = self.class.getrole(@role))
+          instance_exec(node, &blk)
+        end
+      end
+    end
+
+    blk.call(config)
+  end
+end

data/lib/oscar/schema.yaml

@@ -0,0 +1,73 @@
+---
+# Oscar kwalify schema
+
+type: map
+mapping:
+
+  "nodes":
+    type: seq
+    sequence:
+      -
+        type: map
+        mapping:
+          "name": { required: true }
+          "address": { required: false }
+
+          "boxname": &boxname
+            type: str
+          "boxurl": &boxurl
+            type: str
+          "role":
+            desc: "A node can have a role, that adds specific configuration for how it is going to be used."
+            type: str
+            enum: ["master", "console", "agent"]
+            default: "agent"
+
+          "profile":
+            desc: "A node can have a profile, which describes where the box came from."
+            type: str
+          "forwards": &forwards
+            type: seq
+            sequence:
+              -
+                type: map
+                mapping:
+                  "source":
+                    type: int
+                    required: true
+                  "dest":
+                    type: int
+                    required: true
+
+  "profiles":
+    desc: "A profile describes a box type, so what name it is and where to retrieve it from."
+    type: seq
+    sequence:
+      -
+        type: map
+        mapping:
+          "name":
+            required: true
+          "boxname": *boxname
+          "boxurl": *boxurl
+
+
+  "roles":
+    desc: "A role is the configuration needed for a node to do a specific role."
+    type: seq
+    sequence:
+      -
+        type: map
+        mapping:
+          name: { required: true }
+          "forwards": *forwards
+
+  # Network configuration for oscar, not applicable to any node.
+  "networking":
+    type: map
+    mapping:
+      "pool":
+        required: true
+      "domainname":
+        required: true
+

data/lib/oscar/version.rb

@@ -0,0 +1,3 @@
+module Oscar
+  VERSION = '0.2.0alpha1'
+end

data/lib/pe_build.rb

@@ -0,0 +1,13 @@
+require 'vagrant'
+
+module PEBuild
+  def self.archive_directory
+    File.expand_path(File.join(ENV['HOME'], '.vagrant.d', 'pe_builds'))
+  end
+end
+
+require 'pe_build/version'
+require 'pe_build/action'
+require 'pe_build/config'
+require 'pe_build/command'
+require 'pe_build/provisioners'

data/lib/pe_build/action.rb

@@ -0,0 +1,20 @@
+require 'vagrant'
+require 'vagrant/action/builder'
+require 'pe_build'
+
+module PEBuild::Action
+end
+
+require 'pe_build/action/download'
+require 'pe_build/action/unpackage'
+
+builder = Vagrant::Action::Builder.new do
+  use PEBuild::Action::Download
+end
+
+Vagrant.actions.register :download_pe_build, builder
+
+Vagrant.actions.register(:prep_build, Vagrant::Action::Builder.new do
+  use PEBuild::Action::Download
+  use PEBuild::Action::Unpackage
+end)

data/lib/pe_build/action/download.rb

@@ -0,0 +1,56 @@
+require 'pe_build'
+require 'pe_build/action'
+require 'vagrant'
+require 'fileutils'
+
+class PEBuild::Action::Download
+  # Downloads a PE build to a temp directory
+
+  def initialize(app, env)
+    @app, @env = app, env
+    load_variables
+  end
+
+  def call(env)
+    @env = env
+    perform_download
+    @app.call(@env)
+  end
+
+  private
+
+  # Determine system state and download a PE build accordingly.
+  #
+  # If we are applying actions within the context of a single box, then we
+  # should try to prefer and box level configuration options first. If
+  # anything is unset then we should fall back to the global settings.
+  def load_variables
+    if @env[:box_name]
+      @root     = @env[:vm].pe_build.download_root
+      @version  = @env[:vm].pe_build.version
+      @filename = @env[:vm].pe_build.version
+    end
+
+    @root     ||= @env[:global_config].pe_build.download_root
+    @version  ||= @env[:global_config].pe_build.version
+    @filename ||= @env[:global_config].pe_build.filename
+
+    @archive_path = File.join(PEBuild.archive_directory, @filename)
+  end
+
+  # @return [String] The full URL to download, based on the config
+  def url
+    [@root, @version, @filename].join('/')
+  end
+
+  def perform_download
+    if File.exist? @archive_path
+      @env[:ui].info "#{@filename} cached, skipping download."
+    else
+      FileUtils.mkdir_p PEBuild.archive_directory unless File.directory? PEBuild.archive_directory
+      cmd = %{curl -L -A "Vagrant/PEBuild (v#{PEBuild::VERSION})" -O #{url}}
+      @env[:ui].info "Executing '#{cmd}'"
+      Dir.chdir(PEBuild.archive_directory) { %x{#{cmd}} }
+    end
+  end
+end

data/lib/pe_build/action/unpackage.rb

@@ -0,0 +1,70 @@
+require 'vagrant'
+require 'pe_build/action'
+require 'fileutils'
+
+class PEBuild::Action::Unpackage
+  def initialize(app, env)
+    @app, @env = app, env
+    load_variables
+  end
+
+  def call(env)
+    @env = env
+    @extracted_dir = File.join(@env[:unpack_directory], destination_directory)
+    extract_build
+    @app.call(@env)
+  end
+
+  private
+
+  def load_variables
+    if @env[:box_name]
+      @root     = @env[:vm].pe_build.download_root
+      @version  = @env[:vm].pe_build.version
+      @filename = @env[:vm].pe_build.version
+    end
+
+    @root     ||= @env[:global_config].pe_build.download_root
+    @version  ||= @env[:global_config].pe_build.version
+    @filename ||= @env[:global_config].pe_build.filename
+
+    @archive_path = File.join(PEBuild.archive_directory, @filename)
+  end
+
+  # Sadly, shelling out is more sane than trying to use the facilities
+  # provided.
+  def extract_build
+    if File.directory? @extracted_dir
+      @env[:ui].info "#{destination_directory} already present, skipping extraction."
+    else
+      cmd = %{tar xf #{@archive_path} -C #{@env[:unpack_directory]}}
+      @env[:ui].info "Extracting #{@archive_path} to #{@env[:unpack_directory]}"
+      %x{#{cmd}}
+    end
+  rescue => e
+    # If anything goes wrong while extracting, nuke the extracted directory
+    # as it could be incomplete. If we do this, then we can ensure that if
+    # the extracted directory already exists then it will be in a good state.
+    @env[:ui].info "Removing possibly damaged installer directory '#{@extracted_dir}'"
+    FileUtils.rm_r @extracted_dir
+  end
+
+  # Determine the name of the top level directory by peeking into the tarball
+  def destination_directory
+    raise Errno::ENOENT, "No such file \"#{@archive_path}\"" unless File.file? @archive_path
+
+    firstline = nil
+    dir       = nil
+    dir_regex = %r[^(.*?)/]
+    IO.popen(%{tar -tf #{@archive_path}}) { |out| firstline = out.gets }
+
+    if firstline.nil? or firstline.empty?
+      raise "Could not get a directory listing from the installer tarfile #{File.basename @archive_path}"
+    elsif (match = firstline.match dir_regex)
+      dir = match[1]
+    else
+      raise "Could not determine the base directory name from #{firstline} - doesn't match #{dir_regex.to_s}"
+    end
+    dir
+  end
+end

data/lib/pe_build/command.rb

@@ -0,0 +1,31 @@
+require 'pe_build'
+require 'vagrant'
+
+class PEBuild::Command < Vagrant::Command::Base
+  def initialize(argv, env)
+    @argv, @env = argv, env
+
+    @main_args, @subcommand, @sub_args = split_main_and_subcommand(argv)
+
+    # Is this even remotely sane? Are we verging on cargo cult programming?
+    @subcommands = Vagrant::Registry.new
+
+    @subcommands.register('download') { PEBuild::Command::Download }
+    @subcommands.register('list')     { PEBuild::Command::List }
+  end
+
+  def execute
+    if @subcommand and (klass = @subcommands.get(@subcommand))
+      klass.new(@argv, @env).execute
+    elsif @subcommand
+      raise "Unrecognized subcommand #{@subcommand}"
+    else
+      PEBuild::Command::List.new(@argv, @env).execute
+    end
+  end
+end
+
+require 'pe_build/command/list'
+require 'pe_build/command/download'
+
+Vagrant.commands.register(:pe_build) { PEBuild::Command }