lumberg 0.9.5

data/lib/lumberg.rb

@@ -0,0 +1,23 @@
+$:.unshift(File.dirname(__FILE__))
+
+# External Libs
+require 'json'
+require 'uri'
+require 'net/http'
+require 'net/https'
+
+# Internal Libs
+require 'net_http_hacked'
+require 'lumberg/version'
+require 'lumberg/exceptions'
+require 'lumberg/whm/args'
+require 'lumberg/whm'
+
+module Lumberg
+  class << self
+    def base_path
+      File.dirname(__FILE__)
+    end
+  end
+end
+

data/lib/lumberg/exceptions.rb

@@ -0,0 +1,6 @@
+module Lumberg
+  # WHM Exception for when an argument is invalid, missing, etc.
+  class WhmArgumentError < ArgumentError; end
+  # WHM Exception for when a request is performed on an invalid user
+  class WhmInvalidUser < RuntimeError; end
+end

data/lib/lumberg/version.rb

@@ -0,0 +1,3 @@
+module Lumberg
+  VERSION = '0.9.5'
+end

data/lib/lumberg/whm.rb

@@ -0,0 +1,70 @@
+module Lumberg
+  module Whm
+    autoload :Base,     'lumberg/whm/base'
+    autoload :Server,   'lumberg/whm/server'
+    autoload :Account,  'lumberg/whm/account'
+    autoload :Dns,      'lumberg/whm/dns'
+    autoload :Reseller, 'lumberg/whm/reseller'
+
+    class << self
+
+      # Converts keys to symbols
+      def symbolize_keys(arg)
+        case arg
+          when Array
+            arg.map { |elem| symbolize_keys elem }
+          when Hash
+            Hash[
+              arg.map { |key, value|  
+                k = key.is_a?(String) ? key.gsub('-', '_').to_sym : key
+                v = symbolize_keys value
+                [k,v]
+              }]
+          else
+            arg
+        end
+      end
+    
+      # Recursively converts values of 0 or 1 to true or false
+      def to_bool(hash, *keys)
+        if keys.empty?
+          keys = [:all]
+        else
+          keys.flatten!
+        end
+
+        if hash.is_a?(Hash)
+          hash = Hash[
+            hash.map {|key, value|
+              # recurse
+              value = to_bool(value, keys) if value.is_a?(Hash)
+              value = value.map {|elem| to_bool(elem, keys) } if value.is_a?(Array)
+
+              if (keys.first == :all) || (keys.include?(key) || (keys.include?(key.to_sym)))
+                value = (value.to_s.match(/0|1/) ? value.to_i == 1 : value)
+              end
+              [key, value]
+          }]
+        end
+        hash
+      end
+
+      # Converts boolean values to 0 or 1
+      def from_bool(input)
+        if input == false
+          0
+        elsif input == true
+          1
+        elsif input.is_a?(Hash)
+          Hash[ 
+            input.map {|k,v| 
+              v = from_bool(v)
+              [k,v]
+            }
+          ]
+        end
+      end
+
+    end
+  end
+end

data/lib/lumberg/whm/account.rb

@@ -0,0 +1,329 @@
+module Lumberg
+  module Whm
+    # Some WHM functions require different params for the same 'thing'
+    # e.g. some accept 'username' while others accept 'user' 
+    # Be sure to keep our API consistent and work around those inconsistencies internally 
+    class Account < Base
+
+      # Creates a hosting account and sets up its associated domain information
+      #
+      # ==== Required 
+      #  * <tt>:username</tt> - PENDING
+      #  * <tt>:domain</tt> - PENDING
+      #  * <tt>:password</tt> - PENDING
+      #
+      # ==== Optional 
+      #  * <tt>:plan</tt> - PENDING
+      #  * <tt>:pkgname</tt> - PENDING
+      #  * <tt>:savepkg</tt> - PENDING
+      #  * <tt>:featurelist</tt> - PENDING
+      #  * <tt>:quota</tt> - PENDING
+      #  * <tt>:ip</tt> - PENDING
+      #  * <tt>:cgi</tt> - PENDING
+      #  * <tt>:</tt> - PENDING
+      def create(options = {})
+        Args.new(options) do |c|
+          c.requires  :username, :domain, :password
+          c.booleans  :savepkg, :ip, :cgi, :frontpage, :hasshell, :useregns, :reseller, :forcedns
+          c.optionals :plan, :pkgname, :savepkg, :featurelist, :quota, :ip, :cgi, 
+                       :frontpage, :hasshell, :contactemail, :cpmod, :maxftp, :maxsql, :maxpop, :maxlst, 
+                       :maxsub, :maxpark, :maxaddon, :bwlimit, :customip, :language, :useregns, :hasuseregns, 
+                       :reseller, :forcedns, :mxcheck
+        end
+
+        server.perform_request('createacct', options)
+      end
+
+      # Permanently removes a cPanel account
+      #
+      # ==== Required 
+      #  * <tt>:username</tt> - PENDING
+      def remove(options = {})
+        Args.new(options) do |c|
+          c.requires  :username
+          c.booleans  :keepdns
+        end
+
+        options[:user] = options.delete(:username)
+        server.perform_request('removeacct', options)
+      end
+
+      # Changes the password of a domain owner (cPanel) or reseller (WHM) account
+      #
+      # ==== Required 
+      #  * <tt>:username</tt> - PENDING
+      #  * <tt>:password</tt> - PENDING
+      def change_password(options = {})
+        Args.new(options) do |c|
+          c.requires  :username, :password
+          c.booleans  :db_pass_update
+        end
+
+        options[:user] = options.delete(:username)
+        options[:pass] = options.delete(:password)
+        server.perform_request('passwd', options.merge(:key => 'passwd'))
+      end
+
+      # Displays pertinent information about a specific account
+      #
+      # ==== Required 
+      #  * <tt>:username</tt> - PENDING
+      def summary(options = {})
+        Args.new(options) do |c|
+          c.requires  :username
+        end
+
+        options[:user] = options.delete(:username)
+        server.perform_request('accountsummary', options)
+      end
+
+      # Modifies the bandwidth usage (transfer) limit for a specific account
+      #
+      # ==== Required 
+      #  * <tt>:username</tt> - PENDING
+      #  * <tt>:bwlimit</tt> - PENDING
+      def limit_bandwidth(options = {})
+        Args.new(options) do |c|
+          c.requires :username, :bwlimit
+        end
+
+        verify_user(options[:username]) do
+          options[:user] = options.delete(:username)
+          server.perform_request('limitbw', options) do |s|
+            s.boolean_params = :unlimited, :bwlimitenable
+          end
+        end
+      end
+
+      # Lists all accounts on the server, and also allows you to search for a specific account or set of accounts
+
+      #
+      # ==== Optional 
+      #  * <tt>:searchtype</tt> - PENDING
+      #  * <tt>:search</tt> - PENDING
+      def list(options = {})
+        Args.new(options) do |c|
+          c.optionals :searchtype, :search
+        end
+
+        server.perform_request('listaccts', options) do |s|
+          s.boolean_params = :suspended
+        end
+      end
+
+      # Modifies settings for an account
+      #
+      # ==== Required 
+      #  * <tt>:username</tt> - PENDING
+      #
+      # ==== Optional 
+      #  * <tt>:domain</tt> - PENDING
+      #  * <tt>:newuser</tt> - PENDING
+      #  * <tt>:owner</tt> - PENDING
+      #  * <tt>:CPTHEME</tt> - PENDING
+      #  * <tt>:HASCGI</tt> - PENDING
+      #  * <tt>:LANG</tt> - PENDING
+      #  * <tt>:LOCALE</tt> - PENDING
+      #  * <tt>:MAXFTP</tt> - PENDING
+      #  * <tt>:MAXSQL</tt> - PENDING
+      #  * <tt>:MAXPOP</tt> - PENDING
+      #  * <tt>:MAXLST</tt> - PENDING
+      #  * <tt>:MAXSUB</tt> - PENDING
+      #  * <tt>:MAXPARK</tt> - PENDING
+      #  * <tt>:MAXADDON</tt> - PENDING
+      #  * <tt>:shell</tt> - PENDING
+      def modify(options = {})
+        Args.new(options) do |c|
+          c.requires :username
+          c.optionals :domain, :newuser, :owner, :CPTHEME, :HASCGI, :LANG, :LOCALE, :MAXFTP, :MAXSQL, :MAXPOP, :MAXLST, :MAXSUB, :MAXPARK, :MAXADDON, :shell
+        end
+
+        options[:user] = options.delete(:username)
+        server.perform_request('modifyacct', options) do |s|
+          s.boolean_params = :DEMO
+        end
+      end
+
+      # Changes an account's disk space usage quota
+      #
+      # ==== Required 
+      #  * <tt>:username</tt> - PENDING
+      #  * <tt>:quota</tt> - PENDING
+      def edit_quota(options = {})
+        Args.new(options) do |c|
+          c.requires :username, :quota
+        end
+
+        options[:user] = options.delete(:username)
+        server.perform_request('editquota', options)
+      end
+
+      # Adds a new hosting package
+      #
+      # ==== Required 
+      #  * <tt>:name</tt> - PENDING
+      #
+      # ==== Optional 
+      #  * <tt>:featurelist</tt> - PENDING
+      #  * <tt>:quota</tt> - PENDING
+      #  * <tt>:ip</tt> - PENDING
+      #  * <tt>:cgi</tt> - PENDING
+      #  * <tt>:frontpage</tt> - PENDING
+      #  * <tt>:cpmod</tt> - PENDING
+      #  * <tt>:language</tt> - PENDING
+      #  * <tt>:maxftp</tt> - PENDING
+      #  * <tt>:maxsql</tt> - PENDING
+      #  * <tt>:maxpop</tt> - PENDING
+      #  * <tt>:maxlists</tt> - PENDING
+      #  * <tt>:maxsub</tt> - PENDING
+      #  * <tt>:maxpark</tt> - PENDING
+      #  * <tt>:maxaddon</tt> - PENDING
+      #  * <tt>:hasshell</tt> - PENDING
+      #  * <tt>:bwlimit</tt> - PENDING
+      def add_package(options = {})
+        Args.new(options) do |c|
+          c.requires :name
+          c.optionals :featurelist, :quota, :ip, :cgi, :frontpage, :cpmod, :language, :maxftp, :maxsql, :maxpop, :maxlists, :maxsub, :maxpark, :maxaddon, :hasshell, :bwlimit
+          c.booleans :ip, :cgi, :frontpage, :hasshell
+        end
+
+        server.perform_request('addpkg', options)
+      end
+
+      # Changes the hosting package associated with a cPanel account
+      #
+      # ==== Required 
+      #  * <tt>:username</tt> - PENDING
+      #  * <tt>:pkg</tt> - PENDING
+      def change_package(options = {})
+        Args.new(options) do |c|
+          c.requires :username, :pkg
+        end
+
+        options[:user] = options.delete(:username)
+        server.perform_request('changepackage', options)
+      end
+
+      # Obtains user data for a specific domain
+      #
+      # ==== Required 
+      #  * <tt>:domain</tt> - PENDING
+      def domain_user_data(options = {})
+        Args.new(options) do |c|
+          c.requires :domain
+        end
+
+        server.perform_request('domainuserdata', options.merge(:key => 'userdata')) do |s|
+          s.boolean_params = :hascgi
+        end
+      end
+
+      # Prevents a cPanel user from accessing his or her account. Once an account is suspended, it can be un-suspended to allow a user to access the account again
+      #
+      # ==== Required 
+      #  * <tt>:username</tt> - PENDING
+      #
+      # ==== Optional 
+      #  * <tt>:reason</tt> - PENDING
+      def suspend(options ={})
+        Args.new(options) do |c|
+          c.requires  :username
+          c.optionals :reason
+        end
+
+        options[:user] = options.delete(:username)
+        server.perform_request('suspendacct', options)
+      end
+
+      # Unsuspend a suspended account. When a user's account is unsuspended, he or she will be able to access cPanel again
+      #
+      # ==== Required 
+      #  * <tt>:username</tt> - PENDING
+      def unsuspend(options ={})
+        Args.new(options) do |c|
+          c.requires  :username
+        end
+
+        options[:user] = options.delete(:username)
+        server.perform_request('unsuspendacct', options)
+      end
+
+      # Generates a list of suspended accounts
+      def list_suspended(options = {})
+        server.perform_request('listsuspended', options)
+      end
+
+      # Generates a list of features you are allowed to use in WHM. Each feature will display either a 1 or 0. You are only able to use features with a corresponding 1
+      #
+      # ==== Required 
+      #  * <tt>:username</tt> - PENDING
+      def privs(options ={})
+        Args.new(options) do |c|
+          c.requires  :username
+        end
+    
+        verify_user(options[:username]) do
+          resp = server.perform_request('myprivs', options.merge(:key => 'privs')) do |s|
+            s.boolean_params = :all
+          end
+          # if you get this far, it's successful
+          resp[:success] = true
+          resp
+        end
+      end
+
+      # Changes the IP address of a website, or a user account, hosted on your server
+      #
+      # ==== Required 
+      #  * <tt>:ip</tt> - PENDING
+      def set_site_ip(options = {})
+        Args.new(options) do |c|
+          c.requires :ip
+          c.one_of :username, :domain
+        end
+
+        options[:user] = options.delete(:username) if options[:username]
+        server.perform_request('setsiteip', options)
+      end
+
+      # Restores a user's account from a backup file. You may restore a monthly, weekly, or daily backup
+      #
+      # ==== Required 
+      #  * <tt>:username</tt> - PENDING
+      #  * <tt>:type</tt> - PENDING
+      #  * <tt>:all</tt> - PENDING
+      #  * <tt>:ip</tt> - PENDING
+      #  * <tt>:mail</tt> - PENDING
+      #  * <tt>:mysql</tt> - PENDING
+      #  * <tt>:subs</tt> - PENDING
+      def restore_account(options = {})
+        Args.new(options) do |c|
+          c.requires "api.version".to_sym, :username, :type, :all, :ip, :mail, :mysql, :subs
+          c.booleans :all, :ip, :mail, :mysql, :subs
+        end
+
+        options[:user] = options.delete(:username) if options[:username]
+        server.perform_request('restoreaccount', options.merge(:key => 'metadata'))
+      end
+
+      protected 
+      # Some WHM API methods always return a result, even if the user
+      # doesn't actually exist. This makes it seem like your request 
+      # was successful when it really wasn't
+      #
+      # Example
+      #   verify_user('bob') do
+      #      change_password()
+      #   end
+      def verify_user(username, &block)
+        exists = summary(:username => username)
+        if exists[:success]
+          yield
+        else
+          raise WhmInvalidUser, "User #{username} does not exist"
+        end
+      end
+
+    end
+  end
+end

data/lib/lumberg/whm/args.rb

@@ -0,0 +1,113 @@
+module Lumberg
+
+      #
+      # ==== Optional 
+      #  * <tt>:whatever</tt> - PENDING
+  module Whm
+    class Args
+      attr_reader :required_params, :boolean_params, :optional_params, :one_of_params
+      attr_reader :options
+      # Check the included hash for the included parameters.
+      # Raises WhmArgumentError when it's mising the proper params
+      #
+      # ==== Example
+      # 
+      #    Args.new(options) do |c|
+      #      c.requries  :user, :pass
+      #      c.booleans  :name
+      #      c.optionals :whatever
+      #    end
+      def initialize(options)
+        @required_params ||= []
+        @boolean_params  ||= []
+        @optional_params ||= []
+        @one_of_params   ||= []
+        @options = options
+
+        yield self 
+
+        requires!
+        booleans!
+        one_ofs!
+        valid_options!
+      end
+
+      # Specifies the required arguments
+      def requires(*values)
+        @optional_params.concat(values)
+        @required_params = values
+      end
+
+      # Specifies which arguments are boolean
+      def booleans(*values)
+        @optional_params.concat(values)
+        @boolean_params = values
+      end
+
+      # Specifies which arguments are optional
+      def optionals(*values)
+        @optional_params.concat(values)
+      end
+
+      # Specifies which arguments take one of a set of arguments
+      def one_of(*values)
+        @optional_params.concat(values)
+        @one_of_params = values 
+      end
+
+      protected
+
+      # Verifies that all required arguments are present
+      def requires!
+        @required_params.each do |param| 
+          key = (param.is_a?(Array) ? param.first : param)
+          verify_required_param(key)
+        end
+      end
+
+
+      # Checks to see if supplied params (which are booleans) contain
+      # either a 1 ("Yes") or 0 ("No") value.
+      def booleans!
+        @boolean_params.each do |param|
+          key = (param.is_a?(Array) ? param.first : param)
+          verify_boolean_param(key)
+        end
+      end
+
+      # Verifies that only valid arguments were set
+      def valid_options!
+        @options.keys.uniq.each do |key|
+          raise WhmArgumentError.new("Not a valid parameter: #{key}") unless @optional_params.include?(key)
+        end
+      end  
+
+      # Verifies that the one_of arguments were used correctly
+      def one_ofs!
+        if @one_of_params.size > 1
+          specified = @options.keys.select { |key| @one_of_params.include?(key) }.uniq
+          if specified.size > 1 || specified.size == 0
+            raise WhmArgumentError.new("The parameters may include only one of '#{@one_of_params.join(', ')}'") 
+          end
+        else
+          raise WhmArgumentError.new("One of requires two or more items") unless @one_of_params.empty?
+        end
+      end
+
+      private
+      
+      # Internal method for verifiying required arguments
+      def verify_required_param(param)
+        raise WhmArgumentError.new("Missing required parameter: #{param}") unless @options.has_key?(param) 
+        raise WhmArgumentError.new("Required parameter cannot be blank: #{param}") if (@options[param].nil? || (@options[param].respond_to?(:empty?) && @options[param].empty?))
+      end
+
+      # Internal method for verifying boolean arguments
+      def verify_boolean_param(param)
+        if @options.include?(param) && ![true, false].include?(@options[param])
+          raise WhmArgumentError.new("Boolean parameter must be \"true\" or \"false\": #{param}")
+        end
+      end
+    end
+  end
+end