foreman-architect 0.1.0

data/bin/architect

@@ -0,0 +1,147 @@
+#!/usr/bin/env ruby
+#
+# The Architect - design and plan virtual machine environments
+# 
+# Author:	Mark Heily <mark.heily@bronto.com>
+# 
+
+require 'optparse'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'rubygems'
+require 'bundler/setup'
+
+require 'logger'
+require 'yaml'
+require 'pp'
+require 'architect'
+
+log = Logger.new(STDERR)
+log.level = Logger::WARN
+
+# Parse command line options
+options = {
+  :action => nil,
+  :dry_run => false,
+  :start => false,      # If true, the VMs will be powered on after they are created
+  :verbose => 0,
+}
+op = OptionParser.new do |opts|
+  opts.banner = "Usage: architect [options] <path to plan>"
+
+  opts.on("--design", "Design a new plan") do
+    options[:action] = :design
+  end
+
+  opts.on("--execute", "Execute a plan") do
+    options[:action] = :execute
+  end
+
+  opts.on("--validate", "Validate a plan") do
+    options[:action] = :validate
+  end
+
+  opts.on("--dry-run", "Say what will be done, but do not make any changes") do
+    options[:dry_run] = true
+  end
+
+  opts.on("--[no-]start", "Start instances after they are created. [default: true]") do |val|
+    options[:start] = val
+  end
+
+  opts.on("--report-capacity", "Display a capacity report") do
+    options[:action] = :report
+    options[:report_type] = :capacity
+  end
+
+  opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+    options[:verbose] = v
+    log.level = Logger::DEBUG
+  end
+end
+op.parse!
+
+config = Architect::Config.new
+
+case options[:action]
+when :design
+  Architect::Designer.create_plan
+when :validate
+  Architect::Plan.new(ARGV[0])
+when :report
+  require 'architect/report'
+  report = Architect::Report.new
+  case options[:report_type]
+  when :capacity
+    puts report.capacity
+  else
+    raise ArgumentError, 'Invalid report type'
+  end
+when :deploy
+  _deploy
+else
+  puts "ERROR: You must specify a valid action"
+  system "#{$0} --help"
+end
+
+
+# TEMPORARY: refactor this into Plan#deploy
+def _deploy
+  require 'ForemanVM'
+
+  if ARGV.empty?
+    puts "ERROR: You must specify at least one plan\n" + op.help
+    exit 1
+  end
+
+  # Build a list of all plans
+  plans = []
+  ARGV.each do |arg|
+    if File.directory? arg
+      plans.concat(Dir.glob(arg + '/*'))
+    else
+      plans.push arg
+    end
+  end
+
+  raise 'No plans found' if plans.empty?
+
+  # Process each plan
+  plans.each do |plan|
+    log.info "Processing #{plan}"
+
+    # Read the design specification
+    manifest = YAML.load(File.open(plan))
+    #pp manifest
+
+    # Create a virtual machine for each instance listed in the specification
+    manifest['instances'].each do |instance|
+      # Coerce scalar instances into hashes
+      if instance.kind_of? String
+        instance = { instance.dup => {} }
+      end
+
+      instance.each do |name, custom_spec|
+
+        # Create a new spec based on the 'defaults' section of the manifest,
+        # and then apply the custom fields for this instance.
+        spec = manifest['defaults'].dup
+        spec['name'] = name
+        spec.merge! custom_spec
+        spec['fqdn'] = spec['name'] + '.' + spec['domain']
+        spec['instance_type'] ||= 'virtual'
+        pp spec if log.level == Logger::DEBUG
+
+        if architect.instance_exists? fqdn
+          puts "An instance named #{fqdn} exists; skipping" if log.level == Logger::DEBUG
+        else
+          # Build the instance
+          architect.build(spec)
+        end
+      end
+    end
+  end
+  exit 0
+end
+

data/bin/foreman-vm

@@ -0,0 +1,50 @@
+#!/usr/bin/ruby -w
+#
+# Build or rebuild a virtual machine using the Foreman API
+#
+# Author:	Mark Heily <mark.heily@bronto.com>
+#
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'rubygems'
+
+require 'ForemanVM'
+
+STDOUT.sync = true
+
+vm = ForemanVM.new
+vm.parse_options
+
+ARGV.each do |arg|
+  vm.name = arg
+
+  case vm.action
+  when 'rebuild'
+    vm.rebuild
+  when 'delete'
+    vm.delete
+  when 'create'
+    vm.create
+  when 'create-storage'
+    vm.create_storage
+  when 'stop'
+    vm.stop
+  when 'start'
+    vm.start
+  when 'enable-libgfapi'
+    vm.enable_libgfapi
+  when 'disable-libgfapi'
+    vm.disable_libgfapi
+  when 'dumpxml'
+    vm.dumpxml
+  when 'monitor-boot'
+    vm.monitor_boot
+  when 'console'
+    guest = arg
+    guest += vm.config.domain unless guest =~ /\./
+    vm.console.attach(guest)
+  else
+    raise 'Need to specify an action: rebuild, build, etc.'
+  end
+end

data/bin/worker.rb

@@ -0,0 +1,101 @@
+#!/usr/bin/ruby
+
+require 'logger'
+require 'yaml'
+require 'pp'
+require 'pathname'
+
+require 'rubygems'
+require 'beaneater'
+require 'daemons'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'ForemanVM'
+
+# Based on:
+# http://www.jstorimer.com/blogs/workingwithcode/7766093-daemon-processes-in-ruby
+def daemonize_app
+  exit if fork
+  Process.setsid
+  exit if fork
+  STDIN.reopen "/dev/null"
+  STDOUT.reopen "/dev/null", "a" 
+  STDERR.reopen "/dev/null", "a" 
+end
+
+#
+# MAIN()
+#
+
+if ARGV.include? '--daemon'
+  daemonize_app 
+  logfile = File.dirname(__FILE__) + '/../log/worker.log'
+  log = Logger.new(logfile, 10, 1024000)
+  log.info 'started a background worker process'
+else 
+  log = Logger.new(STDERR)
+  log.info 'started a foreground worker process'
+end
+
+if ARGV.include? '--debug'
+  log.level = Logger::DEBUG
+end
+
+
+# DEADWOOD: should use #clear method instead
+### Kill any buried jobs
+##if config['reap_buried_jobs']
+##  while tube.peek(:buried)
+##    log.info tube.stats
+##    tube.kick(1)
+##    job = tube.reserve 
+##    log.info 'discarding job for ' + job.body
+##  end
+##end
+
+wq = ForemanAP::Workqueue.new
+
+wq.process_all_jobs do |rec|
+  begin
+
+  raise 'user is required' unless rec.has_key?('user')
+  raise 'action is required' unless rec.has_key?('action')
+  raise 'invalid API version' unless rec['api_version'] == 1
+  raise 'invalid user' unless rec['user'] =~ /^([a-zA-Z0-9_.]+)$/m
+  raise 'invalid action' unless rec['action'] =~ /^([a-zA-Z0-9_.]+)$/m
+
+  hostname = rec['buildspec']['name'] or raise 'name is required'
+  domain = rec['buildspec']['domain'] or raise 'domain is required'
+
+  log.info("processing a #{rec['action']} job for hostname #{hostname}: #{rec.inspect}")
+  
+    fvm = ForemanVM.new
+    case rec['action']
+    when 'create'
+      fvm.name = hostname
+      fvm.buildspec = rec['buildspec']
+      fvm.create
+    when 'rebuild'
+      fvm.name = hostname + '.' + domain
+      fvm.buildspec = rec['buildspec']
+      fvm.rebuild
+    when 'destroy'
+      fvm.name = hostname + '.' + domain
+      fvm.delete
+    when 'snapshot-create'
+      fvm.snapshot_create
+    when 'snapshot-revert'
+      fvm.snapshot_revert
+    else
+      log.error "invalid action: #{action}"
+      raise "invalid action: #{action}"
+    end
+    log.info("job for #{hostname} is complete")
+    puts "done"
+  rescue => e
+    log.error("job for #{hostname} failed")
+    log.error e.inspect
+    log.error e.backtrace
+  end
+end

data/lib/architect.rb

@@ -0,0 +1,49 @@
+class Architect
+  require 'bundler/setup'
+  require 'architect/config'
+  require 'architect/designer'
+  require 'architect/log'
+  require 'architect/plan'
+  require 'architect/plugin_manager'
+  # FIXME: causes slowdown due to libvirt connection setup
+  #require 'architect/report'
+
+  require 'pp'
+
+  attr_accessor :config
+
+  def plugins
+    @plugins ||= Architect::PluginManager.new(@config.to_hash[:plugins])
+  end
+
+  def initialize(opts = default_options)
+    @config = Architect::Config.new(opts[:conffile])
+    @plugins = nil   # PluginManager, initialized on-demand
+  end
+
+  # Build an instance based on a specification
+  def build(spec)
+   builder(spec).build(spec)
+  end
+
+  # Return the appriate Builder object for an instance
+  def builder(spec)
+    case spec[:instance_type]
+    when 'virtual'
+      require 'architect/builder/virtual'  # Slow, so load it on demand
+      @vm_builder ||= VirtualMachineBuilder.new
+    when 'physical'
+      require 'architect/builder/physical'
+      @physical_builder ||= PhysicalMachineBuilder.new
+    else
+      pp spec
+      raise 'Unsupported instance type'
+    end
+  end
+
+  def default_options
+   return({
+	conffile: nil,
+    })
+  end
+end

data/lib/architect/builder/physical.rb

@@ -0,0 +1,19 @@
+class Architect
+  # Build a physical machine
+  class PhysicalMachineBuilder
+
+    def initialize
+    end
+
+    # Return true if a physical machine named [+fqdn+] exists.
+    def exists?(fqdn)
+      raise 'FIXME'
+    end
+
+    # Build a physical machine
+    def build(spec)
+      pp spec
+      raise 'FIXME'
+    end
+  end
+end

data/lib/architect/builder/virtual.rb

@@ -0,0 +1,27 @@
+class Architect
+  # Build virtual machines
+  class VirtualMachineBuilder
+    require 'ForemanVM'
+
+    # Return true if a virtual machine named [+fqdn+] exists.
+    def self.exists?(fqdn)
+      ForemanVM.new.vm_exists? fqdn
+    end
+
+    # Build a virtual machine
+    def self.build(spec)
+      fqdn = spec['fqdn']
+
+        puts "Creating #{fqdn}"
+        if options[:dry_run]
+          puts '(skipping due to --dry-run)'
+          next
+        end
+        vm = ForemanVM.new
+        vm.name = spec['name']
+        vm.buildspec = spec
+        vm.create
+      end
+    end
+  end
+end

data/lib/architect/config.rb

@@ -0,0 +1,64 @@
+class Architect
+  # Parse the configuration file and ARGV variables
+  class Config
+    require 'facter'
+    require 'pp'
+
+    def to_hash
+      @config
+    end
+
+    def initialize(conffile = nil)
+      config = {
+        :domain => Facter['domain'].value,
+        :plugins => {},
+      }
+      if conffile.nil? or conffile.kind_of?(String)
+        conffile ||= File.dirname(__FILE__) + "/../../conf/architect.yaml"
+        conffile = File.realpath(conffile)
+        if File.exist?(conffile)
+          config.merge! parse(conffile)
+        else
+          raise "configuration file #{conffile} not found"
+        end
+      elsif conffile.kind_of?(Hash)
+        config.merge! symbolize(conffile)
+      else
+        raise ArgumentError
+      end
+      config.keys.each { |k| publish k }
+      @config = config
+    end
+
+    # TODO: find a better way to do this
+    def self.symbolize_hash(obj)
+      symbolize(obj)
+    end
+
+    private
+
+    # Given a nested hash, convert all keys from String to Symbol type
+    # Based on http://stackoverflow.com/questions/800122/best-way-to-convert-strings-to-symbols-in-hash
+    #
+    def symbolize(obj)
+      return obj.inject({}){|memo,(k,v)| memo[k.to_sym] =  symbolize(v); memo} if obj.is_a? Hash
+      return obj.inject([]){|memo,v    | memo           << symbolize(v); memo} if obj.is_a? Array
+      return obj
+    end
+
+    # Parse a configuration file and return a Hash
+    def parse(path)
+      # FIXME: want to disallow group-readable also
+      raise "Insecure permissions on #{path}; please chmod to 0600" \
+	if File.stat(path).world_readable? 
+      symbolize(YAML.load_file(path))
+    end
+
+    # Given a key, create a read-only accessor method
+    def publish(key)
+      self.class.class_eval do
+        define_method(key.to_sym) { @config[key.to_sym] }
+      end
+    end
+  end
+end