path: root/genomed/lib/genomed.rb

# Copyright (C) 2008 Red Hat, Inc

# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.

# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.

# You should have received a copy of the GNU General Public License
# a long with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

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

gem 'reststop', '~> 0.2'

require 'yaml'
require 'fileutils'
require 'rubygems'
require 'picnic'
require 'reststop'
require 'genome-dsl'
require 'restr'
require 'cgi'
require 'xmlrpc/client'
require 'pp'

CONTEXT="/genome"

Camping.goes :Genomed
Genomed.picnic!

module Genomed::Controllers
  class Systems < REST 'systems'
    # OMG, this is ugly
    def _get_cobbler_installed_systems
      systems = {}
      `cat /var/log/cobbler/install.log | cut -f2-3`.each do |line| 
        name, ip = line.split("\t") 
        ip.chomp!
        name.chomp!
        hostname = _get_host_name(ip).chomp 
        puts "name: #{name}, ip: #{ip}, hostname: #{hostname}"

        systems[name] = {"ip" => ip, "hostname" => hostname}
      end
      return systems
    end

    def _get_host_name(ip)
      lookup = `nslookup #{ip} | grep name | cut -f2`
      unless lookup.empty?
        return lookup.split("=")[1].strip.split(".").join(".")
      end
    end

    def read(name)
      name = CGI::unescape(name)
      @systems = _get_cobbler_installed_systems
      @system = {}
      if @systems.has_key?(name)
        @system = {"name" => name, "ip" => @systems[name]["ip"], "hostname" => @systems[name]["hostname"]}
      end
      render :view_system
    end

    def list
      @systems = _get_cobbler_installed_systems
      pp @systems
      render :list_systems
    end
  end

  class MachineTypes < REST 'machine_types'
    include GenomeDsl

    # GET /types/foo
    # GET /types/foo.xml
    def read(type)
      @machine = machines.find {|m| m.name == type}
      render :view_type
    end

    # GET /types
    # GET /types.xml
    def list
      @machines = machines
      render :list_types
    end
  end

  class Nodes < REST 'nodes'
    # GET /nodes/foo
    # GET /nodes/foo.xml
    def read(name)
      @name = name
      begin
        @info = YAML.load(File.read("/etc/genome/nodes/#{@name}/node.yaml")) 
        render :view_node
      rescue
        # node doesn't exist yet
        render :add
      end
    end

    # GET /nodes
    # GET /nodes.xml
    def list
      @nodes = Dir["/etc/genome/nodes/*"].map { |m| File.basename(m) }
      render :list_nodes
    end

    def create
      if input.wizard
        puts "You're using the wizard!"   
        puts input.inspect
      elsif input.yaml
        node_dir = "/etc/genome/nodes/#{input.node_name}"
        persist_node(input.node_name, input.yaml)
      elsif input.xml
        xml = XmlSimple.xml_in(input.xml)

        params = Hash.new
        xml["parameters"].each do |p| 
          p.each_key do |k|
            params[k] = p[k].to_s #The value is an array. Yay.
          end
        end

        persist_node(xml["name"].to_s, YAML.dump({"classes" => xml["class"], "parameters" => params}))
      end

      redirect R(Nodes) if @format == :HTML 
    end

    def persist_node(node, yaml)
      node_dir = "/etc/genome/nodes/#{node}"
      FileUtils.mkdir_p(node_dir) unless File.exist?(node_dir)
      File.open(node_dir + "/node.yaml", "w") {|f| f.puts yaml}
    end
  end

  class Wizard < REST 'wizard'
    include GenomeDsl

    # GET /wizard/foo
    # GET /wizard/foo.xml
    def read(type)
      @machine = machines.find {|m| m.name == type}
      render :view_type
    end

    # GET /types
    # GET /types.xml
    def list
      @machines = machines
      render :list_types
    end

    def create
      @machine_type = input.machine_type

      redirect CONTEXT + R(Nodes)
    end
  end
end

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

  module HTML
    def layout
      html do
        head do
          title 'Genome'
          link :rel => 'stylesheet', :type => 'text/css', :href => '/styles.css', :media => 'screen'
        end
        body do
          div.header! do
            div.headerLogo! {}
          end
          div.content! do
            h1 do
              [a("Machine Types", :href => CONTEXT + R(Genomed::Controllers::MachineTypes)), 
               a("Nodes", :href => CONTEXT + R(Genomed::Controllers::Nodes)),
               a("Systems", :href => CONTEXT + R(Genomed::Controllers::Systems))].join " | "
            end
            self << yield
          end
        end
      end
    end
 
    def add
      form(:method => 'post', :action => CONTEXT + R(Genomed::Controllers::Nodes)) do
        h2 "YAML"
 
        textarea :name => 'yaml', :rows => '25', :cols => '100'; br

        input :name => 'node_name', :value => @name
        input :type => 'submit', :value => "Submit"
      end
    end

    def view_type
      p do
        h1 @machine.name
        p @machine.desc

        form(:method => 'post', :action => CONTEXT + R(Genomed::Controllers::Nodes)) do
          h2 "Fully qualified domain name"
          input :name => "fqdn", :type => 'text', :size  => 45,
                :value => "[prefix]-#{@machine.name}.usersys.redhat.com"

          h2 "Classes"
          @machine.classes.each_with_index do |c, i|
            input :name => "class#{i}", :type => 'text', 
                  :value => c; br
          end
  
          h2 "Parameters"
          fieldset do
            @machine.facts.each do |f|
              a(f.name, :href => "fix me", :title => f.desc); br
              input :name => "param_" + f.name, :type => 'text', :size => 45, 
                    :value => f.default; br
            end
          end

          input :type => 'hidden', :name => 'node_name', :value => @name
          input :type => 'hidden', :name => 'wizard', :value => true
          input :type => 'submit', :value => "Submit"
        end
      end
    end 

    def view_node
      h1 @name
    
      p "This form allows you to submit the YAML to be used by the Puppetmaster to " +
        "determine the configuration to be compiled for a particular host."
      form(:method => 'post', :action => CONTEXT + R(Genomed::Controllers::Nodes)) do
 
        textarea ::YAML.dump(@info), :name => 'yaml', :rows => '25', :cols => '100'; br

        input :type => 'hidden', :name => 'node_name', :value => @name
        input :type => 'submit', :value => "Submit"
      end
    end

    def view_system
      h1 @system["name"]

      p do
        "IP Address: #{@system["ip"]} "
      end
      p do 
        "Hostname: #{@system["hostname"]}"
      end
    end

    def list_nodes
      h1 "Nodes:"
      p "To create a new node just browse to the page corresponding to the hostname.  " +
        "eg, #{CONTEXT + R(Genomed::Controllers::Nodes, "[hostname]")}."
      p do
        ol do
          @nodes.each do |n| 
            # BUG: default format is not getting preserved
            @format = :HTML
            li {a(n, :href => CONTEXT + R(Genomed::Controllers::Nodes, n))}
          end
        end
      end
    end

    def list_types
      p do
        p "Click the links to create a new instance of a particular machine type."
        ol do
          @machines.each do |m|
            li do 
              #h1 {a(m.name, :href => R(Genomed::Controllers::MachineTypes, m.name))}
              h1 m.name
              p(m.desc)
            end
          end
        end
      end
    end

    def list_systems
      host = ENV["HOSTNAME"]
      cobbler_web = "http://#{host}/cobbler/web"
      h1 "Systems:"
      h4 do
        text("This information is gathered from the /var/log/cobbler/install.log file.\n")
        text("If you don't see what you're looking for, try ")
        a("cobbler web", :href => "#{cobbler_web}/?mode=system_list")
      end
         
      p do
        ol do
          @systems.each_key do |name|
            li do 
              a(name, :href => URL("http://#{host}/#{CONTEXT}/systems/?id=#{name}"))
              text(" (")
              a("edit in cobbler", :href => "#{cobbler_web}/?mode=system_edit&name=#{name}")
              text(")")
              ul do
                li "ip: #{@systems[name]["ip"]}"
                li "hostname: #{@systems[name]["hostname"]}"
              end
            end
          end
        end
      end
    end
  end
  default_format :HTML

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

    # This should only be used for Puppet's external nodes
    def view_node
      ::YAML.dump(@info)
    end

    def view_system
      ::YAML.dump(@system)
    end

    def list_systems
      ::YAML.dump(@systems)
    end
  end

  module XML
    def layout
      yield
    end

    def list_types
      @x.instruct!
      @x.machine_types {
        @machines.each do |m|
          @x.machine_type {
            @x.name(m.name)
            @x.description(m.desc)
          }
        end
      }
    end

    def view_type
      @x.instruct!
      @x.machine {
        @x.name(@machine.name)
        @x.description(@machine.desc)
        @machine.classes.each {|c| @x.class(c)}
        @machine.facts.each {|f| 
          @x.fact {
            @x.name(f.name)
            @x.description(f.desc)
            @x.default(f.default)
          }
        }
      }
    end

    def list_nodes
      @x.instruct!
      @x.nodes {
        @nodes.each {|n| @x.node(n)}
      }
    end

    def view_node
      # There no reason we should only support params and classes.
      # It might be nice to simply iterate over all the keys and 
      # display their values.
      @x.instruct!
      @x.node {
        @x.name(@name)
        @info["parameters"].each_pair do |n,v| 
          @x.parameters {
            instance_eval("@x.#{n}(v)")
          }
        end
        @info["classes"].each {|c| @x.class(c)}
      } 
    end

    def list_systems
      @x.instruct!
      @x.systems {
        @systems.each_key {|system| 
          @x.system {
            @x.name(system)
            @x.ip(@systems[system]["ip"])
            @x.hostname(@systems[system]["hostname"])
          }
        }
      }
    end

    def view_system
      @x.instruct!
      @x.system {
        @x.name(@system["name"])
        @x.ip(@system["ip"])
        @x.hostname(@system["hostname"])
      }
    end
  end
end

# Required by picnic
def Genomed.create; end

Genomed.start_picnic