lumberg 1.0.1 → 2.0.0.pre4

data/lib/lumberg/whm/server.rb

@@ -1,5 +1,4 @@
-require 'cgi'
-require 'base64'
+Faraday.register_middleware :response, :format_whm => Lumberg::FormatWhm
 
 module Lumberg
   module Whm
@@ -19,9 +18,6 @@ module Lumberg
       # API username - :default => root
       attr_accessor :user
 
-      # Raw HTTP response from WHM
-      attr_accessor :raw_response
-
       # WHM parsed response
       attr_reader :response
 
@@ -43,58 +39,49 @@ module Lumberg
       # Force response type...ARG!
       attr_accessor :force_response_type
 
+      # HTTP read/open timeout
+      attr_accessor :timeout
+
       #
-      # ==== Required 
+      # ==== Required
       #  * <tt>:host</tt> - PENDING
       #  * <tt>:hash</tt> - PENDING
       #
-      # ==== Optional 
+      # ==== Optional
       #  * <tt>:user</tt> - PENDING
       #  * <tt>:ssl</tt> - PENDING
       #  * <tt>:basic_auth</tt>
       def initialize(options)
-        Args.new(options) do |c|
-          c.requires  :host, :hash
-          c.optionals :user, :ssl, :basic_auth
-        end
-
         @ssl_verify ||= false
         @ssl        = options.delete(:ssl)
         @host       = options.delete(:host)
         @hash       = format_hash(options.delete(:hash))
         @user       = (options.has_key?(:user) ? options.delete(:user) : 'root')
-        @basic_auth = options.has_key?(:basic_auth) && options.delete(:basic_auth)
+        @basic_auth = options.delete(:basic_auth)
+        @timeout    = options.delete(:timeout)
+
+        validate_server_host
 
         @base_url   = format_url(options)
       end
 
       def perform_request(function, options = {})
-        @function = function
-
         # WHM sometime uses different keys for the result hash
-        @key  = options.delete(:key) || 'result'
-
+        @response_key = options.delete(:response_key) || 'result'
+        @function = function
         @params   = format_query(options)
-        uri       = URI.parse("#{@base_url}#{function}?#{@params}")
 
         yield self if block_given?
 
-        req = prepare_request(uri)
-
-        # Do the request
-        res = do_request(uri, req)
-
-        @raw_response = res
-        @response     = JSON.parse(@raw_response.body)
-        format_response
+        do_request(@base_url, function, @params)
       end
 
       def get_hostname
-        perform_request('gethostname', {:key => 'hostname'})
+        perform_request('gethostname', {:response_key => 'hostname'})
       end
 
       def version
-        perform_request('version', {:key => 'version'})
+        perform_request('version', {:response_key => 'version'})
       end
 
       def load_average
@@ -105,267 +92,161 @@ module Lumberg
       end
 
       def system_load_average(options = {})
-        Args.new(options) do |c|
-          c.requires "api.version".to_sym
-        end
-
-        perform_request('systemloadavg', options.merge(:key => 'data'))
+        perform_request('systemloadavg', options.merge(:response_key => 'data'))
       end
 
       def languages
-        perform_request('getlanglist', {:key => 'lang'})
+        perform_request('getlanglist', {:response_key => 'lang'})
+      end
+
+      def themes
+        perform_request('getlanglist', {:response_key => 'themes'})
       end
 
       def list_ips
-        perform_request('listips', {:key => 'result'})
+        perform_request('listips', {:response_key => 'result'})
       end
 
-      def add_ip(options = {})
-        Args.new(options) do |c|
-          c.requires :ip, :netmask
-        end
+      def get_tweaksetting(options = {})
+        request = perform_request('get_tweaksetting',
+          options.merge(
+            :response_key  => 'data',
+            :'api.version' => 1
+          )
+        )
 
-        perform_request('addip', options.merge(:key => 'addip'))
+        request[:success] = !request[:params].empty?
+        request
       end
 
-      def delete_ip(options = {})
-        Args.new(options) do |c|
-          c.requires :ip
-          c.optionals :ethernetdev
-          c.booleans :skipifshutdown
-        end
+      def set_tweaksetting(options = {})
+        request = perform_request('set_tweaksetting',
+          options.merge(
+            :response_key  => 'metadata',
+            :'api.version' => 1
+          )
+        )
 
-        perform_request('delip', options.merge(:key => 'delip'))
+        request[:success] = (request[:params][:reason] == 'OK')
+        request
       end
 
-      def set_hostname(options = {})
-        Args.new(options) do |c|
-          c.requires :hostname
-        end
+      def add_ip(options = {})
+        perform_request('addip', options.merge(:response_key => 'addip'))
+      end
 
-        perform_request('sethostname', options.merge(:key => 'sethostname'))
+      def delete_ip(options = {})
+        perform_request('delip', options.merge(:response_key => 'delip'))
       end
 
-      def set_resolvers(options = {})
-        Args.new(options) do |c|
-          c.requires :nameserver1
-          c.optionals :nameserver2, :nameserver3
-        end
+      def set_hostname(options = {})
+        perform_request('sethostname', options.merge(:response_key => 'sethostname'))
+      end
 
-        perform_request('setresolvers', options.merge(:key => 'setresolvers'))
+      def set_resolvers(options = {})
+        perform_request('setresolvers', options.merge(:response_key => 'setresolvers'))
       end
 
       def show_bandwidth(options = {})
-        Args.new(options) do |c|
-          c.optionals :month, :year, :showres, :search, :searchtype
-        end
-
-        perform_request('showbw', options.merge(:key => 'bandwidth'))
+        perform_request('showbw', options.merge(:response_key => 'bandwidth'))
       end
 
       def set_nv_var(options = {})
-        Args.new(options) do |c|
-          c.requires :key
-          c.optionals :value
-        end
-
-        perform_request('nvset', options.merge(:key => 'nvset'))
+        perform_request('nvset', options.merge(:response_key => 'nvset'))
       end
 
       def get_nv_var(options = {})
-        Args.new(options) do |c|
-          c.requires :key
-          c.optionals :value
-        end
-
-        perform_request('nvget', options.merge(:key => 'nvget'))
+        perform_request('nvget', options.merge(:response_key => 'nvget'))
       end
 
       def reboot
-        perform_request('reboot', {:key => "reboot"})
+        perform_request('reboot', {:response_key => "reboot"})
       end
 
-      protected
-      def response_type
-        if !@force_response_type.nil?
-          @force_response_type
-        elsif !@response.respond_to?(:has_key?)
-          :unknown
-        elsif @response.has_key?('error')
-          :error
-        elsif @response.has_key?(@key)
-          :action
-        elsif @response.has_key?('status') && @response.has_key?('statusmsg')
-          :query
-        else
-          :unknown
-        end
+      def account
+        @account ||= Account.new(:server => self)
       end
 
-      def format_response
-        success, message, params = false, nil, {}
-
-        case response_type
-          when :action
-            success, message, params = format_action_response
-          when :query
-            success, message, params = format_query_response
-          when :error
-            message = @response['error']
-          when :unknown
-            message = "Unknown error occurred #{@response.inspect}"
-        end
- 
-        params = Whm::to_bool(params, @boolean_params) unless @boolean_params.nil?
-
-        # Reset this for subsequent requests
-        @force_response_type = nil
-        {:success => success, :message => message, :params => Whm::symbolize_keys(params)}
+      def dns
+        @dns ||= Dns.new(:server => self)
       end
 
-      def format_url(options = {})
-        @ssl = true if @ssl.nil?
-        port  = (@ssl ? 2087 : 2086)
-        proto = (@ssl ? 'https' : 'http')
-
-        "#{proto}://#{@host}:#{port}/json-api/"
+      def reseller
+        @reseller ||= Reseller.new(:server => self)
       end
 
-      def format_hash(hash)
-        raise Lumberg::WhmArgumentError.new("Missing WHM hash") unless hash.is_a?(String)
-        hash.gsub(/\n|\s/, '')
-      end
-
-      def format_query(hash)
-        elements = []
-        hash.each do |key, value|
-          value = 1 if value === true
-          value = 0 if value === false
-          elements << "#{CGI::escape(key.to_s)}=#{CGI::escape(value.to_s)}"
-        end
-        elements.sort.join('&')
+      def cert
+        @cert ||= Cert.new(:server => self)
       end
 
-      private
+    private
 
-      def do_request(uri, req)
-        begin
-          Net::HTTP.skip_bad_headers = true
-          http = Net::HTTP.new(uri.host, uri.port)
-          http.set_debug_output($stderr) if ENV['LUMBERG_DEBUG']
-
-          enable_ssl(http) if uri.port == 2087
-
-          http.start do |h|
-            h.request(req)
-          end
-        rescue Exception => e
-          puts "Error when sending the request. 
-                 Enable debug output by setting the environment variable LUMBERG_DEBUG and try again."
-          raise e
-        ensure
-          Net::HTTP.skip_bad_headers = false
-        end
-      end
-
-      def format_action_response
-        # Some API methods ALSO return a 'status' as
-        # part of a result. We only use this value if it's
-        # part of the results hash
-        item = @response[@key]
-
-        unless item.is_a?(Array) || item.is_a?(Hash)
-          res = {@key => item}
-          success, message = true, ""
-        else
-          result = nil
-          if item.first.is_a?(Hash)
-            result = item.first
-            res = (item.size > 1 ? item.dup : item.first.dup)
+      def do_request(uri, function, params)
+        @response = Faraday.new(:url => uri, :ssl => ssl_options) do |c|
+          if basic_auth
+            c.basic_auth @user, @hash
           else
-            res = item.dup
-
-            # more hacks for WHM silly API
-            if @response.has_key?('result')
-              result_node = @response['result']
-              node_with_key_status = result_node.is_a?(Hash) && result_node.has_key?('status')
-              result = (node_with_key_status ? result_node : result_node.first)
-            else
-              res.delete('status')
-              res.delete('statusmsg')
-            end
+            c.headers['Authorization'] = "WHM #{@user}:#{@hash}"
           end
 
-          unless result.nil?
-            success = result['status'].to_i == 1
-            message = result['statusmsg']
-          end
-        end
-
-        return success, message, res
+          c.params = params
+          c.request :url_encoded
+          c.response :format_whm, @force_response_type, @response_key, @boolean_params
+          c.response :logger, create_logger_instance
+          c.response :json
+          c.adapter :net_http
+          c.options[:timeout] = timeout if timeout
+        end.get(function).body
+        @force_response_type = nil
+        @response
       end
 
-      def format_query_response
-        success = @response['status'].to_i == 1
-        message = @response['statusmsg']
-
-        # returns the rest as a params arg
-        res = @response.dup
-        res.delete('status')
-        res.delete('statusmsg')
-
-        return success, message, res
+      def format_query(hash)
+        hash.inject({}) do |params, (key, value)|
+          value = 1 if value === true
+          value = 0 if value === false
+          params[key] = value
+          params
+        end
       end
 
-      # Creates WHM::Whatever.new(:server => @server)
-      # automagically
-      def auto_accessors
-        [:account, :dns, :reseller]
+      def create_logger_instance
+        Logger.new(Lumberg.configuration[:debug].is_a?(TrueClass) ? $stderr : Lumberg.configuration[:debug])
       end
 
-      def method_missing(meth, *args, &block)
-        if auto_accessors.include?(meth.to_sym)
-          ivar = instance_variable_get("@#{meth}")
-          if ivar.nil?
-            constant = Whm.const_get(meth.to_s.capitalize)
-            return instance_variable_set("@#{meth}", constant.new(:server => self))
-          else
-            return ivar
-          end
+      def ssl_options
+        if @ssl_verify
+          {
+            :verify_mode => OpenSSL::SSL::VERIFY_PEER,
+            :ca_file     => File.join(Lumberg::base_path, "cacert.pem")
+          }
         else
-          super
+          {
+            :verify_mode => OpenSSL::SSL::VERIFY_NONE
+          }
         end
       end
 
-      def prepare_request(uri)
-        # Setup request URL
-        url = uri.path
-        query = uri.query
-        url << "?" + query unless query.nil? || query.empty?
-
-        req = Net::HTTP::Get.new(url)
+      def format_url(options = {})
+        @ssl = true if @ssl.nil?
+        port  = (@ssl ? 2087 : 2086)
+        proto = (@ssl ? 'https' : 'http')
 
-        # Add Auth Header
-        if basic_auth
-          encoded = Base64.encode64("#{@user}:#{@hash}")
-          auth = "Basic #{encoded}"
-        else
-          auth = "WHM #{@user}:#{@hash}"
-        end
-        req.add_field("Authorization", auth)
-        req
+        "#{proto}://#{@host}:#{port}/json-api/"
       end
 
-      def enable_ssl(http)
-        if @ssl_verify
-          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
-          http.ca_file = File.join(Lumberg::base_path, "cacert.pem")
-        else
-          http.verify_mode = OpenSSL::SSL::VERIFY_NONE
-        end
-        http.use_ssl = true 
+      def format_hash(hash)
+        raise Lumberg::WhmArgumentError.new("Missing WHM hash") unless hash.is_a?(String)
+        hash.gsub(/\n|\s/, '')
       end
 
+      def validate_server_host
+        Resolv.getaddress(@host)
+      rescue Resolv::ResolvError
+        raise Lumberg::WhmArgumentError.new(
+          "Unable to resolve #{@host}"
+        )
+      end
     end
   end
 end

data/lib/lumberg/whm.rb

@@ -5,6 +5,7 @@ module Lumberg
     autoload :Account,  'lumberg/whm/account'
     autoload :Dns,      'lumberg/whm/dns'
     autoload :Reseller, 'lumberg/whm/reseller'
+    autoload :Cert,      'lumberg/whm/cert'
 
     class << self
 
@@ -24,7 +25,7 @@ module Lumberg
             arg
         end
       end
-    
+
       # Recursively converts values of 0 or 1 to true or false
       def to_bool(hash, *keys)
         if keys.empty?

data/lib/lumberg.rb

@@ -1,23 +1,49 @@
 $:.unshift(File.dirname(__FILE__))
 
 # External Libs
+require 'openssl'
 require 'json'
 require 'uri'
-require 'net/http'
-require 'net/https'
+require 'faraday'
+require 'faraday_middleware'
+require 'logger'
+require 'resolv'
 
 # Internal Libs
-require 'net_http_hacked'
+require 'lumberg/format_whm'
 require 'lumberg/version'
 require 'lumberg/exceptions'
-require 'lumberg/whm/args'
+require 'lumberg/config'
 require 'lumberg/whm'
+require 'lumberg/cpanel'
 
 module Lumberg
-  class << self
-    def base_path
-      File.dirname(__FILE__)
-    end
+
+  extend self
+
+  attr_accessor :configuration
+
+  def base_path
+    File.dirname(__FILE__)
   end
+
+  self.configuration ||= Lumberg::Config.new
+
+   # Specificy the config via block
+   #
+   # ==== Attributes
+   #
+   # * +debug+ - Set to true to log debug info to $stderr, or a file path
+   #
+   # ==== Example
+   #
+   #   Lumberg.config do |c|
+   #     c.dubug "path/to/file.log"
+   #   end
+   def config
+     yield self.configuration if block_given?
+     self.configuration.options
+   end
+
 end
 

data/lumberg.gemspec

@@ -11,14 +11,17 @@ Gem::Specification.new do |s|
   s.homepage    = ""
   s.summary     = %q{Ruby library for the WHM & cPanel API}
   s.description = %q{Ruby library for the WHM & cPanel API; It's not a half day or anything like that}
+  s.license     = 'MIT'
 
   s.rubyforge_project = "lumberg"
 
-  s.add_dependency 'json'
+  s.add_runtime_dependency 'json', '~> 1.7.3'
+  s.add_runtime_dependency 'faraday', '~> 0.8.8'
+  s.add_runtime_dependency 'faraday_middleware', '~> 0.9.0'
   s.add_runtime_dependency('jruby-openssl', '~> 0.7.3') if RUBY_PLATFORM == 'java'
-  s.add_development_dependency 'rspec', '~> 2.8.0'
-  s.add_development_dependency 'fakeweb', '~> 1.3.0'
-  s.add_development_dependency 'vcr', '~> 1.11.3'
+  s.add_development_dependency 'rspec', '~> 2.10.0'
+  s.add_development_dependency 'webmock', '~> 1.8.7'
+  s.add_development_dependency 'vcr', '~> 2.4.0'
   s.add_development_dependency 'rake', '~> 0.9.2.2'
 
   s.files         = `git ls-files`.split("\n")

data/spec/config_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Lumberg::Config do
+  before(:each) do
+    @config = Lumberg::Config.new
+  end
+
+  describe "#new" do
+    it "sets up the @config hash" do
+      @config.options.should == {}
+    end
+  end
+
+  describe "#[]" do
+    it "behaves like an array" do
+      @config.options[:something] = 1
+      @config[:something].should == 1
+    end
+  end
+
+  describe "#debug" do
+    it "configures net/http to log to console" do
+      @config.options[:debug].should be_nil
+      @config.debug true
+      @config.options[:debug].should == true
+    end
+  end
+end

data/spec/cpanel/addon_domain_spec.rb

@@ -0,0 +1,84 @@
+require "spec_helper"
+
+module Lumberg
+  describe Cpanel::AddonDomain do
+    before(:each) do
+      @login    = { :host => @whm_host, :hash => @whm_hash }
+      @server   = Whm::Server.new(@login.dup)
+
+      @api_username = "lumberg"
+      @addond = Cpanel::AddonDomain.new(
+        :server       => @server.dup,
+        :api_username => @api_username
+      )
+    end
+
+    describe "#remove" do
+      use_vcr_cassette "cpanel/addon_domain/remove"
+
+      it "removes an addon domain" do
+        # Create the addon domain to be removed
+        @addond.add(
+          :dir       => "public_html/test-addon.com/",
+          :newdomain => "test-addon.com",
+          :subdomain => "testadd"
+        )
+
+        result = @addond.remove(
+          :domain    => "test-addon.com",
+          :subdomain => "testadd_lumberg-test.com"
+        )
+
+        result[:params][:data][0][:result].should == 1
+      end
+
+    end
+
+    describe "#add" do
+      use_vcr_cassette "cpanel/addon_domain/add"
+
+      it "adds an addon domain" do
+        result = @addond.add(
+          :dir       => "public_html/test-magic.com/",
+          :newdomain => "test-magic.com",
+          :subdomain => "tmagic"
+        )
+        result[:params][:data][0][:result].should == 1
+
+        # Remove the addon domain
+        result = @addond.remove(
+          :domain    => "test-magic.com",
+          :subdomain => "tmagic_lumberg-test.com"
+        )
+      end
+    end
+
+    describe "#list" do
+      use_vcr_cassette "cpanel/addon_domain/list"
+
+      context "addon domains exist on the account" do
+        let(:result) { @addond.list }
+        subject { result[:params][:data] }
+
+        it "returns an array with info for each addon domain" do
+          subject.should be_an(Array)
+          subject.each {|info|
+            info.keys.should include(
+              :domainkey, :status, :dir, :reldir, :subdomain, :rootdomain,
+              :fullsubdomain, :domain, :basedir
+            )
+          }
+        end
+      end
+
+      context "addon domains do not exist on the account" do
+        before { @addond.api_username = "minimal" }
+        after { @addond.api_username = "lumberg" }
+
+        it "returns an empty array" do
+          @addond.list[:params][:data].should be_empty
+        end
+      end
+    end
+  end
+end

data/spec/cpanel/backups_spec.rb

@@ -0,0 +1,22 @@
+require "spec_helper"
+
+module Lumberg
+  describe Cpanel::Backups do
+    let(:server) { Whm::Server.new(:host => @whm_host, :hash => @whm_hash) }
+    let(:api_username) { "lumberg" }
+    let(:backups) do
+      described_class.new(
+        :server       => server,
+        :api_username => api_username
+      )
+    end
+
+    describe "#list" do
+      use_vcr_cassette("cpanel/backups/list")
+
+      subject { backups.list[:params][:data] }
+
+      it { should be_an(Array) }
+    end
+  end
+end