netscaler-cli 0.3.3 → 0.4.0

data/lib/netscaler/server/cli.rb

@@ -1,60 +0,0 @@
-require 'netscaler/clitemplate'
-require 'netscaler/errors'
-require 'netscaler/server/executor'
-
-module Netscaler::Server
-  class CLI < Netscaler::CLITemplate
-    def initialize(args)
-      super('server', args)
-    end
-
-    def create_executor(client)
-      Netscaler::Server::Executor.new(host, client)
-    end
-
-    def interface_header(opts)
-      opts.banner = "Usage: #{File.basename($0)} [OPTIONS] [SERVER]"
-      opts.separator <<DESC
-Description:
-    This is a tool for enabling and disabling a server in a Netscaler
-    load balancer.  The name of the server is required, as is the
-    address of the Netscaler load balancer.
-
-    By default, this script will tell you what its current status of the
-    server is.
-
-    If you want to list all of the services, use the --list flag with no
-    server argument.
-
-Options:
-DESC
-    end
-
-    def requires_argument?
-      false
-    end
-
-    def validate_noargs
-      if !options[:action].include?(:list)
-        raise Netscaler::ConfigurationError.new("No hosts specified to act on.")
-      end
-    end
-
-    def interface_actions(opts)
-      opts.separator "   Actions: "
-      opts.on('-e', '--enable',
-              "Enables the given server.") do |e|
-        options[:action] << :enable
-      end
-      opts.on('-d', '--disable',
-              "Disables the given server.") do |d|
-        options[:action] << :disable
-      end
-      opts.on('-l', '--list',
-              "Lists all of the servers in the environment") do |l|
-        options[:action] << :list
-      end
-      opts.separator ""
-    end
-  end # CLI
-end

data/lib/netscaler/server/executor.rb

@@ -1,115 +0,0 @@
-require 'netscaler/baseexecutor'
-
-module Netscaler::Server
-  class Executor < Netscaler::BaseExecutor
-    def initialize(host, client)
-      super(host, client)
-      @params = { :name => host }
-    end
-
-    def enable(options)
-      send_request('enableserver', @params)
-    end
-
-    def disable(options)
-      send_request('disableserver', @params)
-    end
-
-    def list(options)
-      send_request('getserver', {:empty => :ok}) do |response|
-        puts "[" if options[:json]
-        
-        servers = response[:return][:list][:item]
-        servers.each_with_index do |server, i|
-          resp = Response.new(server)
-          if options[:json]
-            if i == servers.length - 1
-              puts "    #{resp.to_json}"
-            else
-              puts "    #{resp.to_json},"
-            end
-          else
-            puts resp.to_s
-            puts
-          end
-        end
-
-        puts "]"if options[:json]
-      end      
-    end
-
-    def status(options)
-      send_request('getserver', @params) do |response|
-        resp = Response.new(response[:return][:list][:item])
-        if options[:json]
-          puts resp.to_json
-        else
-          puts resp.to_s
-        end
-      end
-    end
-  end
-
-  class Response
-    attr_reader :info
-
-    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
-      if info[:servicename]
-        info[:servicename][:item]
-      else
-        []
-      end
-    end
-
-    def to_s
-      base = "Name:\t#{name}\nIP:\t#{ip_address}\nState:\t#{state}"
-
-      if !services.empty?
-        base << "\nServices:\n"
-        services.each do |service|
-          base << "\t#{service}\n"
-        end
-        base
-      end
-
-      base
-    end
-
-    def to_json
-      base = "{ 'name': '#{name}', 'ip_address': '#{ip_address}', 'state': '#{state}'"
-
-      if services.empty?
-        base << " }"
-      else
-        base << ", 'services': ["
-
-        services.each_with_index do |service, i|
-          base << "'#{service}'"
-          if i != services.length - 1
-            base << ", "
-          end
-        end
-
-        base << "] }"
-      end
-
-      base
-    end
-  end
-end

data/lib/netscaler/service/cli.rb

@@ -1,49 +0,0 @@
-require 'netscaler/clitemplate'
-require 'netscaler/service/executor'
-
-module Netscaler::Service
-  class CLI < Netscaler::CLITemplate
-    def initialize(args)
-      super('service', args)
-    end
-
-    def create_executor(client)
-      Netscaler::Service::Executor.new(host, client)
-    end
-
-    def interface_header(opts)
-      opts.banner = "Usage: #{File.basename($0)} [OPTIONS] SERVICE"
-      opts.separator <<DESC
-Description:
-    This is a tool for enabling and disabling services in a Netscaler
-    load balancer.  The name of the service is required, as is the
-    address of the Netscaler load balancer.
-
-Options:
-DESC
-    end
-
-    def interface_actions(opts)
-      opts.separator "   Actions: "
-      opts.on('-e', '--enable',
-              "Enables the given service.") do |e|
-        options[:action] << :enable
-      end
-      opts.on('-d', '--disable',
-              "Disables the given service.") do |d|
-        options[:action] << :disable
-      end
-      opts.on('-b', '--bind VSERVER',
-              "Binds a service to a virtual server.") do |b|
-        options[:action] << :bind
-        options[:vserver] = b
-      end
-      opts.on('-u', '--unbind VSERVER',
-              "Unbinds a serivce to a virtual server.") do |u|
-        options[:action] << :unbind
-        options[:vserver] = u
-      end
-      opts.separator ""
-    end
-  end # CLI
-end

data/lib/netscaler/service/executor.rb

@@ -1,82 +0,0 @@
-require 'netscaler/baseexecutor'
-
-module Netscaler::Service
-  class Executor < Netscaler::BaseExecutor
-    def initialize(host, client)
-      super(host, client)
-      @params = { :name => host }
-    end
-
-    def enable(options)
-      send_request('enableservice', @params)
-    end
-
-    def disable(options)
-      params = { 
-        :name => host, 
-        :delay => 0 
-      }
-      send_request('disableservice', params)
-    end
-
-    def bind(options)
-      params = {
-        :name => options[:vserver],
-        :servicename => host
-      }
-      send_request('bindlbvserver_service', params)
-    end
-
-    def unbind(options)
-      params = {
-        :name => options[:vserver],
-        :servicename => host
-      }
-      send_request('unbindlbvserver_service', params)
-    end
-
-    def status(options)
-      send_request('getservice', @params) do |response|
-        resp = Response.new(response)
-        if options[:json]
-          puts resp.to_json
-        else
-          puts resp.to_s
-        end
-      end
-    end
-  end
-
-  class Response
-    attr_reader :raw_response, :info
-
-    def initialize(raw_response)
-      @raw_response = 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]
-    end
-    
-    def to_s
-      "Name:\t#{name}\nIP:\t#{ip_address}\nState:\t#{state}\nPort:\t#{port}"
-    end
-
-    def to_json
-      "{ 'name': '#{name}', 'ip_address': '#{ip_address}', 'state': '#{state}', 'port': #{port} }"
-    end
-  end
-end

data/lib/netscaler/vserver/cli.rb

@@ -1,92 +0,0 @@
-require 'netscaler/clitemplate'
-require 'netscaler/vserver/executor'
-
-module Netscaler::VServer
-  class CLI < Netscaler::CLITemplate
-    def initialize(args)
-      super('vserver', args)
-    end
-
-    def create_executor(client)
-      Netscaler::VServer::Executor.new(host, client)
-    end
-
-    def interface_header(opts)
-      opts.banner = "Usage: #{File.basename($0)} [OPTIONS] [VSERVER]"
-      opts.separator <<DESC
-Description:
-    This is a tool for enabling and disabling a virtual server in a Netscaler
-    load balancer.  The name of the virtual server is required, as is the
-    address of the Netscaler load balancer.
-
-    By default, this script will tell you what its current status of the
-    virtual server is.
-
-    If you want to list all of the virtual servers, use the --list flag with no
-    server argument.
-
-Options:
-DESC
-    end
-
-    def interface_actions(opts)
-      opts.separator "   Actions: "
-      opts.on('-e', '--enable',
-              "Enables the given virtual server.") do |e|
-        options[:action] << :enable
-      end
-      opts.on('-d', '--disable',
-              "Disables the given virtual server.") do |d|
-        options[:action] << :disable
-      end
-      opts.on('-b', '--bind POLICY_NAME',
-              "Binds a policy of a given name to a",
-              "virtual server.") do |b|
-        options[:action] << :bind
-        options[:policy_name] = b
-      end
-      opts.on('-p', '--priority NUMBER', Integer,
-              "The priority to bind the policy with.",
-              "Used only with the --bind flag.") do |p|
-        options[:priority] = p
-      end
-      opts.on('-u', '--unbind POLICY_NAME',
-              "Unbinds a policy of a given name to a",
-              "virtual server.") do |u|
-        options[:action] << :unbind
-        options[:policy_name] = u
-      end
-      opts.on('-l', '--list',
-              "List all of the virtual servers in the environment.") do |l|
-        options[:action] << :list
-      end
-      opts.separator ""
-    end
-
-    def requires_argument?
-      false
-    end
-
-    def validate_noargs
-      if !options[:action].include?(:list)
-        raise Netscaler::ConfigurationError.new("No hosts specified to act on.")
-      end
-    end
-
-    def validate_args(args)
-      super(args)
-
-      if options[:action][0] == :bind
-        if options[:priority].nil?
-          options[:priority] = 1
-        elsif options[:priority] <= 0
-          raise Netscaler::ConfigurationError.new("The --priority must be greater than 0")
-        end
-      else
-        if options[:priority]
-          raise Netscaler::ConfigurationError.new("The --priority flag can only specified with the --bind option")
-        end
-      end
-    end
-  end # CLI
-end

data/lib/netscaler/vserver/executor.rb

@@ -1,194 +0,0 @@
-require 'netscaler/logging'
-require 'netscaler/baseexecutor'
-
-module Netscaler::VServer
-  class Executor < Netscaler::BaseExecutor
-    include Netscaler::Logging
-
-    def initialize(host, client)
-      super(host, client)
-      @params = { :name => host }
-    end
-
-    def enable(options)
-      send_request('enablelbvserver', @params)
-    end
-
-    def disable(options)
-      send_request('disablelbvserver', @params)
-    end
-
-    def list(options)
-      send_request('getlbvserver', {:empty => :ok}) do |response|
-        puts "[" if options[:json]
-        
-        vservers = response[:return][:list][:item]
-        vservers.each_with_index do |vserver, i|
-          resp = Response.new(vserver)
-          if options[:json]
-            if i == vservers.length - 1
-              puts "    #{resp.to_json}"
-            else
-              puts "    #{resp.to_json},"
-            end
-          else
-            puts resp.to_s
-            puts
-          end
-        end
-
-        puts "]"if options[:json]
-      end      
-    end
-
-    def status(options)
-      send_request('getlbvserver', @params) do |response|
-        begin
-          resp = Response.new(response[:return][:list][:item])
-          if options[:json]
-            puts resp.to_json
-          else
-            puts resp.to_s
-          end
-        rescue Exception => e
-          log.fatal "Unable to lookup any information for host: #{host}"
-          puts e
-          exit(1)
-        end
-      end
-    end
-
-    def bind(options)
-      params = { 
-        :name => host,
-        :policyname => options[:policy_name],
-        :priority => options[:priority],
-        :gotopriorityexpression => 'END' 
-      }
-
-      send_request('bindlbvserver_policy', params)
-    end
-
-    def unbind(options)
-      params = {
-        :name => host,
-        :policyname => options[:policy_name], 
-        :type => 'REQUEST'
-      }
-
-      send_request('unbindlbvserver_policy', params)
-    end
-  end
-
-  class Response
-    attr_reader :info
-
-    def initialize(raw_response)
-      @info = raw_response
-    end
-
-    def name
-      info[:name]
-    end
-
-    def ip_address
-      if info[:ipaddress] =~ /0\.0\.0\.0/
-        info[:ipaddress2]
-      else
-        info[:ipaddress]
-      end
-    end
-
-    def type
-      info[:servicetype]
-    end
-
-    def port
-      info[:port]
-    end
-
-    def state
-      info[:state]
-    end
-
-    def servers
-      @parsed_servers ||= []
-      if !@parsed_servers.empty? || info[:servicename].nil?
-        return @parsed_servers
-      end
-
-      info[:servicename][:item].each do |name|
-        srv = ServerInfo.new
-        srv.name = name
-        @parsed_servers << srv
-      end
-
-      info[:svcstate][:item].each_with_index do |state, i|
-        @parsed_servers[i].state = state
-      end
-
-      info[:svcport][:item].each_with_index do |port, i|
-        @parsed_servers[i].port = port
-      end
-
-      info[:svcipaddress][:item].each_with_index do |ip_address, i|
-        @parsed_servers[i].ip_address = ip_address
-      end
-
-      info[:svctype][:item].each_with_index do |type, i|
-        @parsed_servers[i].type = type
-      end
-
-      @parsed_servers
-    end
-
-    def to_s
-      base = "Name:\t#{name}\nIP:\t#{ip_address}\nState:\t#{state}\nPort:\t#{port}\nType:\t#{type}"
-
-      if !servers.empty?
-        base << "\nServers:\n"
-        servers.each do |server|
-          base << server.to_s
-          base << "\n\n"
-        end
-      end
-
-      base
-    end
-
-    def to_json
-      base = "{ 'name': '#{name}', 'ip_address': '#{ip_address}', 'state': '#{state}', 'port': #{port}, 'type': '#{type}'"
-
-      if servers.empty?
-        base << " }"
-      else
-        base << ", 'servers': [\n    "
-
-        servers.each_with_index do |server, i|
-          base << server.to_json
-          if i != servers.length - 1
-            base << ",\n    "
-          else
-            base << "\n"
-          end
-        end
-
-        base << "] }"
-      end
-
-      base
-    end
-  end
-
-  class ServerInfo
-    attr_accessor :name, :ip_address, :state, :port, :type
-
-    def to_s
- "\tName:\t#{name}\n\tIP:\t#{ip_address}\n\tState:\t#{state}\n\tPort:\t#{port}\n\tType:\t#{type}"
-    end
-
-    def to_json
-      "{ 'name': '#{name}', 'ip_address': '#{ip_address}', 'state': '#{state}', 'port': #{port}, 'type': '#{type}' }"
-    end
-  end
-end