foreman-architect 0.1.0

data/lib/architect/designer.rb

@@ -0,0 +1,73 @@
+#
+# Create a plan
+#
+# Author:	Mark Heily <mark.heily@bronto.com>
+# 
+class Architect
+  class Designer
+
+    require 'yaml'
+    require 'pp'
+    
+    def self.create_plan
+      questions = {
+        'environment' => 'Puppet environment',
+        'hostgroup'   => 'Foreman hostgroup',
+        'domain'     	=> 'DNS domain',
+        'subnet'	=> 'Foreman subnet',
+        'network_interface' => 'libvirt network interface',
+        'cpus'	=> 'Number of virtual CPUs',
+        'memory'	=> 'Amount of memory',
+        'disk_capacity' => 'Disk sizes; separate multiple disks with a comma',
+        'storage_pool' => 'libvirt storage pool',
+        'owner' => 'Foreman owner',
+        }
+      
+      defaults = {
+        'environment' => 'staging',
+        'hostgroup'   => 'staging/generic',
+        'domain'     	=> 'brontolabs.local',
+        'subnet'	=> 'staging_200',
+        'network_interface' => 'vnet0.200',
+        'cpus'	=> '1',
+        'memory'	=> '1G',
+        'disk_capacity' => '20G,20G',
+        'storage_pool' => 'gvol',
+        'owner' 	=> 'Systems Engineering',
+      }
+
+puts "\n------\n\nPlease provide default settings for the instances to be created.\n"
+
+      answers = { 'version' => 1, 'defaults' => {} }
+questions.each do |k,question|
+        puts "\n" + question + "  (default: " + defaults[k] + ")\n" 
+  printf ": "
+  res = STDIN.readline.chomp
+        res = defaults[k] if res.empty?
+  answers['defaults'][k] = res
+end
+
+puts "\n------\n\nEnter the name(s) of the instances to be created. Separate multiple instances with a comma. To specify a range, use (x..y) notation.\n"
+
+printf ": "
+answers['instances'] = []
+STDIN.readline.chomp.split(/\s*,\s*/).sort.each do |tok|
+  # Expand (x..y) notation
+  # This assumes a host naming convention of foo-prod-(x..y)
+  if tok =~ /\((\d+)\.\.(\d+)\)/
+    prefix = $`
+    r = Range.new($1,$2)
+    puts prefix
+    r.each { |x| answers['instances'].push(prefix + sprintf("%03d", x)) }
+  else
+    answers['instances'].push tok
+  end
+end
+
+
+      puts "\n\nHere is the plan you requested:\n\n"
+puts answers.to_yaml
+    end
+
+  end
+end

data/lib/architect/log.rb

@@ -0,0 +1,28 @@
+class Architect
+  class Log
+    require 'logger'
+
+    @@log = Logger.new(STDOUT)
+    @@log.level = Logger::WARN
+
+    def self.log
+      @@log
+    end
+
+    def self.level=(level)
+      @@log.level = level
+    end
+
+    def self.debug(message)
+      @@log.debug message
+    end
+
+    def self.info(message)
+      @@log.info message
+    end
+
+    def self.warn(message)
+      @@log.warn message
+    end
+  end
+end

data/lib/architect/plan.rb

@@ -0,0 +1,41 @@
+class Architect
+  class Plan
+
+    class InvalidPlanException < Exception
+    end
+
+    require 'yaml'
+
+    def initialize(path)
+      case path.kind_of?
+      when String
+        @yaml = YAML.load_file(path)
+      when Hash
+        @yaml = path
+      else
+        raise ArgumentError
+      end
+
+      validate
+    end
+
+    def to_s
+      @yaml
+    end
+
+    def instances
+      @yaml['instances']
+    end
+
+    private
+
+    def validate
+      problems = []
+      problems.push 'Version number missing' unless @yaml.has_key? 'version'
+      problems.push 'Wrong version number' unless @yaml['version'] == 1
+      unless problems.empty?
+        raise InvalidPlanException, "Errors found in the plan:\n  * " + problems.join("\n  * ")
+      end
+    end
+  end
+end

data/lib/architect/plugin.rb

@@ -0,0 +1,67 @@
+class Architect
+  # When the main Architect executable runs, it calls out to various
+  # Plugin objects to do additional work at various stages.
+  class Plugin
+    require 'architect/log'
+
+    # The name of the plugin
+    attr_reader :name
+    # The configuration settings for the plugin
+    attr_reader :config
+
+    # Called when the plugin is registered
+    def register
+      nil
+    end
+
+    # Parse a [+yaml+] configuration file
+    def configure(yaml)
+      nil
+    end
+
+    # Check to see if any actions need to be taken, and return
+    # a list of Architect::ChangeRequest objects for each proposed
+    # action
+    def check
+      []
+    end
+
+    # Ask questions during the design of a new plan; i.e. when
+    # architect --design is called.
+    def design
+      nil
+    end
+
+    # Parse a YAML plan file and perform validation.
+    def plan(yaml)
+      nil
+    end
+
+    # Execute the proposed actions based on the current plan.
+    def execute
+      nil
+    end
+
+    # A single instance of a machine (physical, virtual, or container)
+    class MachineInstance
+      def initialize(spec)
+        raise 'Method not implemented'
+      end
+
+      # Destroy the instance
+      def destroy
+        raise 'Method not implemented'
+      end
+
+      # Change the name of an instance to [+newname+]
+      def rename(newname)
+        raise 'Method not implemented'
+      end
+
+      # Return true if the instance exists within the realm of whatever the Plugin manages.
+      def exist?
+        raise 'Method not implemented'
+      end
+    end
+  end
+end

data/lib/architect/plugin/hello_world.rb

@@ -0,0 +1,46 @@
+require 'architect/plugin'
+
+# A sample plugin to say "hello world" at every opportunity
+class HelloWorldPlugin < Architect::Plugin
+
+  def initialize
+    @name = 'hello_world'
+  end
+
+  def configure(config_hash)
+    @config = OpenStruct.new({ hello: 'world', quiet: false }.merge(config_hash))
+    @quiet = @config[:quiet]
+    say 'hello_world: configured'
+  end
+
+  # Check to see if any actions need to be taken, and return
+  # a list of Architect::ChangeRequest objects for each proposed
+  # action
+  def check
+    say 'hello_world: checking'
+    []
+  end
+
+  # Ask questions during the design of a new plan; i.e. when
+  # architect --design is called.
+  def design
+    say 'hello_world: designing'
+  end
+
+  # Parse a YAML plan file and perform validation.
+  def plan(yaml)
+    say 'hello_world: planning'
+  end
+
+  # Execute the proposed actions based on the current plan.
+  def execute
+    say 'hello_world: executing'
+  end
+
+  private
+
+  # Print a message to the screen
+  def say(message)
+    puts message unless @quiet
+  end
+end

data/lib/architect/plugin/ldap_netgroup.rb

@@ -0,0 +1,114 @@
+require 'architect/plugin'
+
+# Manage host membership in the LDAP 'Security Netgroup' subtree
+class LDAPNetgroupPlugin < Architect::Plugin
+  require 'net/ldap'
+  require 'ostruct'
+
+  attr_accessor :log
+
+  def initialize
+    @name = 'ldap_netgroup'
+    @log = Architect::Log.log
+    #log.level = Logger::DEBUG
+  end
+
+  def configure(config_hash)
+    @config = OpenStruct.new({
+        host: nil,
+        port: nil,
+        bind_dn: nil,
+        bind_password: nil,
+        base_dn: nil,
+        nis_domain: nil,
+    }.merge(config_hash))
+
+    bind_to_server
+  end
+
+  # Delete a [+fqdn+] from all netgroups
+  def instance_delete(fqdn)
+    shortname = fqdn.gsub(/\..*/, '')
+    match = '(' + [shortname, '', config.nis_domain].join(',') + ')'
+    treebase = config.base_dn
+    filter = Net::LDAP::Filter.eq( 'nisnetgrouptriple', match )
+    attrs = [ "nisnetgrouptriple" ]
+
+    log.debug "searching for #{match}"
+    ldap.search(base: treebase, filter: filter, attributes: attrs, return_result: false) do |entry|
+           log.debug "deleting #{shortname} from #{entry.dn}"
+           dn = entry.dn
+           ops = [[:delete, :nisNetgroupTriple, match]]
+           ldap.modify :dn => dn, :operations => ops
+    end
+  end
+
+  # Rename an instance
+  def instance_rename(old_fqdn, new_fqdn)
+    instance_delete old_fqdn
+    instance_create new_fqdn
+  end
+
+  # Add a [+fqdn+] to netgroups
+  def instance_create(fqdn)
+    value = '(' + [fqdn.gsub(/\..*/, ''), '', config.nis_domain].join(',') + ')'
+    netgroup_membership(fqdn).each do |dn|
+      log.debug "adding #{value} to #{dn}"
+      ops = [[:add, :nisNetgroupTriple, value]]
+      ldap.modify :dn => dn, :operations => ops
+      check_operation_result
+    end
+  end
+
+  private
+
+  attr_accessor :ldap, :config
+
+  # Check the result of the previous LDAP operation
+  def check_operation_result
+    result = ldap.get_operation_result
+    return if result.code == 0
+    log.warn "LDAP operation failed with error code #{result.code}: " +
+      result.message
+  end
+
+  # Given a [+fqdn+] return a list of netgroups it should be a member of
+  # This relies on the 'description' field of the netgroup being populated
+  # with information like:   "role=foo,bar,baz", and assumes that the role
+  # is the first part of the FQDN.
+  #
+  def netgroup_membership(fqdn)
+    role = fqdn.gsub /\-.*/, ''
+    filter = Net::LDAP::Filter.eq( "description", "*role=*" )
+    log.debug "searching netgroups for role=#{role}"
+
+    # Put everything in the AllServers tree by default
+    result = ['cn=AllServers,' + config.base_dn]
+    ldap.search( :base => config.base_dn, :filter => filter ) do |entry|
+      begin
+        # Parse something like "role=foo,bar" out of the description
+        entry.description[0] =~ /role=([A-Za-z0-9_,]+)/
+        roles = $1.split /,/
+        log.debug "netgroup #{entry.dn} has roles #{roles.inspect}"
+        result.push entry.dn if roles.include? role
+      rescue => e
+        log.warn "unable to parse #{entry.description} for #{entry.dn}"
+        log.warn "#{e.inspect}"
+      end
+    end
+    result
+  end
+
+  def bind_to_server
+    ldap = Net::LDAP.new
+    ldap.host = config.host
+    ldap.port = config.port
+    ldap.auth config.bind_dn, config.bind_password
+    if ldap.bind
+      log.debug "bound to #{ldap.host}:#{ldap.port} as #{config.bind_dn}"
+      @ldap = ldap
+    else
+      raise "Unable to connect to the LDAP server"
+    end
+  end
+end

data/lib/architect/plugin_manager.rb

@@ -0,0 +1,64 @@
+class Architect
+  class PluginManager
+    require 'ostruct'
+    require 'architect/plugin'
+
+    # The path to the configuration directory for plugins.
+    # Each plugin gets it's own configuration file with the same
+    # name as the plugin.
+    attr_accessor :pluginconfigdir
+
+    attr_reader :plugins
+
+    def initialize(config)
+      @config = config.to_hash
+      @pluginconfigdir = '/etc/architect/plugin.d/'
+      @log = Architect::Log.log
+      #log.level = Logger::DEBUG
+      @plugins = OpenStruct.new
+      plugindir =  File.dirname(__FILE__) + '/plugin'
+      log.debug "registering plugins in #{plugindir}"
+      Dir.glob("#{plugindir}/*.rb").each do |pluginfile|
+        load pluginfile
+      end
+      register_all_plugins
+      plugins.each do |plugin|
+        conffile = "#{pluginconfigdir}/#{plugin.name}.yaml"
+        if File.exist? conffile
+          plugin.configure Architect::Config.symbolize_hash YAML.load(conffile)
+        end
+      end
+    end
+
+    # Before the program exist, each plugin is unregistered.
+    # This gives it a chance to clean up.
+    def unregister_all
+      raise 'FIXME - STUB'
+    end
+
+    private
+
+    attr_accessor :log
+
+    def load(pluginfile)
+      log.debug "loading #{pluginfile}"
+      begin
+        require pluginfile
+      rescue
+        log.warn "plugin failed to load: #{pluginfile}"
+      end
+    end
+
+    # Instantiate all plugins
+    def register_all_plugins
+      ObjectSpace.each_object(Class) do |klass|
+        if klass < Architect::Plugin
+          plugin = klass.new
+          name = plugin.name.to_sym
+          @plugins[name] = plugin
+          log.debug "registered #{klass} as #{name}"
+        end
+      end
+    end
+  end
+end

data/lib/architect/report.rb

@@ -0,0 +1,67 @@
+class Architect
+  class Report
+
+    require 'ForemanVM'
+    require 'pp'
+
+    include FVMUtil
+
+    def initialize
+      @fvm = ForemanVM.new
+    end
+
+    # Show the current capacity of the hypervisor cluster
+    def capacity
+      summary = {
+         :host => {},
+         :cluster => {
+           :cpu_count => 0,
+           :vcpu_count => 0,
+           :allocated_memory => 0,
+           :total_memory => 0,
+         }
+      }
+      @fvm.cluster.members2.each do |host|
+        total_memory = host.memory
+        cpu_count = host.cpus
+        allocated_memory = 0
+        vcpu_count = 0
+
+        host.domains2.each do |domain|
+          vcpu_count += domain.vcpu_count
+          allocated_memory += domain.memory
+        end
+
+        summary[:host][shortname(host.hostname)] = {
+             :allocated_memory => allocated_memory,
+             :total_memory => total_memory,
+             :vcpu_count => vcpu_count,
+             :cpu_count => cpu_count,
+        }
+      end  
+
+      # Compute the cluster-wide totals
+      summary[:host].values.each do |host|
+        summary[:cluster].keys.each do |item|
+           summary[:cluster][item] += host[item]
+         end
+      end
+      #pp summary[:cluster] ; raise 'DEBUG'
+
+      cluster = summary[:cluster]
+      used_mem_pct = 100 * (cluster[:allocated_memory].to_f / cluster[:total_memory].to_f)
+      free_mem = cluster[:total_memory] - cluster[:allocated_memory]
+      printf "Memory: %d%% allocated, %s free, %s total\n", 
+		used_mem_pct, 
+		gigabytes(free_mem),
+		gigabytes(cluster[:total_memory])
+
+      used_cpu_pct = 100 * (cluster[:vcpu_count].to_f / cluster[:cpu_count].to_f)
+      printf "CPU: %d%% allocated, %d vCPUs running on %d CPUs\n", 
+	used_cpu_pct,
+	cluster[:vcpu_count],
+	cluster[:cpu_count]
+    end
+
+  end
+end