dreamy 0.5.1

data/README.md

@@ -0,0 +1,159 @@
+What is it?
+===========
+
+[Dreamy][1] is Ruby library and command line tool for interfacing with [DreamHost's API][2]. The API itself is still very young so this is by no means a comprehensive library. Please fork and contribute!
+
+
+Install
+=======
+
+Grab the gem from GitHub
+
+    gem sources -a http://gems.github.com
+    gem install sant0sk1-dreamy
+
+Library Usage
+=============
+
+DreamHost requires a username (email or webID) and API key (available from your DH Panel) to make API requests. When creating a Dreamy instance you'll need to provide this data. The Dreamy command line tool (dh) gathers the necessary info from a configuration file or environment variables, but you can do it however you'd like.
+
+To get started with the library, just require the gem:
+
+    require 'rubygems'
+    require 'dreamy'
+    
+Create a new object using your username and API key.
+    
+    account = Dreamy::Base.new(username,api_key)
+    
+Fetch an array of Dreamy::Domain objects:
+
+    account.domains
+    
+Now that you have an array you can have your way with the data:
+
+    account.domains.each do |d|
+      puts d.domain
+      puts d.type
+      puts d.home
+    end
+    
+Same goes with Users, DNS records, announcement list subscribers, MySQL databases, MySQL hosts, and MySQL users
+    
+    # fetch an array of Dreamy::User objects
+    account.users
+    
+    # fetch an array of Dreamy::Dns objects
+    account.dns
+    
+    # fetch an array of Dreamy::AnnounceList objects
+    account.announce_lists 
+    
+    # fetch an array of Dreamy::Subscribers to an announcement list
+    account.announce_list(listname,domain)
+    
+    # fetch an array of Dreamy::MysqlUser objects
+    account.mysql_users
+    
+You can interact with announcement lists by adding and removing subscribers
+    
+    # add a new subscriber to an announcement list
+    account.announce_add(listname,domain,email)
+    
+    # remove a subscriber from an announcement list
+    account.announce_remove(listname,domain,email)
+    
+You can interact with DNS by adding and removing records
+
+    # add a new A record for a subdomain of an hosted domain
+    account.dns_add(subdomain,"A","123.321.123.321")
+    
+    # remove the A record just created
+    account.dns_remove(subdomain,"A","123.321.123.321")
+    
+You can interact with your Private Server in many different ways
+
+    # change a private server setting
+    account.ps_set(ps_name,setting,value)
+    
+    # set the memory size (MB)
+    account.ps_size_set(ps_name,"200")
+    
+    # reboot the server
+    account.ps_reboot!(ps_name)
+    
+Check the base class for all the different API calls.
+    
+More and more functions will be added as time allows. If there's something missing that you want in, please:
+
+fork -> commit -> pull request
+    
+Command Line Usage
+==================
+
+The Dreamy gem will install an executable called "dh". In order to use it, you'll need to set your DreamHost account username and API key. You can acquire an API key from the DreamHost panel. "dh" will fetch your API credentials from 2 places, respectively:
+
+1)  A file called .dreamyrc in your $HOME directory with username on line 1, api key on line 2
+
+An example ~/.dreamyrc would look like:
+
+    dh_user@gmail.com
+    34TGGGKBRG3YD1EA
+    
+2) Environment variables DH\_USER and DH\_KEY. You can set these by typing this in your shell:
+
+    export DH_USER=dh_user@gmail.com
+    export DH_KEY=34TGGGKBRG3YD1EA
+    
+If you want to make those environment variables permanent, add those 2 lines to the bottom of your ~/.bashrc
+
+
+Run this from the command line to print the usage:
+
+    dh help
+    
+    === 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
+
+     
+That's it for now. New commands should be springing up as Dreamy and the DreamHost API mature!
+
+TODO
+====
+
+* add real rdocs
+
+[1]:http://github.com/sant0sk1/dreamy
+[2]:http://wiki.Dreamy.com/API

data/Rakefile

@@ -0,0 +1,28 @@
+require 'rake'
+require 'rake/testtask'
+
+task :default => [:test_units]
+
+desc "Run basic tests"
+Rake::TestTask.new("test_units") { |t|
+  t.pattern = 'test/*_test.rb'
+  t.verbose = true
+  t.warning = true
+}
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "dreamy"
+    gemspec.summary = "A Ruby library and command line tool for accessing DreamHost's API"
+    gemspec.email = "jerod.santo@gmail.com"
+    gemspec.homepage = "http://github.com/sant0sk1/dreamy"
+    gemspec.authors = ["Jerod Santo"]
+    gemspec.add_dependency('visionmedia-terminal-table', '>= 1.0.5')
+    gemspec.add_dependency('hpricot', '>= 0.7')
+    gemspec.add_dependency('uuid', '>= 2.0.1')
+    gemspec.files.exclude 'test/credentials.yml'
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/VERSION.yml

@@ -0,0 +1,4 @@
+--- 
+:minor: 5
+:patch: 1
+:major: 0

data/bin/dh

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'dreamy'
+require 'dreamy/command'
+
+args = ARGV.dup
+ARGV.clear
+command = args.shift.strip rescue 'help'
+
+Dreamy::Command.run(command, args)

data/lib/dreamy.rb

@@ -0,0 +1,27 @@
+require 'uri'
+require 'net/https'
+require 'yaml'
+require 'rubygems'
+require 'hpricot'
+require 'uuid'
+
+
+$:.unshift(File.dirname(__FILE__) + "/dreamy")
+require 'dreamy/core_extensions'
+require 'dreamy/easy_class_maker'
+require 'dreamy/base'
+require 'dreamy/domain'
+require 'dreamy/dns'
+require 'dreamy/announce_list'
+require 'dreamy/private_server'
+require 'dreamy/subscriber'
+require 'dreamy/user'
+require 'dreamy/mysql/db'
+require 'dreamy/mysql/host'
+require 'dreamy/mysql/user'
+
+module Dreamy
+    class CantConnect < StandardError; end
+    class Unavailable < StandardError; end
+    class ApiError    < StandardError; end
+end

data/lib/dreamy/announce_list.rb

@@ -0,0 +1,19 @@
+module Dreamy
+  class AnnounceList
+    include EasyClassMaker
+
+    attributes  :account_id, :name, :domain, :short_name, :start_date, :max_bounces, :subscribers
+
+    def self.new_from_xml(xml)
+      l = new
+      l.account_id      = (xml).at('account_id').innerHTML.to_i
+      l.short_name      = (xml).at('listname').innerHTML
+      l.domain          = (xml).at('domain').innerHTML
+      l.name            = (xml).at('name').innerHTML
+      l.start_date      = (xml).at('start_date').innerHTML
+      l.max_bounces     = (xml).at('max_bounces').innerHTML.to_i
+      l.subscribers     = (xml).at('num_subscribers').innerHTML.to_i
+      l
+    end
+  end
+end

data/lib/dreamy/base.rb

@@ -0,0 +1,234 @@
+module Dreamy
+  class Base
+
+    @@host = "api.dreamhost.com"
+
+    def initialize(username, key)
+      @username = username
+      @key      = key
+    end
+
+    # returns an array of domain objects
+    def domains
+      doc = request("domain-list_domains")
+      api_error?(doc)
+      (doc/:data).inject([]) { |domains, domain| domains << Domain.new_from_xml(domain); domains }
+    end
+
+    # returns an array of user objects
+    def users(passwords=false)
+      if passwords
+        doc = request("user-list_users")
+      else
+        doc = request("user-list_users_no_pw")
+      end
+      api_error?(doc)
+      (doc/:data).inject([]) { |users, user| users << User.new_from_xml(user); users }
+    end
+
+    # returns an array of dns objects
+    def dns
+      doc = request("dns-list_records")
+      api_error?(doc)
+      (doc/:data).inject([]) { |records, dns| records << Dns.new_from_xml(dns); records }
+    end
+    
+    def dns_add(record,type,value)
+      doc = request("dns-add_record", {"record" => record, "type" => type, "value" => value})
+      api_error?(doc)
+      true
+    end
+    
+    def dns_remove(record,type,value)
+      doc = request("dns-remove_record", {"record" => record, "type" => type, "value" => value})
+      api_error?(doc)
+      true
+    end
+    
+    def announce_lists
+      doc = request("announcement_list-list_lists")
+      api_error?(doc)
+      (doc/:data).inject([]) { |lists, list| lists << AnnounceList.new_from_xml(list); lists }
+    end
+    
+    # returns an array of subscriber objects
+    def announce_list(listname,domain)
+      doc = request("announcement_list-list_subscribers",{ "listname" => listname, "domain" => domain})
+      api_error?(doc)
+      (doc/:data).inject([]) { |subs, sub| subs << Subscriber.new_from_xml(sub); subs }
+    end
+    
+    # adds new subscriber to announce list
+    def announce_add(listname,domain,email,name="")
+      doc = request("announcement_list-add_subscriber",
+                      {"listname" => listname, "domain" => domain, "email" => email, "name" => name})
+      api_error?(doc)
+      true
+    end
+    
+    def announce_remove(listname,domain,email)
+      doc = request("announcement_list-remove_subscriber",
+                      {"listname" => listname, "domain" => domain, "email" => email})
+      api_error?(doc)
+      true
+    end
+
+    # options:
+    #   stamp        - the time to send the message, like "2009-05-28" or "2009-05-28 14:24:36"
+    #   charset      - the character set in which the message is encoded
+    #   type         - the format of the message, either "text" or "html"
+    #   duplicate_ok - whether to allow duplicate messages to be sent, like 1 or 0
+    def announce_post(listname,domain,subject,message,name,options={})
+      values = {
+        "listname" => listname,
+        "domain" => domain,
+        "subject" => subject,
+        "message" => message,
+        "name" => name
+      }.merge(options)
+      doc = request("announcement_list-post_announcement", values, true)
+      api_error?(doc)
+      true
+    end
+    
+    def mysql_dbs
+      doc = request("mysql-list_dbs")
+      api_error?(doc)
+      (doc/:data).inject([]) { |dbs, db| dbs << MysqlDb.new_from_xml(db); dbs }
+    end
+    
+    def mysql_hosts
+      doc = request("mysql-list_hostnames")
+      api_error?(doc)
+      (doc/:data).inject([]) { |hosts, host| hosts << MysqlHost.new_from_xml(host); hosts }
+    end
+    
+    def mysql_users
+      doc = request("mysql-list_users")
+      api_error?(doc)
+      (doc/:data).inject([]) { |users, user| users << MysqlUser.new_from_xml(user); users }
+    end
+    
+    def ps
+      doc = request("dreamhost_ps-list_ps")
+      api_error?(doc)
+      (doc/:data).inject([]) { |servers, server| servers << PrivateServer.new_from_xml(server); servers }
+    end
+    
+    def ps_settings(name)
+      doc = request("dreamhost_ps-list_settings", {"ps" => name})
+      api_error?(doc)
+      PrivateServer.settings_from_xml(doc)
+    end
+    
+    def ps_set(name,setting,value)
+      doc = request("dreamhost_ps-set_settings", {"ps" => name, setting => value})
+      api_error?(doc)
+      true
+    end
+    
+    def ps_size_history(name)
+      doc = request("dreamhost_ps-list_size_history", {"ps" => name})
+      api_error?(doc)
+      (doc/:data).inject([]) { |sizes, size| sizes << PrivateServer.size_from_xml(size); sizes }
+    end
+    
+    def ps_size_set(name,size)
+      doc = request("dreamhost_ps-set_size", {"ps" => name, "size" => size})
+      api_error?(doc)
+      true
+    end
+    
+    def ps_reboot_history(name)
+      doc = request("dreamhost_ps-list_reboot_history", {"ps" => name})
+      api_error?(doc)
+      (doc/:data).inject([]) { |reboots,reboot| reboots << reboot.at('stamp').innerHTML; reboots }
+    end
+    
+    def ps_reboot!(name)
+      doc = request("dreamhost_ps-reboot", {"ps" => name})
+      api_error?(doc)
+      true
+    end
+    
+    def ps_usage(name)
+      doc = request("dreamhost_ps-list_usage", {"ps" => name})
+      api_error?(doc)
+      (doc/:data).inject([]) { |usages, usage| usages << PrivateServer.usage_from_xml(usage); usages }
+    end
+    
+    def ps_add(type,movedata="no")
+      doc = request("dreamhost_ps-add_ps", {"type" => type, "movedata" => movedata})
+      api_error?(doc)
+      true
+    end
+    
+    def ps_remove
+      doc = request("dreamhost_ps-remove_pending_ps")
+      api_error?(doc)
+      true
+    end
+    
+    def ps_pending
+      doc = request("dreamhost_ps-list_pending_ps")
+      api_error?(doc)
+      (doc/:data).inject([]) { |pends, pend| pends << PrivateServer.pending_from_xml(pend); pends }
+    end
+
+    private
+    
+    def api_error?(doc)
+      raise ApiError, (doc/:data).innerHTML if (doc/:result).innerHTML == "error"
+    end
+
+    def request(cmd,values={},use_post=false)
+      handle_response!(response(cmd,values,use_post))
+    end
+
+    def response(cmd,values={},use_post=false)
+      values = {
+        "username"  => @username,
+        "key"       => @key,
+        "cmd"       => cmd,
+        "format"    => "xml",
+        "unique_id" => UUID.new.generate
+      }.merge(values)
+
+      http = Net::HTTP.new(@@host, 443)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+      begin
+        # puts path
+        response = if use_post
+          request = Net::HTTP::Post.new("/")
+          request.form_data = values
+          http.request(request)
+        else
+          path = "/?#{values.to_param_array.join("&")}"
+          http.get(path)
+        end
+      rescue => error
+        raise CantConnect, error.message
+      end
+    end
+
+    def handle_response!(response)
+      if %w[200 304].include?(response.code)
+        response = parse(response.body)
+      elsif response.code == '503'
+        raise Unavailable, response.message
+      elsif response.code == '401'
+        raise CantConnect, 'Authentication failed. Check your username and password'
+      else
+        raise CantConnect, "Dreamy is returning a #{response.code}: #{response.message}"
+      end
+    end
+
+    # Converts a string response into an Hpricot xml element.
+    def parse(response)
+      Hpricot.XML(response || '')
+    end
+
+  end
+end