hazetug 0.1.1

data/lib/hazetug/haze/digital_ocean.rb

@@ -0,0 +1,71 @@
+require 'hazetug/haze/cloud_server'
+
+class Hazetug
+  class Haze
+    class DigitalOcean < Haze
+      include CloudServer
+
+      requires :name, :location, :flavor, :image
+      defaults :backups_active => true, :private_networking => true
+
+      def initialize(config={})
+        super
+        @config[:bits] = bits_from_string(@config[:image])
+        @config[:image_slug] = image_from_string(@config[:image])
+      end
+
+      def create_server_args
+        {
+          :name => config[:name],
+          :region_id => lookup(:location).id,
+          :flavor_id => lookup(:flavor).id,
+          :image_id  => lookup(:image).id,
+          :ssh_key_ids => ssh_key_ids,
+          :backups_active => config[:backups_active],
+          :private_networking => config[:private_networking]
+        }
+      end
+
+      def compare_location?(o)
+        a = o.attributes
+        value = config[:location]
+        a[:name].match(/^#{value}/i) != nil ||
+        a['slug'] == config[:location] || a['slug'].match(/^#{value}/) != nil
+      end
+
+      def compare_flavor?(o)
+        a = o.attributes
+        value = config[:flavor]
+        a[:memory] == memory_in_megabytes(value) ||
+        a[:name].match(/^#{value}/i)
+      end
+
+      def compare_image?(o)
+        a = o.attributes
+        img_id = image_from_string(a[:name])
+        bits = bits_from_string(a[:name])
+        img_id.match(/^#{config[:image_slug]}/) && bits == config[:bits]
+      end
+
+      def public_ip_address
+        server and server.public_ip_address
+      end
+
+      def private_ip_address
+        server and server.private_ip_address
+      end
+
+      private
+
+      def ssh_key_ids
+        if config[:ssh_keys].nil? || config[:ssh_keys].empty?
+          compute.ssh_keys.map(&:id)
+        else
+          config[:ssh_keys].map do |n|
+            k = lookup(:ssh_key, n) and k.id
+          end.compact
+        end
+      end
+    end
+  end
+end

data/lib/hazetug/haze/linode.rb

@@ -0,0 +1,66 @@
+require 'securerandom'
+require 'hazetug/haze/cloud_server'
+
+class Hazetug
+  class Haze
+    class Linode < Haze
+      include CloudServer
+
+      requires :name, :location, :flavor, :image
+      defaults :payment_terms => 1
+
+      def initialize(config={})
+        super
+        @config[:bits] = bits_from_string(@config[:image])
+        @config[:image_slug] = image_from_string(@config[:image])
+        @config[:ssh_password] ||= SecureRandom.hex
+      end
+
+      def create_server_args
+        latest = /^Latest #{config[:bits]} bit/
+        {
+          :name => config[:name],
+          :data_center => lookup(:location),
+          :flavor => lookup(:flavor),
+          :image  => lookup(:image),
+          :kernel => compute.kernels.find {|k| k.name.match(latest)},
+          :password => config[:ssh_password],
+          :payment_terms => config[:payment_terms]
+        }
+      end
+
+      def compare_location?(o)
+        a = o.attributes
+        value = config[:location]
+        a[:location].match(/^#{value}/i) != nil ||
+        a[:abbr] == config[:location] || a[:abbr].match(/^#{value}/) != nil
+      end
+
+      def compare_flavor?(o)
+        a = o.attributes
+        value = config[:flavor]
+        a[:ram] == memory_in_megabytes(value) ||
+        a[:name].match(/^#{value}/i)
+      end
+
+      def compare_image?(o)
+        a = o.attributes
+        img_id = image_from_string(a[:name])
+        bits = a[:bits]
+        img_id.match(/^#{config[:image_slug]}/) && bits == config[:bits]
+      end
+
+      def public_ip_address
+        server and server.public_ip_address
+      end
+
+      def private_ip_address
+        server and begin
+          found = server.ips.find {|ip| not ip.public}
+          found and found.ip
+        end
+      end
+
+    end
+  end
+end

data/lib/hazetug/haze.rb

@@ -0,0 +1,81 @@
+require 'hazetug/config'
+require 'hazetug/compute'
+require 'hazetug/ui'
+require 'hazetug/tug'
+require 'chef/mash'
+
+class Hazetug
+  class Haze
+    include Hazetug::UI::Mixin
+
+    RE_BITS  = /-?x(32)$|-?x(64)$|(32)bit|(64)bit/i
+    attr_reader :config, :compute, :compute_name, :server
+
+    def initialize(config={})
+      @compute_name = Hazetug.leaf_klass_name(self.class)
+      @compute = Hazetug::Compute.const_get(compute_name).new
+      @config  = configure(config)
+      @server  = nil
+      @sshable = false
+    end
+
+    def provision
+      provision_server
+      wait_for_ssh
+    rescue Fog::Errors::Error
+      ui.error "[#{compute_name}] #{$!.inspect}"
+      ui.msg   $@
+      exit(1)
+    end
+
+    def configure(config)
+      input = config.keys.map(&:to_sym)
+      requires = self.class.requires
+      unless (norequired = requires.select {|r| not input.include?(r)}).empty?
+        ui.error "Required options missing: #{norequired.join(', ')}"
+        raise ArgumentError, "Haze options missing"
+      end
+      Mash.new(self.class.defaults.merge(config))
+    end
+
+    class << self
+      def requires(*args)
+        if args.empty?
+          @requires
+        else
+          @requires = args.flatten.dup
+        end
+      end
+
+      def defaults(hash=nil)
+        if hash.nil?
+          @defaults
+        else
+          @defaults = hash
+        end
+      end
+
+      def [](haze_name)
+        klass = Hazetug.camel_case_name(haze_name)
+        Hazetug::Haze.const_get(klass)
+      end
+    end
+
+    def public_ip_address
+    end
+
+    def private_ip_address
+    end
+
+    protected
+
+    def provision_server
+      ui.error "#{compute_name} Provisioning is not impemented"
+    end
+
+    def wait_for_ssh
+      ui.error "#{compute_name} Waiting for shh is not impemented"
+    end
+
+  end
+end

data/lib/hazetug/hazetug.rb

@@ -0,0 +1,31 @@
+require 'hazetug/version'
+require 'hazetug/compute'
+require 'hazetug/haze'
+require 'hazetug/haze/linode'
+require 'hazetug/haze/digital_ocean'
+
+class Hazetug
+  class Exception < ::Exception
+  end
+
+  class << self
+    def camel_case_name(string_or_symbol)
+      string_or_symbol.to_s.split('_').map(&:capitalize).join
+    end
+
+    def leaf_klass_name(klass)
+      if klass.is_a? String
+        klass.split('::').last
+      else
+        klass.name.split('::').last
+      end
+    end
+
+    def ssh_keys(compute_name=nil)
+      ssh_attr = []
+      ssh_attr << "#{compute_name.downcase}_ssh_keys" if compute_name
+      ssh_attr << "ssh_keys"
+      Hazetug::Config[ssh_attr.find {|a| Hazetug::Config[a]}]
+    end
+  end
+end

data/lib/hazetug/task.rb

@@ -0,0 +1,53 @@
+require 'psych'
+require 'chef/mash'
+require 'chef/mixin/deep_merge'
+require 'hazetug/ui'
+
+class Hazetug
+  class Task
+    include  Hazetug::UI::Mixin
+
+    def initialize(path)
+      path = File.expand_path(path)
+      @task = Mash.new(Psych.load_file(path))
+    rescue Psych::Exception
+      ui.fatal "Unable to parse hazetug task file: '#{path}'"
+      puts $!.inspect, $@
+      exit(1)
+    rescue SystemCallError
+      ui.fatal "Unable to read file: '#{path}'"
+      exit(1)
+    end
+
+    def [](key)
+      @task[key]
+    end
+
+    def hosts_to_bootstrap(env={}, &block)
+      return if block.nil?
+      base_conf = Mash.new(task)
+      hosts = base_conf.delete(:bootstrap)
+      base_conf = Chef::Mixin::DeepMerge.merge(base_conf, env)
+      hosts.each do |conf|
+        merged = Chef::Mixin::DeepMerge.merge(base_conf, conf)
+        block.call(merged)
+      end
+    end
+
+    class << self
+      protected :new
+
+      def load_from_file(path)
+        @instance ||= self.new(path)
+      end
+
+      def [](key)
+        @instance and @instance[key]
+      end
+    end
+
+    protected
+    attr_reader :task
+
+  end
+end

data/lib/hazetug/tug/knife.rb

@@ -0,0 +1,97 @@
+require 'chef/knife/ssh'
+require 'chef/knife/bootstrap'
+require 'hazetug/tug'
+
+# Monkey Patch:)
+# Extend knife bootstrap context with our data
+class Chef::Knife::Core::BootstrapContext
+  def hazetug; @config[:hazetug]; end
+end
+
+class Chef::Knife::Ssh < Chef::Knife
+  def run
+    extend Chef::Mixin::Command
+    @longest = 0
+    configure_attribute
+    configure_user
+    configure_password
+    configure_identity_file
+    configure_gateway
+    configure_session
+    exit_status = ssh_command(@name_args[1..-1].join(" "))
+    session.close
+
+    exit_status
+  end
+end
+
+class Hazetug
+  class Tug
+    class Knife < Tug
+
+      def bootstrap_server
+        [
+          :template_file,
+          :identity_file,
+          :ssh_user,
+          :ssh_password,
+          :host_key_verify
+        ].each do |opt|
+          kb.config[opt] = bootstrap_options[opt]
+        end
+        [
+          :environment,
+          :chef_server_url,
+          :validation_key
+        ].each do |opt|
+          Chef::Config[opt] = bootstrap_options[opt]
+        end
+        kb.name_args = [haze.server.ssh_ip_address]
+        kb.run
+      ensure
+        @kb and @kb.ui.stdout.close
+      end
+
+      def kb
+        @kb ||= begin
+          lf = create_log_file
+          Chef::Knife::Bootstrap.load_deps
+          kb = Chef::Knife::Bootstrap.new
+          kb.config[:hazetug] = config
+          kb.ui = Chef::Knife::UI.new(lf, lf, lf, {verbosity: 2})
+          kb
+        end
+      end
+
+      def bootstrap_options
+        @bootstrap_options ||= begin
+          template = options[:opts][:bootstrap]
+          opts = {}
+          opts[:validation_key] = File.expand_path(config[:chef_validation_key] || 'validation.pem')
+          opts[:template_file]  = File.expand_path(template || 'bootstrap.erb')
+          opts[:ssh_user] = config[:ssh_user] || 'root'
+          opts[:ssh_password] = config[:ssh_password]
+          opts[:environment]  =  config[:chef_environment]
+          opts[:host_key_verify] = config[:host_key_verify] || false
+          opts[:chef_server_url] = config[:chef_server_url]
+          opts[:identity_file]   = preferred_ssh_identity if not opts[:ssh_password]
+          opts
+        end
+      end
+
+      def preferred_ssh_identity
+        @preferred_ssh_identity ||= begin
+          compute = Hazetug.leaf_klass_name(haze.class.name).downcase
+          identity = config[:identity_file]
+          key_path = (Hazetug::Config["#{compute}_ssh_keys"] || []).first
+          if identity.nil? && key_path.nil?
+            raise Hazetug::Exception, "identity file not specified, use #{compute}_ssh_keys or identity_file"
+          end
+          identity ||= File.expand_path(key_path)
+          identity
+        end
+      end
+
+    end
+  end
+end

data/lib/hazetug/tug.rb

@@ -0,0 +1,85 @@
+require 'hazetug/tug/knife'
+require 'hazetug/ui'
+require 'chef/mash'
+
+class Hazetug
+  class Tug
+    include Hazetug::UI::Mixin
+
+    SSH_OPTIONS = [
+      :ssh_user, :ssh_password, :ssh_port,
+      :ssh_host_key_verify, :ssh_keys
+    ]
+    LOGDIR = "#{Dir.pwd}/logs"
+
+    attr_reader :haze, :config, :options
+
+    def initialize(config={}, haze=nil)
+      @haze = haze
+      @config = config
+    end
+
+    def tug_name
+      @tug_name ||= self.class.name.split('::').last
+    end
+
+    def bootstrap(options={})
+      if haze && haze.server && haze.server.sshable?
+        @options = options
+        haztug_set_variables
+        ip = config[:public_ip_address]
+        ui.msg "[#{tug_name}] bootstraping server #{haze.config[:name]}, ip: #{ip}"
+        exit_status = bootstrap_server
+        if exit_status.is_a?(Fixnum) && exit_status != 0
+          ui.error "[#{tug_name}] bootstraping server #{haze.config[:name]} failed."
+        else
+          ui.msg "[#{tug_name}] bootstraping server #{haze.config[:name]} done."
+        end
+      else
+        ui.error "#{haze.compute_name} skipping bootstrap, server #{haze.config[:name]} not ready"
+      end
+    rescue Hazetug::Exception => e
+      ui.error "[#{haze.compute_name}] #{e.message}"
+    end
+
+    class << self
+      def [](symbol_or_string)
+        klass = Hazetug.camel_case_name(symbol_or_string)
+        const_get(klass)
+      end
+
+      def ssh_options_from(config)
+        SSH_OPTIONS.inject({}) do |hash, k|
+          if value = (config[k])
+            hash[k] = value
+          end
+          hash
+        end
+      end
+    end
+
+    private
+
+    def haztug_set_variables
+      {
+        compute_name: haze.compute_name.downcase,
+        public_ip_address: (haze.public_ip_address || haze.server.ssh_ip_address rescue nil),
+        private_ip_address: haze.private_ip_address
+      }.each do |key, value|
+        config[key] = value if value
+      end
+    end
+
+    protected
+
+    def create_log_file
+      unless File.directory?(LOGDIR)
+        Dir.mkdir(LOGDIR)
+      end
+      log = File.new("#{LOGDIR}/#{haze.config[:name]}", "w+")
+      log.sync = true
+      log
+    end
+
+  end
+end

data/lib/hazetug/ui.rb

@@ -0,0 +1,75 @@
+class Hazetug
+  class UI
+    module Mixin
+      def self.included(includer)
+        includer.class_exec do
+          define_method(:ui) {Hazetug::UI.instance}
+        end
+      end
+    end
+
+    attr_reader :stdout
+    attr_reader :stderr
+    attr_reader :stdin
+
+    def initialize(stdout, stderr, stdin)
+      @stdout, @stderr, @stdin = stdout, stderr, stdin
+    end
+
+    def highline
+      @highline ||= begin
+        require 'highline'
+        HighLine.new
+      end
+    end
+
+    def msg(message)
+      begin
+        stdout.puts message
+      rescue Errno::EPIPE => e
+        raise e
+        exit 0
+      end
+    end
+
+    alias :info :msg
+
+    def err(message)
+      begin
+        stderr.puts message
+      rescue Errno::EPIPE => e
+        raise e
+        exit 0
+      end
+    end
+
+    def warn(message)
+      err("#{color('WARNING:', :yellow, :bold)} #{message}")
+    end
+
+    def error(message)
+      err("#{color('ERROR:', :red, :bold)} #{message}")
+    end
+
+    def fatal(message)
+      err("#{color('FATAL:', :red, :bold)} #{message}")
+    end
+
+    def color(string, *colors)
+      if color?
+        highline.color(string, *colors)
+      else
+        string
+      end
+    end
+
+    def color?
+      stdout.tty?
+    end
+
+    def self.instance
+      @instance ||= Hazetug::UI.new(STDOUT, STDERR, STDIN)
+    end
+
+  end
+end

data/lib/hazetug/version.rb

@@ -0,0 +1,3 @@
+class Hazetug
+  VERSION = "0.1.1"
+end

data/lib/hazetug.rb

@@ -0,0 +1,4 @@
+require 'hazetug/hazetug'
+require 'hazetug/cli'
+
+Hazetug::CLI.new.run(ARGV) if $0 == __FILE__