zaws 0.0.5 → 0.1.1

data/lib/zaws/command/config.rb

@@ -0,0 +1,42 @@
+require 'thor'
+
+module ZAWS
+  module Command
+    class Config < Thor
+      class_option :verbose, :type => :boolean, :desc => "Verbose outout", :aliases => :d, :default => false
+
+      attr_accessor :config
+      attr_accessor :out
+      attr_accessor :print_exit_code
+
+      def initialize(*args)
+        super
+        shellout=ZAWS::Helper::Shell.new
+        nessusapi = ZAWS::Nessusapi.new(shellout)
+        sumoapi = ZAWS::Sumoapi.new(shellout)
+        newrelicapi = ZAWS::Newrelicapi.new(shellout)
+        awscli = ZAWS::AWSCLI.new(shellout)
+        @config = ZAWS::Controllers::Config.new(shellout, nessusapi,sumoapi,newrelicapi,awscli)
+        @out = $stdout
+        @print_exit_code = false
+      end
+
+      desc "remove_creds", "remove_creds"
+      option :home, :type => :string, :default => ENV['HOME'], :desc => 'Home directory location for credentials file'
+      def remove_creds
+        @config.awscli.home=options[:home]
+        @config.awscli.remove_creds()
+
+        @config.nessusapi.home=options[:home]
+        @config.nessusapi.remove_creds()
+
+        @config.sumoapi.home=options[:home]
+        @config.sumoapi.remove_creds()
+
+        @config.newrelicapi.home=options[:home]
+        @config.newrelicapi.remove_creds()
+      end
+
+    end
+  end
+end

data/lib/zaws/command/elasticip.rb

@@ -6,37 +6,47 @@ module ZAWS
 	  class_option :region, :type => :string, :desc => "AWS Region", :banner => "<region>",  :aliases => :r, :required => true
 	  class_option :verbose, :type => :boolean, :desc => "Verbose outout", :aliases => :d, :default => false
 
+	  attr_accessor :aws
+      attr_accessor :out
+      attr_accessor :print_exit_code
+
+	  def initialize(*args)
+		super
+        shellout=ZAWS::Helper::Shell.new
+		awscli = ZAWS::AWSCLI.new(shellout)
+		@aws = ZAWS::AWS.new(shellout,awscli)
+		@out = $stdout
+		@print_exit_code = false
+	  end
+
+
 	  desc "view","View elastic ips."
 	  option :viewtype, :type => :string, :desc => "View type, json or table", :banner => "<viewtype>", :aliases => :w, :default => "table"
 	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :default => nil
 	  def view
-		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		aws.ec2.elasticip.view(options[:region],options[:viewtype],$stdout,(options[:verbose]?$stdout:nil),options[:vpcid])
+		@aws.ec2.elasticip.view(options[:region],options[:viewtype],@out,(options[:verbose]?@out:nil),options[:vpcid])
 	  end
 
 	  desc "assoc_exists EXTERNAL_ID","Determine by an instance's EXTERNAL_ID if it has an elastic."
 	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :default => nil
 	  def assoc_exists(externalid) 
-		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		val,instanceid,assoc,alloc,ip=aws.ec2.elasticip.assoc_exists(options[:region],externalid,$stdout,(options[:verbose]?$stdout:nil),options[:vpcid])
+		val,instanceid,assoc,alloc,ip=@aws.ec2.elasticip.assoc_exists(options[:region],externalid,@out,(options[:verbose]?@out:nil),options[:vpcid])
 		return val
 	  end
 
 	  desc "declare EXTERNAL_ID","Declare an instance by its instance's EXTERNAL_ID  should have an elastic ip."
 	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :default => nil
-      option :nagios, :type => :boolean, :desc => "Returns a nagios check result",  :aliases => :n, :default => false
+      option :check, :type => :boolean, :desc => "Returns a nagios check result",  :aliases => :n, :default => false
 	  option :undofile, :type => :string, :desc => "File for undo commands", :banner => "<undofile>", :aliases => :f, :default => nil
 	  def declare(externalid) 
-		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		val=aws.ec2.elasticip.declare(options[:region],externalid,$stdout,(options[:verbose]?$stdout:nil),options[:vpcid],options[:nagios],options[:undofile])
+		val=@aws.ec2.elasticip.declare(options[:region],externalid,@out,(options[:verbose]?@out:nil),options[:vpcid],options[:check],options[:undofile])
 		return val
 	  end
 
 	  desc "release EXTERNAL_ID","Release an elastic ip address a specific instance. The instance's EXTERNAL_ID is required."
 	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :default => nil
 	  def release(externalid) 
-		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		val=aws.ec2.elasticip.release(options[:region],externalid,$stdout,(options[:verbose]?$stdout:nil),options[:vpcid])
+		val=@aws.ec2.elasticip.release(options[:region],externalid,@out,(options[:verbose]?@out:nil),options[:vpcid])
 		return val
 	  end
 

data/lib/zaws/command/hosted_zone.rb

@@ -2,24 +2,37 @@ require 'thor'
 
 module ZAWS
   module Command
-	class Hosted_Zone < Thor 
-	  class_option :verbose, :type => :boolean, :desc => "Verbose outout", :aliases => :d, :default => false
-
-	  desc "view","View hosted zones."
-	  option :viewtype, :type => :string, :desc => "View type, json or table", :banner => "<viewtype>", :aliases => :w, :default => "table"
-	  def view
-		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		aws.route53.hosted_zone.view(options[:viewtype],$stdout,(options[:verbose]?$stdout:nil))
-	  end
-
-	  desc "view_records ZONE_NAME","View record sets for hosted ZONE_NAME."
-	  option :viewtype, :type => :string, :desc => "View type, json or table", :banner => "<viewtype>", :aliases => :w, :default => "table"
-	  def view_records(zonename)
-		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		aws.route53.hosted_zone.view_records(options[:viewtype],$stdout,(options[:verbose]?$stdout:nil),zonename)
-	  end
-
-	end
+    class Hosted_Zone < Thor
+      class_option :verbose, :type => :boolean, :desc => "Verbose outout", :aliases => :d, :default => false
+
+      attr_accessor :aws
+      attr_accessor :out
+      attr_accessor :print_exit_code
+
+      def initialize(*args)
+        super
+        shellout=ZAWS::Helper::Shell.new
+        awscli = ZAWS::AWSCLI.new(shellout)
+        @aws = ZAWS::AWS.new(shellout, awscli)
+        @out = $stdout
+        @print_exit_code = false
+      end
+
+      desc "view", "View hosted zones."
+      option :viewtype, :type => :string, :desc => "View type, json or table", :banner => "<viewtype>", :aliases => :w, :default => "table"
+
+      def view
+        @aws.route53.hosted_zone.view(options[:viewtype], @out, (options[:verbose] ? @out : nil))
+      end
+
+      desc "view_records ZONE_NAME", "View record sets for hosted ZONE_NAME."
+      option :viewtype, :type => :string, :desc => "View type, json or table", :banner => "<viewtype>", :aliases => :w, :default => "table"
+
+      def view_records(zonename)
+        @aws.route53.hosted_zone.view_records(options[:viewtype], @out, (options[:verbose] ? @out : nil), zonename)
+      end
+
+    end
   end
 end
 

data/lib/zaws/command/iam.rb

@@ -0,0 +1,37 @@
+require 'thor'
+
+module ZAWS
+  module Command
+	class IAM < Thor 
+	  class_option :verbose, :type => :boolean, :desc => "Verbose outout", :aliases => :d, :default => false
+
+	  attr_accessor :aws
+      attr_accessor :out
+      attr_accessor :print_exit_code
+
+	  def initialize(*args)
+		super
+        shellout=ZAWS::Helper::Shell.new
+		awscli = ZAWS::AWSCLI.new(shellout,false)
+		@aws = ZAWS::AWS.new(shellout,awscli)
+		@out = $stdout
+		@print_exit_code = false
+	  end
+
+	  desc "view_role_policy ROLE POLICY","View inline role policy."
+	  option :viewtype, :type => :string, :desc => "View type, json or table", :banner => "<viewtype>", :aliases => :w, :default => "table"
+	  def view_role_policy(role,policy)
+		@aws.iam.role.view_policy(role,policy,options[:viewtype],@out,options[:verbose]?@out:nil)
+	  end
+
+	  desc "view_default_policy_version POLICY_ARN","View default policy."
+	  option :viewtype, :type => :string, :desc => "View type, json or table", :banner => "<viewtype>", :aliases => :w, :default => "table"
+	  def view_default_policy_version(policy_arn)
+		@aws.iam.policy.view_default_policy_version(policy_arn,options[:viewtype],@out,options[:verbose]?@out:nil)
+	  end
+
+	end
+  end
+end
+
+	

data/lib/zaws/command/load_balancer.rb

@@ -6,105 +6,108 @@ module ZAWS
 	  class_option :region, :type => :string, :desc => "AWS Region", :banner => "<region>",  :aliases => :r, :required => true
 	  class_option :verbose, :type => :boolean, :desc => "Verbose outout", :aliases => :d, :default => false
 
+	  attr_accessor :aws
+      attr_accessor :out
+      attr_accessor :print_exit_code
+
+	  def initialize(*args)
+		super
+        shellout=ZAWS::Helper::Shell.new
+		awscli = ZAWS::AWSCLI.new(shellout)
+		@aws = ZAWS::AWS.new(shellout,awscli)
+		@out = $stdout
+		@print_exit_code = false
+	  end
+
 	  desc "view","View load balancers."
 	  option :viewtype, :type => :string, :desc => "View type, json or table", :banner => "<viewtype>", :aliases => :w, :default => "table"
 	  def view
-		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		aws.elb.load_balancer.view(options[:region],options[:viewtype],$stdout,(options[:verbose]?$stdout:nil))
+		@aws.elb.load_balancer.view(options[:region],options[:viewtype],@out,(options[:verbose]?@out:nil))
 	  end
 
 	  desc "exists LOAD_BALANCER_NAME","Determine if a load balancer exists by its LOAD_BALANCER_NAME"
 	  def exists(lbname) 
-		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		val,instances=aws.elb.load_balancer.exists(options[:region],lbname,$stdout,(options[:verbose]?$stdout:nil))
+		val,instances=@aws.elb.load_balancer.exists(options[:region],lbname,@out,(options[:verbose]?@out:nil))
 		return val
 	  end
 
-	  desc "create_in_subnets","Create a new load balancer in the subnets specified by the option --cidrblocks."
+	  desc "create_in_subnet LOAD_BALANCER_NAME LB_PROTOCOL LB_PORT IN_PROTOCOL IN_PORT SECURITY_GROUP","Create a new load balancer in the subnets specified by the option --cidrblocks."
 	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :default => nil
 	  option :cidrblocks,:type => :array, :desc => "subnet cidr blocks to attach to load balancer, one per avaialability zone.", :banner => "<cidrblocks>", :aliases => :u
-	  option :nagios, :type => :boolean, :desc => "Returns a nagios check result",  :aliases => :n, :default => false
+	  option :check, :type => :boolean, :desc => "Returns a check result",  :aliases => :n, :default => false
 	  option :undofile, :type => :string, :desc => "File for undo commands", :banner => "<undofile>", :aliases => :f, :default => nil
 	  def create_in_subnet(lbname,lbprotocol,lbport,inprotocol,inport,securitygroup)
-		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		exitcode = aws.elb.load_balancer.create_in_subnet(options[:region],lbname,lbprotocol,lbport,inprotocol,inport,securitygroup,options[:cidrblocks],options[:vpcid],options[:nagios],$stdout,(options[:verbose]?$stdout:nil),options[:undofile])
+		exitcode = @aws.elb.load_balancer.create_in_subnet(options[:region],lbname,lbprotocol,lbport,inprotocol,inport,securitygroup,options[:cidrblocks],options[:vpcid],options[:check],@out,(options[:verbose]?@out:nil),options[:undofile])
 		exit exitcode
 	  end
 
 	  desc "delete LOAD_BALANCER_NAME","Delete load balancer identified by LOAD_BALANCER_NAME if it exists."
 	  def delete(lbname) 
-		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		aws.elb.load_balancer.delete(options[:region],lbname,$stdout,(options[:verbose]?$stdout:nil))
+		@aws.elb.load_balancer.delete(options[:region],lbname,@out,(options[:verbose]?@out:nil))
 	  end
 
 	  desc "exists_instance LOAD_BALANCER_NAME INSTANCE_EXTERNAL_ID","Determine if an instance identified by the INSTANCE_EXTERNAL_ID is registered with load balancer identified by LOAD_BALANCER_NAME."
 	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :default => nil
 	  def exists_instance(lbname,instance_external_id) 
-		$stdout.puts "DEBUG: options[:region]=#{options[:region]}" if options[:verbose]
-		$stdout.puts "DEBUG: lbname=#{lbname}" if options[:verbose]
-		$stdout.puts "DEBUG: instance_external_id=#{instance_external_id}" if options[:verbose]
-		$stdout.puts "DEBUG: options[:vpcid]=#{options[:vpcid]}" if options[:verbose]
-		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		aws.elb.load_balancer.exists_instance(options[:region],lbname,instance_external_id,options[:vpcid],$stdout,(options[:verbose]?$stdout:nil))
+		@out.puts "DEBUG: options[:region]=#{options[:region]}" if options[:verbose]
+		@out.puts "DEBUG: lbname=#{lbname}" if options[:verbose]
+		@out.puts "DEBUG: instance_external_id=#{instance_external_id}" if options[:verbose]
+		@out.puts "DEBUG: options[:vpcid]=#{options[:vpcid]}" if options[:verbose]
+		@aws.elb.load_balancer.exists_instance(options[:region],lbname,instance_external_id,options[:vpcid],@out,(options[:verbose]?@out:nil))
 	  end
 
 	  desc "register_instance LOAD_BALANCER_NAME INSTANCE_EXTERNAL_ID","Register an instance identified by the INSTANCE_EXTERNAL_ID is registered with load balancer identified by LOAD_BALANCER_NAME."
 	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :default => nil
-      option :nagios, :type => :boolean, :desc => "Returns a nagios check result",  :aliases => :n, :default => false
+      option :check, :type => :boolean, :desc => "Returns a check result",  :aliases => :n, :default => false
 	  option :undofile, :type => :string, :desc => "File for undo commands", :banner => "<undofile>", :aliases => :f, :default => nil
 	  def register_instance(lbname,instance_external_id) 
-		$stdout.puts "DEBUG: options[:region]=#{options[:region]}" if options[:verbose]
-		$stdout.puts "DEBUG: lbname=#{lbname}" if options[:verbose]
-		$stdout.puts "DEBUG: instance_external_id=#{instance_external_id}" if options[:verbose]
-		$stdout.puts "DEBUG: options[:vpcid]=#{options[:vpcid]}" if options[:verbose]
-		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		aws.elb.load_balancer.register_instance(options[:region],lbname,instance_external_id,options[:vpcid],options[:nagios],$stdout,(options[:verbose]?$stdout:nil),options[:undofile])
+		@out.puts "DEBUG: options[:region]=#{options[:region]}" if options[:verbose]
+		@out.puts "DEBUG: lbname=#{lbname}" if options[:verbose]
+		@out.puts "DEBUG: instance_external_id=#{instance_external_id}" if options[:verbose]
+		@out.puts "DEBUG: options[:vpcid]=#{options[:vpcid]}" if options[:verbose]
+		@aws.elb.load_balancer.register_instance(options[:region],lbname,instance_external_id,options[:vpcid],options[:check],@out,(options[:verbose]?@out:nil),options[:undofile])
 	  end
 
 	  desc "deregister_instance LOAD_BALANCER_NAME INSTANCE_EXTERNAL_ID","Deregister an instance identified by the INSTANCE_EXTERNAL_ID is registered with load balancer identified by LOAD_BALANCER_NAME."
 	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :default => nil
 	  def deregister_instance(lbname,instance_external_id) 
-		$stdout.puts "DEBUG: options[:region]=#{options[:region]}" if options[:verbose]
-		$stdout.puts "DEBUG: lbname=#{lbname}" if options[:verbose]
-		$stdout.puts "DEBUG: instance_external_id=#{instance_external_id}" if options[:verbose]
-		$stdout.puts "DEBUG: options[:vpcid]=#{options[:vpcid]}" if options[:verbose]
-		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		aws.elb.load_balancer.deregister_instance(options[:region],lbname,instance_external_id,options[:vpcid],$stdout,(options[:verbose]?$stdout:nil))
+		@out.puts "DEBUG: options[:region]=#{options[:region]}" if options[:verbose]
+		@out.puts "DEBUG: lbname=#{lbname}" if options[:verbose]
+		@out.puts "DEBUG: instance_external_id=#{instance_external_id}" if options[:verbose]
+		@out.puts "DEBUG: options[:vpcid]=#{options[:vpcid]}" if options[:verbose]
+		@aws.elb.load_balancer.deregister_instance(options[:region],lbname,instance_external_id,options[:vpcid],@out,(options[:verbose]?@out:nil))
 	  end
 
 	  desc "exists_listener LOAD_BALANCER_NAME LBPROTOCOL LBPORT INPROTOCOL INPORT","Determine if a listener is registered with load balancer."
 	  def exists_listener(lbname,lbprotocol,lbport,inprotocol,inport) 
-		$stdout.puts "DEBUG: lbname=#{lbname}" if options[:verbose] 
-        $stdout.puts "DEBUG: lbprotocol=#{lbprotocol}" if options[:verbose]
-        $stdout.puts "DEBUG: lbport=#{lbport}" if options[:verbose]
-        $stdout.puts "DEBUG: inprotocol=#{inprotocol}" if options[:verbose]
-		$stdout.puts "DEBUG: inport=#{inport}" if options[:verbose]
-		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		aws.elb.load_balancer.exists_listener(options[:region],lbname,lbprotocol,lbport,inprotocol,inport,$stdout,(options[:verbose]?$stdout:nil))
+		@out.puts "DEBUG: lbname=#{lbname}" if options[:verbose] 
+        @out.puts "DEBUG: lbprotocol=#{lbprotocol}" if options[:verbose]
+        @out.puts "DEBUG: lbport=#{lbport}" if options[:verbose]
+        @out.puts "DEBUG: inprotocol=#{inprotocol}" if options[:verbose]
+		@out.puts "DEBUG: inport=#{inport}" if options[:verbose]
+		@aws.elb.load_balancer.exists_listener(options[:region],lbname,lbprotocol,lbport,inprotocol,inport,@out,(options[:verbose]?@out:nil))
 	  end
 
 	  desc "declare_listener LOAD_BALANCER_NAME LBPROTOCOL LBPORT INPROTOCOL INPORT","Create a new listener."
-      option :nagios, :type => :boolean, :desc => "Returns a nagios check result",  :aliases => :n, :default => false
+      option :check, :type => :boolean, :desc => "Returns a check result",  :aliases => :n, :default => false
 	  option :undofile, :type => :string, :desc => "File for undo commands", :banner => "<undofile>", :aliases => :f, :default => nil
 	  def declare_listener(lbname,lbprotocol,lbport,inprotocol,inport) 
-		$stdout.puts "DEBUG: lbname=#{lbname}" if options[:verbose] 
-        $stdout.puts "DEBUG: lbprotocol=#{lbprotocol}" if options[:verbose]
-        $stdout.puts "DEBUG: lbport=#{lbport}" if options[:verbose]
-        $stdout.puts "DEBUG: inprotocol=#{inprotocol}" if options[:verbose]
-		$stdout.puts "DEBUG: inport=#{inport}" if options[:verbose]
-		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		aws.elb.load_balancer.declare_listener(options[:region],lbname,lbprotocol,lbport,inprotocol,inport,options[:nagios],$stdout,(options[:verbose]?$stdout:nil),options[:undofile])
+		@out.puts "DEBUG: lbname=#{lbname}" if options[:verbose] 
+        @out.puts "DEBUG: lbprotocol=#{lbprotocol}" if options[:verbose]
+        @out.puts "DEBUG: lbport=#{lbport}" if options[:verbose]
+        @out.puts "DEBUG: inprotocol=#{inprotocol}" if options[:verbose]
+		@out.puts "DEBUG: inport=#{inport}" if options[:verbose]
+		@aws.elb.load_balancer.declare_listener(options[:region],lbname,lbprotocol,lbport,inprotocol,inport,options[:check],@out,(options[:verbose]?@out:nil),options[:undofile])
 	  end
 
 	  desc "delete_listener LOAD_BALANCER_NAME LBPROTOCOL LBPORT INPROTOCOL INPORT","Delete listener."
 	  def delete_listener(lbname,lbprotocol,lbport,inprotocol,inport) 
-		$stdout.puts "DEBUG: lbname=#{lbname}" if options[:verbose] 
-        $stdout.puts "DEBUG: lbprotocol=#{lbprotocol}" if options[:verbose]
-        $stdout.puts "DEBUG: lbport=#{lbport}" if options[:verbose]
-        $stdout.puts "DEBUG: inprotocol=#{inprotocol}" if options[:verbose]
-		$stdout.puts "DEBUG: inport=#{inport}" if options[:verbose]
-		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		aws.elb.load_balancer.delete_listener(options[:region],lbname,lbprotocol,lbport,inprotocol,inport,$stdout,(options[:verbose]?$stdout:nil))
+		@out.puts "DEBUG: lbname=#{lbname}" if options[:verbose] 
+        @out.puts "DEBUG: lbprotocol=#{lbprotocol}" if options[:verbose]
+        @out.puts "DEBUG: lbport=#{lbport}" if options[:verbose]
+        @out.puts "DEBUG: inprotocol=#{inprotocol}" if options[:verbose]
+		@out.puts "DEBUG: inport=#{inport}" if options[:verbose]
+		@aws.elb.load_balancer.delete_listener(options[:region],lbname,lbprotocol,lbport,inprotocol,inport,@out,(options[:verbose]?@out:nil))
 	  end
 
 	end

data/lib/zaws/command/nessus.rb

@@ -0,0 +1,41 @@
+require 'thor'
+
+module ZAWS
+  module Command
+    class Nessus < Thor
+      class_option :verbose, :type => :boolean, :desc => "Verbose outout", :aliases => :d, :default => false
+      class_option :home, :type => :string, :default => ENV['HOME'], :desc => 'Home directory location for credentials file'
+      class_option :viewtype, :type => :string, :desc => "View type, json or table", :banner => "<viewtype>", :aliases => :w, :default => "table"
+
+      attr_accessor :nessus
+      attr_accessor :out
+      attr_accessor :print_exit_code
+
+      def initialize(*args)
+        super
+        shellout=ZAWS::Helper::Shell.new
+        nessusapi = ZAWS::Nessusapi.new(shellout)
+        @nessus = ZAWS::Controllers::Nessus.new(shellout, nessusapi)
+        @out = $stdout
+        @print_exit_code = false
+        @params= {
+           'home' =>  options[:home]
+        }
+      end
+
+      desc "view_scanners", "View scanners."
+      def view_scanners
+        @out.puts(@nessus.scanners.view(@params));
+      end
+
+      desc "view_agents", "View agents."
+      option :scanner, :type => :string, :default => '1', :desc => 'scanner id'
+      def view_agents
+        @params['scanner']=options[:scanner]
+        @out.puts(@nessus.agents.view(params));
+      end
+    end
+  end
+end
+
+

data/lib/zaws/command/newrelic.rb

@@ -0,0 +1,30 @@
+require 'thor'
+
+module ZAWS
+  module Command
+    class Newrelic < Thor
+      class_option :verbose, :type => :boolean, :desc => "Verbose outout", :aliases => :d, :default => false
+
+      attr_accessor :newrelic
+      attr_accessor :out
+      attr_accessor :print_exit_code
+
+      def initialize(*args)
+        super
+        shellout=ZAWS::Helper::Shell.new
+        newrelicapi = ZAWS::Newrelicapi.new(shellout)
+        @newrelic = ZAWS::Controllers::Newrelic.new(shellout, newrelicapi)
+        @out = $stdout
+        @print_exit_code = false
+      end
+
+      desc "view_servers", "View Servers."
+      option :home, :type => :string, :default => ENV['HOME'], :desc => 'Home directory location for credentials file'
+      def view_servers
+        @newrelic.servers.view(options[:home], @out, (options[:verbose] ? @out : nil))
+      end
+
+    end
+  end
+end
+

data/lib/zaws/command/route_table.rb

@@ -2,131 +2,144 @@ require 'thor'
 
 module ZAWS
   module Command
-	class Route_Table < Thor 
-	  class_option :region, :type => :string, :desc => "AWS Region", :banner => "<region>",  :aliases => :r, :required => true
-	  class_option :verbose, :type => :boolean, :desc => "Verbose outout", :aliases => :d, :default => false
-
-	  desc "view","View route tables."
-	  option :viewtype, :type => :string, :desc => "View type, json or table", :banner => "<viewtype>", :aliases => :w, :default => "table"
-	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :default => nil
-	  def view
-		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		aws.ec2.route_table.view(options[:region],options[:viewtype],$stdout,(options[:verbose]?$stdout:nil),options[:vpcid])
-	  end
-
-	  desc "exists_by_external_id EXTERNAL_ID","Determine if a route table exists by EXTERNAL_ID."
-	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :default => nil
-	  def exists_by_external_id(externalid) 
-		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		aws.ec2.route_table.exists(options[:region],$stdout,(options[:verbose]?$stdout:nil),options[:vpcid],externalid)
-	  end
-
-	  desc "declare EXTERNAL_ID VPCID","Declare a new route table by EXTERNAL_ID in VPCID, but skip creating it if it exists."
-      option :nagios, :type => :boolean, :desc => "Returns a nagios check result",  :aliases => :n, :default => false
-	  option :undofile, :type => :string, :desc => "File for undo commands", :banner => "<undofile>", :aliases => :f, :default => nil
-	  def declare(externalid,vpcid) 
-		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		exitcode = aws.ec2.route_table.declare(options[:region],vpcid,externalid,options[:nagios],$stdout,(options[:verbose]?$stdout:nil),options[:undofile])
+    class Route_Table < Thor
+      class_option :region, :type => :string, :desc => "AWS Region", :banner => "<region>", :aliases => :r, :required => true
+      class_option :verbose, :type => :boolean, :desc => "Verbose outout", :aliases => :d, :default => false
+
+      attr_accessor :aws
+      attr_accessor :out
+      attr_accessor :print_exit_code
+
+      def initialize(*args)
+        super
+        shellout=ZAWS::Helper::Shell.new
+        awscli = ZAWS::AWSCLI.new(shellout)
+        @aws = ZAWS::AWS.new(shellout, awscli)
+        @out = $stdout
+        @print_exit_code = false
+      end
+
+      desc "view", "View route tables."
+      option :viewtype, :type => :string, :desc => "View type, json or table", :banner => "<viewtype>", :aliases => :w, :default => "table"
+      option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>", :aliases => :v, :default => nil
+
+      def view
+        @out.puts(@aws.ec2.route_table.view(options[:region], options[:viewtype], @out, (options[:verbose] ? @out : nil), options[:vpcid]))
+      end
+
+      desc "exists_by_external_id EXTERNAL_ID", "Determine if a route table exists by EXTERNAL_ID."
+      option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>", :aliases => :v, :default => nil
+
+      def exists_by_external_id(externalid)
+        @aws.ec2.route_table.exists(options[:region], @out, (options[:verbose] ? @out : nil), options[:vpcid], externalid)
+      end
+
+      desc "declare EXTERNAL_ID VPCID", "Declare a new route table by EXTERNAL_ID in VPCID, but skip creating it if it exists."
+      option :check, :type => :boolean, :desc => "Returns a check result", :aliases => :n, :default => false
+      option :undofile, :type => :string, :desc => "File for undo commands", :banner => "<undofile>", :aliases => :f, :default => nil
+
+      def declare(externalid, vpcid)
+        exitcode = @aws.ec2.route_table.declare(options[:region], vpcid, externalid, options[:check], @out, (options[:verbose] ? @out : nil), options[:undofile])
         exit exitcode
-	  end
-
-	  desc "delete EXTERNAL_ID","Delete route table by its EXTERNAL_ID."
-	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :default => nil
-	  def delete(externalid) 
-		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		aws.ec2.route_table.delete(options[:region],$stdout,(options[:verbose]?$stdout:nil),options[:vpcid],externalid)
-	  end
-
-	  desc "route_exists_by_instance ROUTE_TABLE CIDR_BLOCK INSTANCE_EXTERNAL_ID","Determine if a route exists for CIDR_BLOCK in ROUTE_TABLE to an instance INSTANCE_EXTERNAL_ID."
-	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :default => nil
-	  def route_exists_by_instance(routetable,cidrblock,externalid) 
-		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		aws.ec2.route_table.route_exists_by_instance(options[:region],$stdout,(options[:verbose]?$stdout:nil),options[:vpcid],routetable,cidrblock,externalid)
-	  end
-
-	  desc "declare_route ROUTE_TABLE CIDR_BLOCK INSTANCE_EXTERNAL_ID","Declare a new route to instance INSTANCE_EXTERNAL_ID for CIDR_BLOCK in ROUTE_TABLE, but skip creating it if it exists."
-	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :default => nil
-      option :nagios, :type => :boolean, :desc => "Returns a nagios check result",  :aliases => :n, :default => false
-	  option :undofile, :type => :string, :desc => "File for undo commands", :banner => "<undofile>", :aliases => :f, :default => nil
-	  def declare_route(routetable,cidrblock,externalid) 
-		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		exitcode = aws.ec2.route_table.declare_route(options[:region],$stdout,(options[:verbose]?$stdout:nil),options[:vpcid],routetable,cidrblock,externalid,options[:nagios],options[:undofile])
+      end
+
+      desc "delete EXTERNAL_ID", "Delete route table by its EXTERNAL_ID."
+      option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>", :aliases => :v, :default => nil
+
+      def delete(externalid)
+        @aws.ec2.route_table.delete(options[:region], @out, (options[:verbose] ? @out : nil), options[:vpcid], externalid)
+      end
+
+      desc "route_exists_by_instance ROUTE_TABLE CIDR_BLOCK INSTANCE_EXTERNAL_ID", "Determine if a route exists for CIDR_BLOCK in ROUTE_TABLE to an instance INSTANCE_EXTERNAL_ID."
+      option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>", :aliases => :v, :default => nil
+
+      def route_exists_by_instance(routetable, cidrblock, externalid)
+        @aws.ec2.route_table.route_exists_by_instance(options[:region], @out, (options[:verbose] ? @out : nil), options[:vpcid], routetable, cidrblock, externalid)
+      end
+
+      desc "declare_route ROUTE_TABLE CIDR_BLOCK INSTANCE_EXTERNAL_ID", "Declare a new route to instance INSTANCE_EXTERNAL_ID for CIDR_BLOCK in ROUTE_TABLE, but skip creating it if it exists."
+      option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>", :aliases => :v, :default => nil
+      option :check, :type => :boolean, :desc => "Returns a check result", :aliases => :n, :default => false
+      option :undofile, :type => :string, :desc => "File for undo commands", :banner => "<undofile>", :aliases => :f, :default => nil
+
+      def declare_route(routetable, cidrblock, externalid)
+        exitcode = @aws.ec2.route_table.declare_route(options[:region], @out, (options[:verbose] ? @out : nil), options[:vpcid], routetable, cidrblock, externalid, options[:check], options[:undofile])
         exit exitcode
-	  end
-
-      desc "delete_route ROUTE_TABLE CIDR_BLOCK","Delete a route to CIDR_BLOCK in ROUTE_TABLE, but skip deletion if it doesn't exist."
-	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :default => nil
-	  def delete_route(routetable,cidrblock) 
-		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		aws.ec2.route_table.delete_route(options[:region],$stdout,(options[:verbose]?$stdout:nil),options[:vpcid],routetable,cidrblock)
-	  end
-
-	  desc "route_exists_by_gatewayid ROUTE_TABLE CIDR_BLOCK GATEWAY_ID","Determine if a route exists for CIDR_BLOCK in ROUTE_TABLE to GATEWAY_ID."
-	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :default => nil
-	  def route_exists_by_gatewayid(routetable,cidrblock,gatewayid) 
-		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		aws.ec2.route_table.route_exists_by_gatewayid(options[:region],$stdout,(options[:verbose]?$stdout:nil),options[:vpcid],routetable,cidrblock,gatewayid)
-	  end
-
-	  desc "declare_route_to_gateway ROUTE_TABLE CIDR_BLOCK GATEWAY_ID","Declare a new route to GATEWAY_ID, but skip creating it if it exists."
-	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :default => nil
-      option :nagios, :type => :boolean, :desc => "Returns a nagios check result",  :aliases => :n, :default => false
-	  option :undofile, :type => :string, :desc => "File for undo commands", :banner => "<undofile>", :aliases => :f, :default => nil
-	  def declare_route_to_gateway(routetable,cidrblock,gatewayid) 
-		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		exitcode = aws.ec2.route_table.declare_route_to_gateway(options[:region],$stdout,(options[:verbose]?$stdout:nil),options[:vpcid],routetable,cidrblock,gatewayid,options[:nagios],options[:undofile])
+      end
+
+      desc "delete_route ROUTE_TABLE CIDR_BLOCK", "Delete a route to CIDR_BLOCK in ROUTE_TABLE, but skip deletion if it doesn't exist."
+      option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>", :aliases => :v, :default => nil
+
+      def delete_route(routetable, cidrblock)
+        @aws.ec2.route_table.delete_route(options[:region], @out, (options[:verbose] ? @out : nil), options[:vpcid], routetable, cidrblock)
+      end
+
+      desc "route_exists_by_gatewayid ROUTE_TABLE CIDR_BLOCK GATEWAY_ID", "Determine if a route exists for CIDR_BLOCK in ROUTE_TABLE to GATEWAY_ID."
+      option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>", :aliases => :v, :default => nil
+
+      def route_exists_by_gatewayid(routetable, cidrblock, gatewayid)
+        @aws.ec2.route_table.route_exists_by_gatewayid(options[:region], @out, (options[:verbose] ? @out : nil), options[:vpcid], routetable, cidrblock, gatewayid)
+      end
+
+      desc "declare_route_to_gateway ROUTE_TABLE CIDR_BLOCK GATEWAY_ID", "Declare a new route to GATEWAY_ID, but skip creating it if it exists."
+      option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>", :aliases => :v, :default => nil
+      option :check, :type => :boolean, :desc => "Returns a check result", :aliases => :n, :default => false
+      option :undofile, :type => :string, :desc => "File for undo commands", :banner => "<undofile>", :aliases => :f, :default => nil
+
+      def declare_route_to_gateway(routetable, cidrblock, gatewayid)
+        exitcode = @aws.ec2.route_table.declare_route_to_gateway(options[:region], @out, (options[:verbose] ? @out : nil), options[:vpcid], routetable, cidrblock, gatewayid, options[:check], options[:undofile])
         exit exitcode
-	  end
-
-	  desc "subnet_assoc_exists ROUTE_TABLE_EXTERNAL_ID CIDRBLOCK","Determine if a route table is associated to a subnet."
-	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :default => nil
-	  def subnet_assoc_exists(rtable_externalid,cidrblock) 
-		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		aws.ec2.route_table.subnet_assoc_exists(options[:region],$stdout,(options[:verbose]?$stdout:nil),options[:vpcid],rtable_externalid,cidrblock)
-	  end
-
-	  desc "assoc_subnet ROUTE_TABLE_EXTERNAL_ID CIDRBLOCK","Associate a route table to a subnet."
-	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :default => nil
-      option :nagios, :type => :boolean, :desc => "Returns a nagios check result",  :aliases => :n, :default => false
-	  option :undofile, :type => :string, :desc => "File for undo commands", :banner => "<undofile>", :aliases => :f, :default => nil
-	  def assoc_subnet(rtable_externalid,cidrblock) 
-		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		exitcode = aws.ec2.route_table.assoc_subnet(options[:region],$stdout,(options[:verbose]?$stdout:nil),options[:vpcid],rtable_externalid,cidrblock,options[:nagios],options[:undofile])
-		exit exitcode
-	  end
-
-	  desc "delete_assoc_subnet ROUTE_TABLE_EXTERNAL_ID CIDRBLOCK","Delete association of route table to subnet."
-	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :default => nil
-	  def delete_assoc_subnet(rtable_externalid,cidrblock) 
-		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		aws.ec2.route_table.delete_assoc_subnet(options[:region],$stdout,(options[:verbose]?$stdout:nil),options[:vpcid],rtable_externalid,cidrblock)
-	  end
-
-      desc "propagation_exists_from_gateway ROUTE_TABLE_EXTERNAL_ID VIRTUAL_GATEWAY_ID","Determine if route propagation from a gateway exists."
-	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :default => nil
-	  def propagation_exists_from_gateway(rtable_externalid,vgatewayid) 
-		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		aws.ec2.route_table.propagation_exists_from_gateway(options[:region],$stdout,(options[:verbose]?$stdout:nil),options[:vpcid],rtable_externalid,vgatewayid)
-	  end
-
-	  desc "declare_propagation_from_gateway ROUTE_TABLE_EXTERNAL_ID VIRTUAL_GATEWAY_ID","Propagate routes to the routing tables from a virtual gateway."
-	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :default => nil
-      option :nagios, :type => :boolean, :desc => "Returns a nagios check result",  :aliases => :n, :default => false
-	  option :undofile, :type => :string, :desc => "File for undo commands", :banner => "<undofile>", :aliases => :f, :default => nil
-	  def declare_propagation_from_gateway(rtable_externalid,vgatewayid)
-		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		exitcode = aws.ec2.route_table.declare_propagation_from_gateway(options[:region],$stdout,(options[:verbose]?$stdout:nil),options[:vpcid],rtable_externalid,vgatewayid,options[:nagios],options[:undofile])
-		exit exitcode
-	  end
-
-	  desc "delete_propagation_from_gateway ROUTE_TABLE_EXTERNAL_ID GATEWAY_ID","Delete route propagation from virtual gateway."
-	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :default => nil
-      def delete_propagation_from_gateway(rtable_externalid,vgatewayid)
-        aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
-		aws.ec2.route_table.delete_propagation_from_gateway(options[:region],$stdout,(options[:verbose]?$stdout:nil),options[:vpcid],rtable_externalid,vgatewayid)
-	  end
-
-	end
+      end
+
+      desc "subnet_assoc_exists ROUTE_TABLE_EXTERNAL_ID CIDRBLOCK", "Determine if a route table is associated to a subnet."
+      option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>", :aliases => :v, :default => nil
+
+      def subnet_assoc_exists(rtable_externalid, cidrblock)
+        @aws.ec2.route_table.subnet_assoc_exists(options[:region], @out, (options[:verbose] ? @out : nil), options[:vpcid], rtable_externalid, cidrblock)
+      end
+
+      desc "assoc_subnet ROUTE_TABLE_EXTERNAL_ID CIDRBLOCK", "Associate a route table to a subnet."
+      option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>", :aliases => :v, :default => nil
+      option :check, :type => :boolean, :desc => "Returns a check result", :aliases => :n, :default => false
+      option :undofile, :type => :string, :desc => "File for undo commands", :banner => "<undofile>", :aliases => :f, :default => nil
+
+      def assoc_subnet(rtable_externalid, cidrblock)
+        exitcode = @aws.ec2.route_table.assoc_subnet(options[:region], @out, (options[:verbose] ? @out : nil), options[:vpcid], rtable_externalid, cidrblock, options[:check], options[:undofile])
+        exit exitcode
+      end
+
+      desc "delete_assoc_subnet ROUTE_TABLE_EXTERNAL_ID CIDRBLOCK", "Delete association of route table to subnet."
+      option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>", :aliases => :v, :default => nil
+
+      def delete_assoc_subnet(rtable_externalid, cidrblock)
+        @aws.ec2.route_table.delete_assoc_subnet(options[:region], @out, (options[:verbose] ? @out : nil), options[:vpcid], rtable_externalid, cidrblock)
+      end
+
+      desc "propagation_exists_from_gateway ROUTE_TABLE_EXTERNAL_ID VIRTUAL_GATEWAY_ID", "Determine if route propagation from a gateway exists."
+      option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>", :aliases => :v, :default => nil
+
+      def propagation_exists_from_gateway(rtable_externalid, vgatewayid)
+        @aws.ec2.route_table.propagation_exists_from_gateway(options[:region], @out, (options[:verbose] ? @out : nil), options[:vpcid], rtable_externalid, vgatewayid)
+      end
+
+      desc "declare_propagation_from_gateway ROUTE_TABLE_EXTERNAL_ID VIRTUAL_GATEWAY_ID", "Propagate routes to the routing tables from a virtual gateway."
+      option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>", :aliases => :v, :default => nil
+      option :check, :type => :boolean, :desc => "Returns a check result", :aliases => :n, :default => false
+      option :undofile, :type => :string, :desc => "File for undo commands", :banner => "<undofile>", :aliases => :f, :default => nil
+
+      def declare_propagation_from_gateway(rtable_externalid, vgatewayid)
+        exitcode = @aws.ec2.route_table.declare_propagation_from_gateway(options[:region], @out, (options[:verbose] ? @out : nil), options[:vpcid], rtable_externalid, vgatewayid, options[:check], options[:undofile])
+        exit exitcode
+      end
+
+      desc "delete_propagation_from_gateway ROUTE_TABLE_EXTERNAL_ID GATEWAY_ID", "Delete route propagation from virtual gateway."
+      option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>", :aliases => :v, :default => nil
+
+      def delete_propagation_from_gateway(rtable_externalid, vgatewayid)
+        @aws.ec2.route_table.delete_propagation_from_gateway(options[:region], @out, (options[:verbose] ? @out : nil), options[:vpcid], rtable_externalid, vgatewayid)
+      end
+
+    end
   end
 end