rea-netscaler-cli 0.5.9

data/lib/netscaler/errors.rb

@@ -0,0 +1,7 @@
+
+module Netscaler
+  Error = Class.new(RuntimeError)
+
+  ConfigurationError = Class.new(Netscaler::Error)
+  TransactionError = Class.new(Netscaler::Error)
+end

data/lib/netscaler/executor.rb

@@ -0,0 +1,28 @@
+require 'netscaler/errors'
+require 'netscaler/logging'
+require 'netscaler/transaction'
+require 'json'
+
+module Netscaler
+  class Executor
+    
+    def initialize(request_class)
+      @request_class = request_class
+    end
+
+    def execute!(args, options)
+      Netscaler::Logging.configure(options[:debug])
+
+      Netscaler::Transaction.new options[:netscaler] do |client|
+        @request_class.new(client).send(options[:action], args[0], options) do |response|
+          if options[:json]
+            puts JSON.pretty_generate(response)
+          else
+            STDERR.puts "Tempoararily disabled stdout. Use --json instead.  Sorry...."
+            # puts Hirb::Helpers::Tree.render(response)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/netscaler/logging.rb

@@ -0,0 +1,47 @@
+require 'rubygems'
+require 'log4r'
+require 'savon'
+
+module Netscaler
+  # A convenient module for mixins that allow to
+  # share the logging configuration everywhere
+  # easily
+  module Logging
+    @@log = nil
+
+    def Logging.configure(debug)
+      if @@log.nil?
+        @@log = Log4r::Logger.new 'netscaler'
+        @@log.outputters = Log4r::Outputter.stderr
+        @@log.level = Log4r::WARN
+        Log4r::Outputter.stderr.formatter = Log4r::PatternFormatter.new(:pattern => "[%l]   %M")
+        
+        @@log.level = debug ? Log4r::DEBUG : Log4r::INFO
+
+        Savon.configure do |config|
+          config.log = debug ? true : false
+          config.log_level = :debug
+          config.logger = @@log
+          config.raise_errors = false
+        end
+      end
+    end
+    
+    def Logging.log
+      @@log ||= Log4r::Logger.root
+    end
+    
+    # Meant for mixing into other classes for simplified logging
+    def log
+      @@log ||= Log4r::Logger.root
+    end
+  end
+end
+
+# SHUT THE HELL UP!
+module HTTPI
+  class << self
+    def log(*messages)
+    end
+  end
+end

data/lib/netscaler/server/request.rb

@@ -0,0 +1,35 @@
+require 'netscaler/base_request'
+require 'netscaler/server/response'
+
+module Netscaler::Server
+  class Request < Netscaler::BaseRequest
+    def enable(server, options)
+      send_request('enableserver', {:name => server})
+    end
+
+    def disable(server, options)
+      send_request('disableserver', {:name => server})
+    end
+
+    def list(server, options)
+      responses = []
+      send_request('getserver', {:empty => :ok}) do |response|
+        response_part(response).each_with_index do |server, i|
+          responses << Response.new(server).to_hash
+        end
+      end      
+      yield responses if block_given?
+    end
+
+    def status(server, options)
+      send_request('getserver', {:name => server }) do |response|
+        yield Response.new(response_part(response)).to_hash if block_given?
+      end
+    end
+
+    private
+    def response_part(response)
+      response[:return][:list][:item]
+    end
+  end
+end

data/lib/netscaler/server/response.rb

@@ -0,0 +1,114 @@
+module Netscaler::Server
+  class Response
+    def initialize(raw_response)
+      @info = raw_response
+    end
+
+    def name
+      @info[:name]
+    end
+
+    def ip_address
+      @info[:ipaddress]
+    end
+
+    def state
+      @info[:state]
+    end
+
+    def services
+      @parsed_services ||= []
+      return @parsed_services if !@parsed_services.empty? || @info[:servicename].nil?
+
+      if @info[:servicename][:item].is_a?(String)
+        @parsed_services << ServiceInfo.new(@info, nil)
+      else
+        @info[:servicename][:item].each_with_index do |name, i|
+          @parsed_services << ServiceInfo.new(@info, i)
+        end
+      end
+
+      @parsed_services
+    end
+
+    def to_hash
+      hash = { 
+        :name => name,
+        :ip_address => ip_address,
+        :state => state,
+      }
+
+      if !services.empty?
+        hash[:services] = services.map {|s| s.to_hash}
+      end
+
+      hash
+    end
+  end
+
+  class ServiceInfo
+    attr_reader :name, :type, :state, :ip_address, :servicegroup
+
+    def initialize(raw_response, index)
+      @name = raw_response[:servicename][:item]
+      @ip_address = raw_response[:serviceipaddress][:item]
+      @state = raw_response[:svrstate][:item]
+      @port = raw_response[:port][:item]
+      @type = raw_response[:servicetype][:item]
+
+      if !index.nil?
+        @name = @name[index]
+        @ip_address = @ip_address[index]
+        @state = @state[index]
+        @port = @port[index]
+        @type = @type[index]
+      end
+
+      @servicegroup = if raw_response[:servicegroupname] && raw_response[:servicegroupname][:item]
+                        ServiceGroupInfo.new(raw_response, index)
+                      else
+                        nil
+                      end
+    end
+
+    def port
+      @port.to_i
+    end
+
+    def to_hash
+      hash = {
+        :name => name,
+        :ip_address => ip_address,
+        :type => type,
+        :state => state,
+        :port => port,
+      }
+
+      if servicegroup
+        hash[:servicegroup] = servicegroup.to_hash
+      end
+
+      hash
+    end
+  end
+
+  class ServiceGroupInfo
+    attr_reader :name, :state
+
+    def initialize(raw_response, index)
+      @name = raw_response[:servicegroupname][:item]
+      @state = raw_response[:boundservicegroupsvrstate][:item]
+
+      if !index.nil?
+        @name = @name[index]
+        @state = @state[index]
+      end
+    end
+
+    def to_hash
+      { :name => name,
+        :state => state
+      }
+    end
+  end
+end

data/lib/netscaler/service/request.rb

@@ -0,0 +1,42 @@
+require 'netscaler/base_request'
+require 'netscaler/service/response'
+
+module Netscaler::Service
+  class Request < Netscaler::BaseRequest
+    def enable(service, options)
+      params = { :name => service }
+      send_request('enableservice', params)
+    end
+
+    def disable(service, options)
+      params = { 
+        :name => service, 
+        :delay => 0 
+      }
+      send_request('disableservice', params)
+    end
+
+    def bind(service, options)
+      params = {
+        :name => options[:vserver],
+        :servicename => service
+      }
+      send_request('bindlbvserver_service', params)
+    end
+
+    def unbind(service, options)
+      params = {
+        :name => options[:vserver],
+        :servicename => service
+      }
+      send_request('unbindlbvserver_service', params)
+    end
+
+    def status(service, options)
+      params = { :name => service }
+      send_request('getservice', params) do |response|
+        yield Response.new(response).to_hash if block_given?
+      end
+    end
+  end
+end

data/lib/netscaler/service/response.rb

@@ -0,0 +1,36 @@
+module Netscaler::Service
+  class Response
+    def initialize(raw_response)
+      @info = raw_response[:return][:list][:item]
+    end
+
+    def name
+      @info[:name]
+    end
+
+    def ip_address
+      @info[:ipaddress]
+    end
+
+    def state
+      @info[:svrstate]
+    end
+
+    def port
+      @info[:port].to_i
+    end
+
+    def server
+      @info[:servername]
+    end
+
+    def to_hash
+      { :name => name,
+        :server => server,
+        :ip_address => ip_address,
+        :state => state,
+        :port => port
+      }
+    end
+  end
+end

data/lib/netscaler/servicegroup/request.rb

@@ -0,0 +1,46 @@
+require 'netscaler/base_request'
+require 'netscaler/servicegroup/response'
+
+module Netscaler::ServiceGroup
+  class Request < Netscaler::BaseRequest
+    def enable(service, options)
+      params = { :servicegroupname => service }
+      [:servername, :port].each do |option|
+        params[option] = options[option] if options[option]
+      end
+      send_request('enableservicegroup', params)
+    end
+
+    def disable(servicegroup, options)
+      params = { :servicegroupname => servicegroup }
+      [:servername, :port, :delay].each do |option|
+        params[option] = options[option] if options[option]
+      end
+      send_request('disableservicegroup', params)
+    end
+
+    def bind(servicegroup, options)
+      params = {
+        :name => options[:vserver],
+        :servicegroupname => servicegroup
+      }
+      send_request('bindlbvserver_servicegroup', params)
+    end
+
+    def unbind(servicegroup, options)
+      params = {
+        :name => options[:vserver],
+        :servicename => servicegroup
+      }
+      send_request('unbindlbvserver_servicegroup', params)
+    end
+
+    def status(servicegroup, options)
+      params = { :servicegroupname => servicegroup }
+      send_request('getservicegroup', params) do |response|
+        yield Response.new(response).to_hash if block_given?
+      end
+    end
+  end
+end
+

data/lib/netscaler/servicegroup/response.rb

@@ -0,0 +1,78 @@
+module Netscaler::ServiceGroup
+  class Response
+    def initialize(raw_response)
+      @info = raw_response[:return][:list][:item]
+    end
+
+    def name
+      @info[:servicegroupname]
+    end
+
+    def state
+      @info[:state]
+    end
+
+    def type
+      @info[:servicetype]
+    end
+
+    def servers
+      @parsed_servers ||= []
+      return @parsed_servers if !@parsed_servers.empty? || @info[:servername].nil?
+
+      if @info[:servername][:item].is_a?(String)
+        @parsed_servers << ServerInfo.new(@info, nil)
+      else
+        @info[:servername][:item].each_with_index do |name, i|
+          @parsed_servers << ServerInfo.new(@info, i)
+        end
+      end
+
+      @parsed_servers
+    end
+
+    def to_hash
+      hash = { 
+        :name => name,
+        :state => state,
+        :type => type,
+      }
+
+      if !servers.empty?
+        hash[:servers] = servers.map {|s| s.to_hash}
+      end
+
+      hash
+    end
+  end
+
+  class ServerInfo
+    attr_reader :name, :ip_address, :state
+
+    def initialize(raw_response, index)
+      @name = raw_response[:servername][:item]
+      @ip_address = raw_response[:ipaddress][:item]
+      @state = raw_response[:svcstate][:item]
+      @port = raw_response[:port][:item]
+
+      if !index.nil?
+        @name = @name[index]
+        @ip_address = @ip_address[index]
+        @state = @state[index]
+        @port = @port[index]
+      end
+    end
+
+    def port
+      @port.to_i
+    end
+
+    def to_hash
+      { :name => name,
+        :ip_address => ip_address,
+        :state => state,
+        :port => port
+      }
+    end
+  end
+end

data/lib/netscaler/transaction.rb

@@ -0,0 +1,68 @@
+require 'netscaler/logging'
+require 'savon'
+
+module Netscaler
+  NSCONFIG_NAMESPACE = "urn:NSConfig"
+
+  class Transaction
+    include Logging
+
+    def initialize(config, &block)
+      @config = config
+      if block_given?
+        execute(&block)
+      end
+    end
+
+    def execute(&block)
+      if !block_given?
+        raise Netscaler::TransactionError.new("No execution block given.")
+      end
+      
+      log.debug("Beginning the transaction execution: #{@config.host}")
+      begin
+        client = Savon::Client.new do 
+          wsdl.endpoint = url
+          wsdl.namespace = Netscaler::NSCONFIG_NAMESPACE
+        end
+        client.http.auth.ssl.verify_mode = :none
+
+        log.debug("Logging in to the Netscaler host.")
+        body = { :username => @config.username, :password => @config.password }
+
+        response = client.request :login do
+          #soap.namespace = Netscaler::NSCONFIG_NAMESPACE
+          soap.body = body
+        end
+
+        auth_cookie = response.http.headers['Set-Cookie']
+        client.http.headers['Cookie'] = auth_cookie
+        log.debug("Got authorization cookie: #{auth_cookie}")
+
+        log.debug("Yielding client control to the calling context")
+        yield client
+      rescue SystemExit => e
+        raise
+      rescue Exception => e
+        log.fatal(e)
+        log.fatal("Unable to execute transaction.")
+        raise Netscaler::TransactionError.new(e)
+      ensure
+        begin
+          log.debug("Logging out of the Netscaler host.")
+          client.request :logout
+        rescue Exception => e
+          log.fatal(e)
+          log.fatal("Unable to logout.")
+        end
+      end
+
+      log.debug("Ending the transaction execution: #{@config.host}")
+    end
+
+    private
+    def url
+      "https://#{@config.host}/soap"
+    end
+  end
+end