rig 0.4.5 → 0.5.0

data/lib/rig.rb

@@ -1,2 +1,12 @@
+require 'clamp'
+require 'fog'
+
 require 'rig/version'
-require 'rig/config'
+require 'rig/config'
+require 'rig/account'
+require 'rig/log'
+require 'rig/plugin'
+require 'rig/model'
+
+Rig::Config.data
+Rig::Account.data

data/lib/rig/account.rb

@@ -0,0 +1,43 @@
+module Rig
+  module Account
+    class << self
+      attr_reader :name
+      attr_reader :loaded
+
+      def data(name = get)
+        if @name != name
+          @data = nil
+          @loaded = false
+          @name = nil
+        end
+
+        @data ||= begin
+          Rig::Log.debug "loading account"
+          a        = Rig::Model::Account.load(name)
+          a[:name] = name
+
+          Rig::Log.debug "loading plugins from account"
+          Rig::Plugin.load(a[:plugins]) if a[:plugins]
+
+          a
+        end
+        @name = @data[:name]
+        @loaded = true
+        @data
+      end
+
+      def get
+        return ENV['RIG_ACCOUNT'] if ENV['RIG_ACCOUNT']
+        return Rig.config[:account] if Rig.config[:account]
+        return Rig.config[:default_account] if Rig.config[:default_account]
+        return Rig.config[:accounts].first if Rig.config[:accounts] && Rig.config[:accounts].count > 0
+        "default"
+      end
+
+      def save
+        name = Rig.account[:name]
+        Rig::Model::Account.save(name, Rig.account)
+      end
+    end
+  end
+end

data/lib/rig/command.rb

@@ -1,47 +1,98 @@
 require 'rig'
-require 'clamp'
-require 'fog'
-require 'yaml'
-
 require 'rig/model'
 
 require 'rig/command/abstract'
 require 'rig/command/options'
 
-require 'rig/command/main'
-require 'rig/command/ssh'
-require 'rig/command/account'
-require 'rig/command/config'
-require 'rig/command/database'
-
-require 'rig/command/environment/main'
-require 'rig/command/environment/list'
-require 'rig/command/environment/create'
-require 'rig/command/environment/destroy'
-require 'rig/command/environment/protect'
-
-require 'rig/command/balancer/main'
-require 'rig/command/balancer/list'
-require 'rig/command/balancer/view'
-require 'rig/command/balancer/destroy'
-require 'rig/command/balancer/listener'
-
-require 'rig/command/dns/main'
-require 'rig/command/dns/list'
-require 'rig/command/dns/create'
-require 'rig/command/dns/edit'
-require 'rig/command/dns/destroy'
-
-require 'rig/command/instance/main'
-require 'rig/command/instance/list'
-require 'rig/command/instance/create'
-require 'rig/command/instance/destroy'
-require 'rig/command/instance/view'
-
-require 'rig/command/instance/tag/main'
-require 'rig/command/instance/tag/get'
-require 'rig/command/instance/tag/set'
-require 'rig/command/instance/tag/remove'
-
-require 'rig/command/keypair/main'
-require 'rig/command/keypair/list'
+module Rig
+  module Command
+    class Main < Abstract
+      def merge_file(src, dest)
+        old = YAML.load_file(dest)
+        FileUtils.mv(dest, "#{dest}.bak.#{Time.now.to_i}")
+        new = YAML.load_file(src)
+        new.merge!(old)
+        File.open(dest, "w") {|f| f.write(new.to_yaml)}
+      end
+
+      subcommand "userdata", "test userdata" do
+        parameter "NAME", "name of server"
+        parameter "ROLE", "role of server"
+        parameter "ENVIRONMENT", "environment of server"
+
+        def execute
+          userdata = Rig::Model::Userdata.create(name, role, environment)
+          puts "USERDATA:\n#{userdata}"
+        end
+      end
+
+      subcommand "init", "initialize configuration directory" do
+        option %w{-f --force}, :flag, "force creation of files", :default => false
+        option %w{-d --directory}, "DIRECTORY", "configuration directory", :default => "~/.rig"
+
+        def execute
+          dir = File.expand_path(ENV['RIG_CONFIG'] ? ENV['RIG_CONFIG'] : directory)
+          back = "#{dir}.bak.#{Time.now.to_i}"
+          conf = File.expand_path("../../../../conf", __FILE__)
+
+          files = %w{
+            config.yml
+
+            accounts/default.yml
+
+            templates/solo.yml
+            templates/multi.yml
+
+            userdata/default/userdata.sh.erb
+            userdata/default/userdata.yml
+            userdata/chef/userdata.sh.erb
+            userdata/chef/userdata.yml
+            userdata/chef/validation.pem
+
+            plugins/chef.rb
+            plugins/scout.rb
+          }
+
+          unless dir
+            puts "directory could not be found: tried environment variables RIG_CONFIG (#{ENV['RIG_CONFIG']}) and HOME (#{ENV['HOME']}"
+            exit(1)
+          end
+
+          if File.exists?(dir)
+            unless File.directory?(dir)
+              puts "moving old config #{dir} to #{back}"
+              FileUtils.mv(dir, new)
+            end
+          end
+
+          puts "[create] #{dir}/"
+          FileUtils.mkdir_p(dir)
+
+          files.each do |file|
+            src  = "#{conf}/#{file}"
+            dest = "#{dir}/#{file}"
+            FileUtils.mkdir_p(File.dirname(dest))
+            if File.exists?(dest) && !force?
+              puts "[skip] #{dest}"
+            else
+              puts "[create] #{dest}"
+              FileUtils.copy(src, dest)
+            end
+          end
+        end
+      end
+    end
+
+    class << self
+      def load
+        Rig::Plugin.run "commands:before"
+
+        Dir["#{File.dirname(__FILE__)}/model/*.rb"].each {|file| require file.gsub(/\.rb/,'')}
+
+        Rig::Plugin.run "commands:loaded", Rig::Command::Main
+      end
+    end
+  end
+end
+
+Rig::Command.load

data/lib/rig/command/abstract.rb

@@ -9,8 +9,7 @@ module Rig
       end
 
       option ["-a", "--account"], "ACCOUNT", "set the rig account to use", :default => "default" do |a|
-        Rig.config[:account] = a
-        a
+        Rig::Account.data(a)
       end
 
       option ["-v", "--version"], :flag, "print version number and exit" do |v|

data/lib/rig/command/balancer.rb

@@ -0,0 +1,102 @@
+require 'rig'
+require 'rest-client'
+
+module Rig
+  module Command
+    class Balancer < Abstract
+      self.default_subcommand = 'list'
+
+      subcommand "list", "list load balancers" do
+        def execute
+          list = Rig::Model::Balancer.all
+          list.each do |lb|
+            puts lb.id
+            puts "- listeners"
+            lb.listeners.each do |l|
+              puts "  - #{l.protocol}:#{l.lb_port} => #{l.instance_protocol}:#{l.instance_port}"
+            end
+            puts "- instances"
+            lb.instances.each do |inst|
+              puts "  - #{inst}"
+            end
+            puts "- zones"
+            lb.availability_zones.each do |z|
+              puts "  - #{z}"
+            end
+          end
+        end
+      end
+
+      subcommand "destroy", "destroy load balancer" do
+        parameter "NAME", "name of load balancer"
+
+        def execute
+          Rig::Model::Balancer.destroy(name)
+        end
+      end
+
+      subcommand "listener", "manage listeners for load balancer" do
+        subcommand "add", "add a listener to a balancer" do
+          parameter "BALANCER", "balancer name"
+          parameter "LISTENER", "listener data PROTO:PORT/PROTO:PORT"
+          parameter "[CERT]", "arn for server certificate"
+          parameter "[POLICY] ...", "policy names"
+
+          def execute
+            (from, to) = listener.split('/')
+            #newlist    = elb.listeners.create()
+            Rig::Model::Balancer.add_listener(balancer, from, to, cert, policy_list)
+          end
+        end
+
+        subcommand "rm", "remove a listener from a balancer" do
+          parameter "BALANCER", "balancer name"
+          parameter "LISTENER", "listener data PROTO:PORT (just the elb side)"
+
+          def execute
+            Rig::Model::Balancer.destroy_listener(balancer, listener)
+          end
+        end
+      end
+
+      subcommand 'test', 'test a load balancer' do
+        option %w{-c --count}, "COUNT", "number of times to loop", :default => 100
+        option %w{-p --poll}, "POLL", "poll time", :default => 10
+        parameter "NAME", "name of the load balancer to test"
+
+        def execute
+          elb = Rig::Model::Balancer.find(name)
+          raise "elb #{name} not found" unless elb
+
+          dns = elb.dns_name
+          count.times do |i|
+            puts "### loop #{i}"
+            ips = `host #{dns}`.split(/\n/).collect { |e| e.split.last }
+            ips.each do |ip|
+              val = begin
+                RestClient.get("http://#{ip}")
+              rescue => e
+                e.message
+              end
+              print ".. #{ip} - #{val}"
+              puts
+            end
+            sleep poll
+          end
+        end
+      end
+
+      subcommand "view", "view load balancer information" do
+        include Options::ShowAll
+
+        parameter "NAME", "name of instance"
+
+        def execute
+          item = Rig::Model::Balancer.find(name)
+          puts item.attributes.to_yaml
+        end
+      end
+    end
+  end
+end
+Rig::Command::Main.subcommand "balancer", "manage load balancers", Rig::Command::Balancer

data/lib/rig/command/dns.rb

@@ -0,0 +1,47 @@
+
+module Rig
+  module Command
+    class Dns < Abstract
+      self.default_subcommand = 'list'
+
+      subcommand "create", "create dns entry" do
+        parameter 'NAME', 'the name to create'
+        parameter 'VALUE', 'where the name points to'
+
+        def execute
+          Rig::Model::Dns.create(name, value)
+        end
+      end
+
+      subcommand "destroy", "destroy dns entry" do
+        parameter "NAME", "name of dns entry"
+        def execute
+          Rig::Model::Dns.destroy(name)
+        end
+      end
+
+      subcommand "change", "change dns entry" do
+        parameter 'NAME', 'the name to change'
+        parameter 'VALUE', 'where the name points to'
+
+        def execute
+          Rig::Model::Dns.destroy(name)
+          Rig::Model::Dns.create(name, value)
+        end
+      end
+
+      subcommand "list", "list dns entries" do
+        def execute
+          zone    = Rig.get_config(:dns_zone)
+          records = Rig::Model::Dns.records("#{zone}")
+          rows    = []
+          records.each do |record|
+            rows << [zone, record.type, record.ttl, record.name, [*record.value].join(",")]
+          end
+          print_table(%w{Domain Type TTL Name Value}, rows)
+        end
+      end
+    end
+  end
+end
+Rig::Command::Main.subcommand "dns", "manage dns", Rig::Command::Dns

data/lib/rig/command/environment.rb

@@ -0,0 +1,67 @@
+require 'rig'
+require 'fog'
+
+module Rig
+  module Command
+    class Environment < Abstract
+      self.default_subcommand = "list"
+
+      subcommand "create", "create environment" do
+        parameter "NAME", "the name of the environment"
+        parameter "TEMPLATE", "the template to use (solo, multi, etc)", :default => "solo"
+
+        def execute
+          #connection = Rig::Connection.compute
+          env = Rig::Model::Environment.create(name, template.to_sym)
+          #ap env.servers
+        end
+      end
+
+      subcommand "destroy", "destroy environment" do
+        parameter "NAME", "name of the environment to destroy"
+
+        def execute
+          Rig::Model::Environment.destroy(name)
+        end
+      end
+
+      subcommand "list", "list environments" do
+        option %w{-s --simple}, :flag, "just show list of names"
+
+        def execute
+          envs = Rig::Model::Environment.list
+
+          if simple?
+            print_table(%w{Name}, envs)
+          else
+            rows = []
+            envs.each do |e|
+              env   = Rig::Model::Environment.find(e)
+              zones = env.servers.collect { |e| e.availability_zone }
+              rows << [env.name, env.template, env.region, env.servers.count, env.balancers.count, env.protected?, zones]
+            end
+            print_table(%w{Name Template Region Servers# Balancers# Protected? AZs}, rows)
+          end
+        end
+      end
+
+      subcommand "protect", "set (or disable) protection on environment" do
+        option ["-u", "--undo"], :flag, "disable protection instead of enabling"
+        parameter "NAME", "the environment to protect"
+
+        def execute
+          env = Rig::Model::Environment.find(name)
+          raise "Environment #{name} not found" if env.nil?
+          connection = Rig::Connection.compute
+          val        = undo? ? "false" : "true"
+
+          env.servers.each do |s|
+            connection.create_tags(s.id, "Protected" => val)
+          end
+        end
+      end
+    end
+  end
+end
+
+Rig::Command::Main.subcommand "environment", "manage environments", Rig::Command::Environment

data/lib/rig/command/keypair.rb

@@ -0,0 +1,15 @@
+module Rig
+  module Command
+    class Keypair < Abstract
+      self.default_subcommand = "list"
+      subcommand "list", "list key pairs" do
+        def execute
+          connection = Rig::Connection.compute
+          list       = connection.key_pairs.all
+          puts list.inspect
+        end
+      end
+    end
+  end
+end
+Rig::Command::Main.subcommand "keypair", "manage key pairs", Rig::Command::Keypair

data/lib/rig/command/server.rb

@@ -0,0 +1,181 @@
+require 'rig'
+require 'awesome_print'
+
+module Rig
+  module Command
+    class Server < Abstract
+      self.default_subcommand = "list"
+      subcommand "create", "create an server" do
+        option %w{-i --image}, "IMAGE", "the image / ami to use, default: your account image"
+        option %w{-f --flavor}, "FLAVOR", "the flavor / size to use"
+        option %w{-k --keypair}, "KEYPAIR", "the key pair / name to use, default: your account keypair"
+        option %w{-g --groups}, "GROUPS", "comma separated list of groups, default: your account groups"
+        option %w{-r --region}, "GROUPS", "the region, default: your account region"
+        option %w{--add}, :flag, "add this to the existing servers of this role and environment"
+        option "--[no-]chef", :flag, "use chef to bootstrap", :default => true
+
+        parameter "ENVIRONMENT", "the environment this server should belong to"
+        parameter "ROLE", "the server role", :default => 'solo'
+
+        def execute
+          name = role
+          # figure out if there are others of this role, if there are add a number to name to distinguish.
+          n    = "#{name}.#{environment}.env"
+          chef = Rig.config[:chef] ? true : false
+
+          unless flavor
+            raise "must specify flavor"
+          end
+
+          o      = {
+              :image_id  => image,
+              :flavor_id => flavor,
+              :key_name  => keypair,
+              :groups    => groups.split(','),
+              :user_data => Rig::Model::Userdata.create(n, role, environment, :chef => chef)
+          }
+          tags   = { 'Name' => n, 'Environment' => environment, 'Role' => role }
+          server = Rig::Model::Instance.create(o, tags)
+          puts "created: #{server.id}"
+        rescue => e
+          puts "error: #{e.message}"
+          raise Clamp::HelpWanted, self
+        end
+
+        def default_image
+          Rig.account[:image].is_a?(Hash) ? Rig.account[:image].first.last : Rig.account[:image]
+        end
+
+        def default_keypair
+          Rig.account[:keypair]
+        end
+
+        def default_groups
+          Rig.account[:groups].join(",")
+        end
+      end
+
+      subcommand "destroy", "destroy (terminate) server" do
+        parameter "NAME", "the name of the server to connect to"
+
+        def execute
+          list = Rig::Model::Instance.find(name)
+          Rig::Model::Instance.destroy(list)
+        end
+      end
+      subcommand "list", "list servers" do
+        include Options::ShowAll
+
+        option %w{-l --long}, :flag, "show more information in table"
+        parameter "[ENV]", "environment"
+
+        def execute
+          connection = Rig::Connection.compute
+          filters    = { }
+          filters["instance-state-name"] = "running" unless showall?
+          filters["tag:Environment"] = env if env
+
+          list = connection.servers.all(filters)
+          instance_list(list, long?)
+        end
+      end
+      subcommand "tag", "manage server tags" do
+        subcommand "get", "get tag(s) for this server" do
+          parameter "NAME", "the name of the server to get tags for"
+
+          def execute
+            instance = Rig::Model::Instance.find(name)
+            raise "server not found #{name}" unless instance
+            puts "#{instance.tags.inspect}"
+          end
+        end
+
+        subcommand "rm", "remove tag(s) for this server" do
+          include Options::Instance
+          include Options::InstanceName
+
+          parameter "TAG", "tag key to remove", :attribute_name => :raw_tag
+
+          # TODO: fix this to use Model instead
+          def execute
+            unless iname || iid
+              raise "Must set either server name or server id (-iname or -iid)"
+            end
+
+            connection = Rig::Connection.compute
+            if iid
+              instance = connection.servers.get(iid)
+            else
+              list = connection.servers.all({ "tag:Name" => iname })
+              if list.count > 1
+                puts "there is more than one server that matches:"
+                instance_list(list)
+                return
+              end
+              instance = list.first
+            end
+
+            unless instance
+              puts "could not find server"
+              return
+            end
+
+            ap connection.delete_tags(instance.id, raw_tag => instance.tags[raw_tag])
+          end
+        end
+
+        subcommand "set", "set tag(s) for this server" do
+          include Options::Instance
+          include Options::InstanceName
+
+          parameter "TAGS ...", "tags of the form key:value", :attribute_name => :raw_tags
+
+          def execute
+            unless iname || iid
+              raise "Must set either server name or server id (-iname or -iid)"
+            end
+
+            connection = Rig::Connection.compute
+            if iid
+              instance = connection.servers.get(iid)
+            else
+              list = connection.servers.all({ "tag:Name" => iname })
+              if list.count > 1
+                puts "there is more than one server that matches:"
+                instance_list(list)
+                return
+              end
+              instance = list.first
+            end
+
+            unless instance
+              puts "could not find server"
+              return
+            end
+
+            raw_tags.each do |s|
+              (k, v) = s.split(':', 2)
+              #tags[k] = v if k && v
+              connection.create_tags(instance.id, k => v)
+            end
+          end
+        end
+      end
+      subcommand "view", "view server information" do
+        include Options::ShowAll
+
+        # TODO: something wrong here, view is showing all servers
+        parameter "NAME", "name of server"
+
+        def execute
+          list = Rig::Model::Instance.find(name)
+          list.each do |item|
+            ap item.attributes
+          end
+        end
+      end
+    end
+  end
+end
+
+Rig::Command::Main.subcommand "server", "manage servers", Rig::Command::Server