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'
require 'pp'

Camping.goes :Cloudmasterd
Cloudmasterd.picnic!

module Cloudmasterd::Helpers
  class Syncer
    def self.run
      begin
        sync_memory
        sync_state
        sync_owners
      rescue Exception => e
        puts "ERROR: An error occured during syncing - #{e.to_s}"
      end
    end

    def self.parse_hosts(func_stderr)
      hosts = []
      func_stderr.split("\n").each do |host_line|
        # Handle a remote exception coming from a disconnected host
        if host_line.index("remote exception") then
          hosts.pop()
        else
          hosts << host_line.split(":")[1][2..-1]
        end
      end
      return hosts
    end

    def self.sync_memory
      current_state = {}
      Open3.popen3("func '*' call virt freemem") do |stdin, stdout, stderr|
        hosts = parse_hosts(stderr.read)

        # Parse out the machines that belong to each host and zip them together in a hash
        stdout.read.split("\n").each_with_index do |memory, index|
          current_state[hosts[index]] = memory
        end
      end

      Cloudmasterd::Models::Cloud.transaction do
        # Sync up the DB state - delete everything first
        Cloudmasterd::Models::Cloud.delete_all

        # Create the current entries
        current_state.each do |host, memory|
          Cloudmasterd::Models::Cloud.create :name => host, :memory => memory
        end
      end
    end

    def self.sync_state
      current_state = {}
      Open3.popen3("func '*' call virt state") do |stdin, stdout, stderr|
        hosts = parse_hosts(stderr.read)

        # 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

    def self.sync_owners
      # Sync up any unowned machines that now have an owner (handles race condition with syncing states)
      unowned_machines = {}
      Cloudmasterd::Models::Machine.find(:all, :conditions => "email = 'unknown'").each do |machine|
        unowned_machines[machine.name] = machine
      end

      owned_machines = {}
      Cloudmasterd::Models::Machine.find(:all, :conditions => "email <> 'unknown'").each do |machine|
        owned_machines[machine.name] = machine
      end

      owned_machines.each do |name, machine|
        if unowned_machines.has_key?(name) then
          # Delete the unowned machine and update the owned one
          u_machine = unowned_machines[name]
          machine.update_attributes(:cloud => u_machine.cloud, :state => u_machine.state)
          u_machine.destroy()
        end
      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 Cloud < Base; end
  class Machine < Base; end

  class CreateTheBasics < V 1.0
    def self.up
      create_table :cloudmasterd_cloud do |t|
        t.column :name,     :string,  :null => false, :limit => 255
        t.column :memory,   :integer,  :null => false
      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} /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(Status)
    end
  end

  class Status < REST 'status'
    def list
      # TODO: Figure out how to move this to a background thread
      Cloudmasterd::Helpers::Syncer.run

      @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 = Cloud.sum('memory')
      @cloud_machines = Cloud.find(:all)

      render :status
    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 => "/styles.css", :media => 'screen'
        end
        body do
          div.content! do
            self << yield
          end
        end
      end
    end

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

        table do
          tr do
            th 'Cloud Instance'
            th 'Memory'
          end
          @cloud_machines.each do |machine|
            tr do
              td machine.name
              td machine.memory
            end
          end
        end
      end

      div.machines! do
        @machines.keys.each do |email|
          div.user 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 => "/cloud" + R(Cloudmasterd::Controllers::Koan, "#{machine.name}").to_s) 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