dreamy 0.5.1

data/lib/dreamy/command.rb

@@ -0,0 +1,57 @@
+require 'commands/base'
+
+module Dreamy
+  module Command
+    class InvalidCommand < RuntimeError; end
+
+    class << self
+      def run(command, args)
+        run_internal(command, args)
+      rescue InvalidCommand
+        error "Unknown command. Run 'dh help' for usage information."
+      rescue ApiError => e
+        error "DreamHost returned this error: #{e}"
+      rescue Interrupt => e
+        error "\n[canceled]"
+      end
+
+      def run_internal(command, args)
+        namespace, command = parse(command)
+        require "commands/#{namespace}"
+        klass = Dreamy::Command.const_get(namespace.capitalize).new(args)
+        raise InvalidCommand unless klass.respond_to?(command)
+        klass.send(command)
+      end
+
+      def error(msg)
+        STDERR.puts(msg)
+        exit 1
+      end
+
+      def parse(command)
+        parts = command.split(':')
+        case parts.size
+        when 1
+          if namespaces.include? command
+            return command, 'index'
+          else
+            raise InvalidCommand
+          end
+        when 2
+          raise InvalidCommand unless namespaces.include? parts[0]
+          return parts
+        else
+          raise InvalidCommand
+        end
+      end
+
+      def namespaces
+        @@namespaces ||= Dir["#{File.dirname(__FILE__)}/commands/*"].map do |namespace|
+          namespace.gsub(/.*\//, '').gsub(/\.rb/, '')
+        end
+      end
+
+    end
+
+  end
+end

data/lib/dreamy/commands/announce.rb

@@ -0,0 +1,73 @@
+module Dreamy::Command
+  class Announce < Base
+    
+    def index
+      lists = @account.announce_lists
+      
+      if lists.empty?
+        display "No announcement lists on this account"
+      else
+        list_table = table do |t|
+          t.headings = 'Name', 'Short Name', 'Domain', 'Subscribers', 'Max Bounces', 'Start Date'
+          lists.each { |l| t << [l.name, l.short_name, l.domain, l.subscribers, l.max_bounces, l.start_date]}
+        end
+        display list_table
+      end
+    end
+    
+    def list
+      if args.length >= 1
+        listname, domain = extract_values(args.shift)
+        subscribers = @account.announce_list(listname,domain)
+        if subscribers.empty?
+          display "No subscribers to this list"
+        else
+          subscriber_table = table do |t|
+            t.headings = 'email', 'name', 'subscribe_date', 'bounces'
+            subscribers.each { |s| t << [s.email, s.name, s.subscribe_date, s.num_bounces] }
+          end
+          display subscriber_table
+          display "#{subscribers.size} total subscribers"
+        end
+      else
+        display "Usage: dh announce:list my_list@example.com"
+      end
+    end
+    
+    def add
+      if args.length >= 2
+        listname, domain = extract_values(args.shift)
+        email = args.shift
+        if @account.announce_add(listname,domain,email)
+          display "Successfully added #{email} to #{listname} list"
+        else
+          display "Failed to add #{email} to #{listname} list"
+        end
+      else
+        display "Usage: dh announce:add my_list@example.com new_guy@gmail.com"
+      end
+    end
+    
+    def remove
+      if args.length >= 2
+        listname, domain = extract_values(args.shift)
+        email = args.shift
+        if @account.announce_remove(listname,domain,email)
+          display "Successfully removed #{email} from #{listname} list"
+        else
+          display "Failed to remove #{email} from #{listname} list"
+        end
+      else
+        display "Usage: dh announce:remove my_list@example.com new_guy@gmail.com"
+      end
+    end
+
+    private
+
+    def extract_values(arg)
+      arg =~ /^(.*)@(.*)$/
+      return $1, $2
+    end
+
+  end
+end

data/lib/dreamy/commands/base.rb

@@ -0,0 +1,96 @@
+require 'terminal-table/import'
+
+module Dreamy::Command
+  class Base
+    
+    attr_accessor :args
+    def initialize(args)
+      @args     = args
+      @account  = configure_account 
+    end
+
+    def display(msg, newline=true)
+      if newline
+        puts(msg)
+      else
+        print(msg)
+        STDOUT.flush
+      end
+    end
+
+    def ask
+      gets.strip
+    end
+
+    def shell(cmd)
+      `cd '#{Dir.pwd}' && #{cmd}`
+    end
+
+    def extract_option(options, default=true)
+      values = options.is_a?(Array) ? options : [options]
+      return unless opt_index = args.select { |a| values.include? a }.first
+      opt_position = args.index(opt_index) + 1
+      if args.size > opt_position && opt_value = args[opt_position]
+        if opt_value.include?('--')
+          opt_value = nil
+        else
+          args.delete_at(opt_position)
+        end
+      end
+      opt_value ||= default
+      args.delete(opt_index)
+      block_given? ? yield(opt_value) : opt_value
+    end
+
+    def home_directory
+      running_on_windows? ? ENV['USERPROFILE'] : ENV['HOME']
+    end
+
+    def running_on_windows?
+      RUBY_PLATFORM =~ /mswin32/
+    end
+    
+    private
+    
+    def configure_account
+			Dreamy::Base.new(user,key)
+    end
+    
+    def user
+      get_credentials
+      @credentials[0]
+    end
+    
+    def key
+      get_credentials
+      @credentials[1]
+    end
+    
+    def credentials_file
+			"#{home_directory}/.dreamyrc"
+		end
+		
+		def read_credentials
+		  if File.exists? credentials_file
+				return File.read(credentials_file).split("\n")
+			end
+		end
+    
+    def get_credentials
+      return if @credentials
+      unless @credentials = read_credentials
+        @credentials = [ENV['DH_USER'], ENV['DH_KEY']]
+      end
+      if @credentials[0].nil? || @credentials[1].nil?
+        display "\nYou need to set your API credentials. You can do this 2 ways:\n"
+        display "\n1) set environment variables 'DH_USER' and 'DH_KEY'"
+        display "2) create ~/.dreamyrc with user on first line and key on second\n\n"
+        exit 1
+      end
+      @credentials
+    end
+    
+
+  end
+
+end

data/lib/dreamy/commands/dns.rb

@@ -0,0 +1,48 @@
+module Dreamy::Command
+  class Dns < Base
+    
+    def list
+      dns = @account.dns
+      
+      if args.length > 0
+        filter = args.shift.downcase
+        dns = dns.select { |d| d.zone.match(filter) }
+      end
+      
+      if dns.empty?
+        display "No DNS records for this account or requested zone not found"
+      else
+        dns_table = table do |t|
+          t.headings = 'Record', 'Type', 'Value'
+          dns.each { |d| t << [d.record,d.type,d.value] if d.type != "TXT" }
+        end
+        display "NOTE: TXT records not displayed (too long)"
+        display dns_table
+      end
+    end
+    alias :index :list
+    
+    def add
+      if args.length == 3
+        record, type, value = args[0], args[1], args[2]
+        @account.dns_add(record,type,value)
+        display "Successfully added #{type} record of #{value} to #{record}"
+        display "Please wait for DNS to propagate"
+      else
+        display "Usage: dh dns:add [new record] [type] [value]"
+      end
+    end
+    
+    def remove
+      if args.length == 3
+        record, type, value = args[0], args[1], args[2]
+        @account.dns_remove(record,type,value)
+        display "Successfully removed #{type} record of #{value} to #{record}"
+        display "Please wait for DNS to propagate"
+      else
+        display "Usage: dh dns:remove [new record] [type] [value]"
+      end
+    end
+    
+  end
+end

data/lib/dreamy/commands/domains.rb

@@ -0,0 +1,61 @@
+require 'ping'
+
+module Dreamy::Command
+  class Domains < Base
+    
+    def index
+      http
+    end
+    
+    def http
+      domains = @account.domains.reject { |d| d.type != 'http'}
+      
+      if domains.empty?
+        display "No HTTP domains on this account"
+      else
+        domain_table = table do |t|
+          t.headings = 'Domain Name', 'Server', 'Type', 'User', 'WWW or Not'
+          domains.each { |d| t << [d.domain,d.short_home,d.hosting_type,d.user,d.www_or_not]}
+        end
+        display domain_table
+      end
+    end
+    
+    def mysql
+      domains = @account.domains.reject { |d| d.type != 'mysqldns'}
+      
+      if domains.empty?
+        display "No MySQL domains on this account"
+      else
+        domain_table = table do |t|
+          t.headings = 'Domain Name', 'Server'
+          domains.each { |d| t << [d.domain,d.short_home]}
+        end
+        display domain_table
+      end
+    end
+    
+    def status
+      domains = @account.domains
+      domains.each do |d|
+        if host_available?(d.domain)
+          display "#{d.domain} is up"
+        else
+          display "#{d.domain} is down!"
+          if host_available?(d.home)
+            display "  But its host server (#{d.home}) is up"
+          else
+            display "  And its host server (#{d.home}) is down"
+          end
+        end
+      end
+    end
+    
+    protected
+    
+    def host_available?(host)
+      Ping.pingecho host
+    end
+    
+  end
+end

data/lib/dreamy/commands/help.rb

@@ -0,0 +1,48 @@
+module Dreamy::Command
+	class Help < Base
+		def index
+			display usage
+		end
+
+		def usage
+			usage = <<EOTXT
+
+=== Commands
+ 
+ announce                           # list announce lists
+ announce:list <list>               # list all subscribers to <name> list
+ announce:add <list> <email>        # add subscriber with <email> to <list>
+ announce:remove <list> <email>     # remove subscriber with <email> from <list>
+
+ dns                                # list DNS records
+ dns <name>                         # list DNS records for <name>
+ dns:add <record> <type> <value>    # add DNS record 
+ dns:remove <record> <type> <value> # remove DNS record
+
+ domains:http                       # list HTTP domain details
+ domains:mysql                      # list MySQL domains
+ domains:status                     # check availability of all domains (pingability)
+ 
+ mysql:dbs                          # list MySQL database details
+ mysql:hosts                        # list MySQL database hostnames
+ mysql:users                        # list MySQL user details
+ 
+ ps                                 # list private servers
+ ps:add <web|mysql> <yes|no>        # adds a private server of type <web|mysql>. Yes = move data
+ ps:pending                         # list private servers scheduled to be created
+ ps:reboots <name>                  # list historical reboots for <name>
+ ps:reboot <name> now!              # reboot <name> now! (proceed with caution)
+ ps:remove                          # removes all pending private servers
+ ps:settings <name>                 # list settings for private server <name>
+ ps:set <name> <setting> <value>    # change <setting> on <name> to <value>
+ ps:size <name>                     # list historical memory sizes for <name>
+ ps:size <name> <value>             # set new memory <value> for <name>
+ ps:usage <name>                    # list historical memory & CPU usage for <name>
+ 
+ users                              # list user accounts: details
+ users:pw                           # list user accounts: usernames & passwords
+
+EOTXT
+		end
+	end
+end

data/lib/dreamy/commands/mysql.rb

@@ -0,0 +1,45 @@
+module Dreamy::Command
+  class Mysql < Base
+    
+    def dbs
+      dbs = @account.mysql_dbs
+      if dbs.empty?
+        display "No MySQL databases on this account"
+      else
+        db_table = table do |t|
+          t.headings = 'Name', 'Home', 'Description', 'Disk used (MB)'
+          dbs.each { |db| t << [db.name,db.home,db.description,db.disk_usage_mb]  }
+        end
+        display db_table
+      end
+    end
+    alias :index :dbs
+    
+    def hosts
+      hosts = @account.mysql_hosts
+      if hosts.empty?
+        display "No MySQL hosts on this account"
+      else
+        host_table = table do |t|
+          t.headings = 'Domain Name','Home'
+          hosts.each { |host| t << [host.domain,host.home]  }
+        end
+        display host_table
+      end
+    end
+    
+    def users
+      users = @account.mysql_users
+      if users.empty?
+        display "No MySQL users on this account"
+      else
+        user_table = table do |t|
+          t.headings = 'Username', 'Database', 'Sel', 'Ins', 'Upd', 'Del', 'Cre', 'Drop', 'Ind', 'Alt'
+          users.each { |u| t << [u.username,u.db,u.select,u.insert,u.update,u.delete,u.create,u.drop,u.index,u.alter]  }
+        end
+        display user_table
+      end
+    end
+    
+  end
+end

data/lib/dreamy/commands/ps.rb

@@ -0,0 +1,136 @@
+module Dreamy::Command
+  class Ps < Base
+    
+    def list
+      servers = @account.ps
+      
+      if servers.empty?
+        display "No private servers for this account"
+      else
+        servers_table = table do |t|
+          t.headings = 'Name', 'Type', 'Memory (MB)', 'Start Date'
+          servers.each { |ps| t << [ps.name,ps.type,ps.memory,ps.start_date]  }
+        end
+        display servers_table
+      end
+    end
+    alias :index :list
+    
+    def settings
+      if args.length == 1
+        settings = @account.ps_settings(args[0])
+        settings_table = table do |t|
+          t.headings = 'Setting', 'Value'
+          settings.each { |k,v| t << [k,v] }
+        end
+        display settings_table
+      else
+        display "Usage: dh ps:settings [ps name]"
+      end
+    end
+    
+    def set
+      if args.length == 3
+        name, setting, value = args[0], args[1], args[2]
+        @account.ps_set(name,setting,value)
+        display "Successfully set #{setting} to #{value} for #{name}"
+      else
+        display "Usage: dh ps:set [ps name] [setting] [value]"
+      end
+    end
+    
+    def size
+      case args.length
+        when 1
+        sizes = @account.ps_size_history(args[0])
+        sizes_table = table do |t|
+          t.headings = 'Time', 'Memory (MB)', 'Duration (Seconds)', 'Cost (Period)', 'Cost (Monthly)'
+          sizes.each { |s| t << [s["stamp"],s["memory_mb"],s["period_seconds"],s["period_cost"],s["monthy_cost"]] }
+        end
+        display sizes_table
+      when 2
+        name, new_size = args[0], args[1]
+        @account.ps_size_set(name,new_size)
+        display "Successfully set memory size to #{new_size} for #{name}"
+      else
+        display "Usage: dh ps:size [ps name] [new size (optional)]"
+      end
+    end
+    
+    def reboots
+      if args.length == 1
+        reboots = @account.ps_reboot_history(args[0])
+        reboots_table = table do |t|
+          t.headings = 'Count', 'Reboot Time'
+          reboots.each_with_index { |r,i| t << [i + 1,r] }
+        end
+        display reboots_table
+      else
+        display "Usage: dh ps:reboots [ps name]"
+      end
+    end
+    
+    def reboot
+      if args.length == 2
+        if args[1] == "now!"
+          @account.ps_reboot!(args[0])
+          display "Successfully sent reboot command for #{args[0]}"
+        else
+          display "Are you sure?? If yes, finish the command with 'now!'"
+        end
+      else
+        display "Usage: dh ps:reboot [ps name] now! (WARNING: this will reboot your server)"
+      end
+    end
+    
+    def usage
+      if args.length == 1
+        usages = @account.ps_usage(args[0])
+        usage_table = table do |t|
+          t.headings = 'Time', 'Memory (MB)', 'CPU Load'
+          usages.each { |u| t << [u["stamp"], u["memory_mb"],u["load"]] }
+        end
+        display usage_table
+      else
+        display "Usage: dh ps:usage [ps name]"
+      end
+    end
+    
+    def add
+      case args.length
+      when 1
+        if args[0] == "web"
+          display "you must specify 'yes' or 'no' for whether or not to move data to new server"
+        else
+          @account.ps_add(args[0])
+          display "Successfully requested new private mysql server"
+        end
+      when 2
+        type, move = args[0], args[1]
+        @account.ps_add(type,move)
+        display "Successfully requested new private server"
+      else
+        display "Usage: dh ps:add <web|mysql> <yes|no>"
+      end
+    end
+    
+    def remove
+      @account.ps_remove
+      display "Successfully removed all pending private server requests"
+    end
+    
+    def pending
+      pendings = @account.ps_pending
+      if pendings.empty?
+        display "You have no pending server creations"
+      else
+        pending_table = table do |t|
+          t.headings = 'Account', 'IP Address', 'Type', 'Time'
+          pendings.each { |p| t << [p["account_id"],p["ip"],p["type"],p["stamp"]]}
+        end
+        display pending_table
+      end
+    end
+    
+  end
+end