path: root/cloudmasterd/lib/cloudmasterd.rb

$: << File.dirname(File.expand_path(__FILE__))

gem 'reststop', '~> 0.2'

require 'yaml'
require 'fileutils'
require 'rubygems'
require 'picnic'
require 'reststop'
require 'everest'
require 'restr'
require 'xmlrpc/client'
require 'sqlite3'
require 'fastthread'
require 'open3'

Camping.goes :Cloudmasterd
Cloudmasterd.picnic!

module Cloudmasterd::Helpers
  class Syncer
    def self.run
      # Figure out the current amount of memory
      freemem = 0
      `func '*' call virt freemem`.split("\n").each{|mem| freemem = freemem + mem.to_i}

      memory = Cloudmasterd::Models::Memory.find(:all)
      if memory.empty? then
        Cloudmasterd::Models::Memory.create :free => freemem
      else
        memory[0].update_attribute(:free, freemem)
      end

      current_state = {}
      Open3.popen3("func '*' call virt state") do |stdin, stdout, stderr|
        # Parse out the hosts based on the func output (stripping off https:// and the port)
        hosts = stderr.read.split("\n").collect{|host| host.split(" ")[1].split(":")[1][2..-1]}

        # Parse out the machines that belong to each host and zip them together in a hash
        stdout.read.split("\n").each_with_index do |host, index|
          host[1..-2].split(", ").each do |machine|
            name, state = machine[1..-2].split(" ")
            current_state[name] = {:state => state, :cloud => hosts[index]} unless name == "Domain-0"
          end
        end
      end

      # Sync up the state for all the machines
      Cloudmasterd::Models::Machine.find(:all).each do |machine|
        if current_state.has_key?(machine.name) then
          # We have a current state match for this machine
          machine.update_attributes(:cloud => current_state[machine.name][:cloud], :state => current_state[machine.name][:state])

          # Delete the key so we can determine unaccounted for machines
          current_state.delete(machine.name)
        else
          # Not good - the machine in the DB isn't locateable
          machine.update_attribute(:state, "Missing")
        end
      end

      # We need to create an 'unknown' instance for all the remaining keys
      current_state.each do |name, machine|
        Cloudmasterd::Models::Machine.create :name => name, :email => "Unknown", :cloud => machine[:cloud], :state => machine[:state]
      end
    end
  end

  class Cobblerd
    def initialize(repo)
      @repo = repo
      @xmlrpc = XMLRPC::Client.new2("http://#{@repo}:25152")
      @token = @xmlrpc.call2("login", "cobbler", "password")[1]
    end

    def _call(method, *args)
      return @xmlrpc.call2(method, *args)[1]
    end

    def distros
      _call("get_distros", @token)
    end

    def profiles
      _call("get_profiles", @token)
    end

    def systems
      _call("get_systems", @token)
    end

    def repos
      _call("get_repos", @token)
    end

    def distro(name)
      _call("get_distro", name, @token)
    end

    def distro_for_koan(name)
      _call("get_distro_for_koan", name, @token)
    end

    def profile(name)
      _call("get_profile", name, @token)
    end
    
    def profile_for_koan(name)
      _call("get_profile_for_koan", name, @token)
    end

    def system(name)
      _call("get_system", name, @token)
    end

    def system_for_koan(name)
      _call("get_system_for_koan", name, @token)
    end

    def repo(name)
      _call("get_repo", name, @token)
    end
    
    def repo_for_koan(name)
      _call("get_repo_for_koan", name, @token)
    end

  end
end

module Cloudmasterd::Models
  class Memory < Base; end
  class Machine < Base; end

  class CreateTheBasics < V 1.0
    def self.up
      create_table :cloudmasterd_memory do |t|
        t.column :free,   :string,  :null => false, :limit => 255
      end
      create_table :cloudmasterd_machine do |t|
        t.column :name,   :string,  :null => false, :limit => 255
        t.column :email,  :string,  :null => false, :limit => 255
        t.column :cloud,  :string,  :null => false, :limit => 255
        t.column :state,  :string,  :null => false, :limit => 255
      end
    end
    def self.down
      drop_table :cloudmasterd_memory
      drop_table :cloudmasterd_machine
    end
  end
end
 
module Cloudmasterd::Controllers
  class Koan < REST 'koan'
    # Retrieve the cobbler profile for the given profile name
    def _get_cobbler_profile(system_name, repo) 
      cobblerd = Cloudmasterd::Helpers::Cobblerd.new(repo)
      cobbler_system = cobblerd.system(system_name)
      return cobblerd.profile(cobbler_system["profile"])
    end

    # Find the best host on which to create a VM
    def _get_best_host(disk_size, ram)
      return `func-find-resources -m #{ram}`.chomp()
    end

    # run the appropriate koan command to create the given "fqdn"
    # on the given "host" and "vol_group"
    def _koan(host, fqdn, repo)
      # Run the koan process
      output = `func "#{host}" call virt install #{repo} #{fqdn} True #{fqdn} /images`
      
      # Throw an exception if the process failed
      raise output unless $?.success?

      # Make the new host autostart
      `func "#{host}" call command run "ln -s /etc/xen/#{fqdn.split('.')[0]} /etc/xen/auto/"`
    end

    # POST /koan
    def create
      machine_fqdn = input.machine_fqdn
      repo = input.repo
      email = input.email

      cobbler_profile = _get_cobbler_profile(machine_fqdn, repo)
      @host = _get_best_host(cobbler_profile["virt_file_size"], cobbler_profile["virt_ram"])

      begin
        _koan(@host, machine_fqdn, repo)

        Machine.create :name => machine_fqdn, :email => email, :cloud => @host, :state => "Installing"
        render :_koan
      rescue Exception => e
        @exception = e
        render :_error
      end
    end

    def destroy(name)
      puts "Destroying image #{name}"
      Machine.find(:all, :conditions => "name = '#{name}'").each do |machine|
        # If the machine is missing, don't bother remotely trying to cleanup
        unless machine.state == "Missing" then
          # Destroy the virtual machine
          `func "#{machine.cloud}" call command run "virsh destroy #{machine.name}"`
          `func "#{machine.cloud}" call command run "virsh undefine #{machine.name}"`

          # Remove the auto start file if it exists
          `func "#{machine.cloud}" call command run "rm -rf /etc/xen/auto/#{machine.name}"`

          # Remove the image file
          `func "#{machine.cloud}" call command run "rm -rf /images/#{machine.name}-disk0"`
        end

        # Delete the DB record
        machine.destroy
      end
      redirect R(Cloud)
    end
  end

  class Cloud < REST 'cloud'
    def list
      @machines = {}
      Machine.find(:all, :select => "distinct email").map{|x| x.email}.each do |email|
        @machines[email] = Machine.find(:all, :conditions => "email = '#{email}'", :order => 'cloud')
      end

      @memory = Memory.find(:all)[0][:free]
      render :cloud
    end
  end
end

module Cloudmasterd::Views
  def initialize(*args)
    super(*args)
    @x = Builder::XmlMarkup.new(:indent => 1)
  end

  module HTML
    def layout
      html do
        head do
          title 'Everest Cloud Master Controller'
          #link :rel => 'stylesheet', :type => 'text/css', :href => self/'/styles.css', :media => 'screen'
        end
        body do
          div.content do
            self << yield
          end
        end
      end
    end

    def cloud
      div.memory! do
        h2 "Available cloud memory: #{@memory}"
      end

      div.machines! do
        @machines.keys.each do |email|
          div do
            h2 email
            table do
              tr do
                th 'Name'
                th 'Cloud Instance'
                th 'State'
                th ''
              end
              @machines[email].each do |machine|
                tr do
                  td machine.name
                  td machine.cloud
                  td machine.state
                  td do
                    form(:method => :delete, :action => R(Cloudmasterd::Controllers::Koan, "#{machine.name}")) do
                      input :type => :submit, :value => 'Destroy'
                    end
                  end
                end
              end
            end
          end
        end
      end
    end
 
    def _koan
      @host
    end

    def _error
      "ERROR: #{@exception.to_s}"
    end
  end
  default_format :HTML

  module YAML
    CONTENT_TYPE = 'text/plain'
    
    def layout
      yield
    end
  end

  module XML
    def layout
      yield
    end
  end
end

def Cloudmasterd.create
  ActiveRecord::Base.logger = Logger.new(STDOUT)
  ActiveRecord::Base.colorize_logging = true
  ActiveRecord::Base.pluralize_table_names = false

  ActiveRecord::Base.establish_connection(
    :adapter => "sqlite3",
    :database  => "/var/lib/cloudmaster.db"
  )
  Cloudmasterd::Models.create_schema :assume => (Cloudmasterd::Models::Machine.table_exists? ? 1.0 : 0.0)

  # Sync up the state initially
  Cloudmasterd::Helpers::Syncer.run
end

Thread.new do
  while true do
    Cloudmasterd::Helpers::Syncer.run
    sleep 5
  end
end

Cloudmasterd.start_picnic