zaws 0.0.1

data/lib/zaws/command/elasticip.rb

@@ -0,0 +1,47 @@
+require 'thor'
+
+module ZAWS
+  module Command
+	class Elasticip < 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 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])
+	  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])
+		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 :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])
+		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])
+		return val
+	  end
+
+	end
+  end
+end
+
+	

data/lib/zaws/command/hosted_zone.rb

@@ -0,0 +1,26 @@
+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
+  end
+end
+
+	

data/lib/zaws/command/load_balancer.rb

@@ -0,0 +1,113 @@
+require 'thor'
+
+module ZAWS
+  module Command
+	class Load_Balancer < 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 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))
+	  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))
+		return val
+	  end
+
+	  desc "create_in_subnets","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 :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])
+		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))
+	  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))
+	  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 :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])
+	  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))
+	  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))
+	  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 :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])
+	  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))
+	  end
+
+	end
+  end
+end
+

data/lib/zaws/command/route_table.rb

@@ -0,0 +1,134 @@
+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","Declare a new route table by EXTERNAL_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(externalid) 
+		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
+		exitcode = aws.ec2.route_table.declare(options[:region],options[:vpcid],externalid,options[:nagios],$stdout,(options[:verbose]?$stdout: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])
+        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 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])
+        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
+end
+
+	

data/lib/zaws/command/security_group.rb

@@ -0,0 +1,69 @@
+require 'thor'
+
+module ZAWS
+  module Command
+	class Security_Group < 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 security groups."
+	  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.security_group.view(options[:region],options[:viewtype],$stdout,(options[:verbose]?$stdout:nil),options[:vpcid])
+	  end
+
+	  desc "exists_by_name GROUP_NAME","Determine if a security group exists by name GROUP_NAME."
+	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :default => nil
+	  def exists_by_name(group_name) 
+		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
+		aws.ec2.security_group.exists(options[:region],$stdout,(options[:verbose]?$stdout:nil),options[:vpcid],group_name)
+	  end
+
+	  desc "declare GROUP_NAME DESCRIPTION","Declare a new security group GROUP_NAME, 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(group_name,description) 
+		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
+		exitcode = aws.ec2.security_group.declare(options[:region],options[:vpcid],group_name,description,options[:nagios],$stdout,(options[:verbose]?$stdout:nil),options[:undofile])
+        exit exitcode
+	  end
+
+	  desc "delete GROUP_NAME","Delete a new security group GROUP_NAME, but skip it if it does not exist."
+	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :default => nil
+	  def delete(group_name) 
+		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
+		aws.ec2.security_group.delete(options[:region],$stdout,(options[:verbose]?$stdout:nil),options[:vpcid],group_name)
+	  end
+
+	  desc "ingress_group_exists TARGET_GROUP_NAME SOURCE_GROUP_NAME PROTOCOL PORT","Determine if an ingress security group rule exists."
+	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :default => nil
+	  def ingress_group_exists(target,source,protocol,port) 
+		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
+		aws.ec2.security_group.ingress_group_exists(options[:region],options[:vpcid],target,source,protocol,port,$stdout,(options[:verbose]?$stdout:nil))
+	  end
+
+	  desc "declare_ingress_group TARGET_GROUP_NAME SOURCE_GROUP_NAME PROTOCOL PORT","Declare an ingress security group rule."
+	  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_ingress_group(target,source,protocol,port) 
+		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
+		exitcode = aws.ec2.security_group.declare_ingress_group(options[:region],options[:vpcid],target,source,protocol,port,options[:nagios],$stdout,(options[:verbose]?$stdout:nil),options[:undofile])
+		exit exitcode
+	  end
+
+	  desc "delete_ingress_group TARGET_GROUP_NAME SOURCE_GROUP_NAME PROTOCOL PORT","Delete an ingress security group rule."
+	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :default => nil
+	  def delete_ingress_group(target,source,protocol,port) 
+		aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
+		aws.ec2.security_group.delete_ingress_group(options[:region],options[:vpcid],target,source,protocol,port,$stdout,(options[:verbose]?$stdout:nil))
+	  end
+
+	end
+  end
+end
+
+	

data/lib/zaws/command/subnet.rb

@@ -0,0 +1,65 @@
+require 'thor'
+
+module ZAWS
+  module Command
+	class Subnet < 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 subnets."
+	  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.subnet.view(options[:region],options[:viewtype],$stdout,(options[:verbose]?$stdout:nil),options[:vpcid])
+	  end
+
+	  desc "id_subnet_by_ip","get subnet id by specifying ip address in subnet"
+	  option :privateip, :type => :string, :desc => "ip addresses", :banner => "<privateip>", :aliases => :p, :required => true
+	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :required => true
+	  def id_by_ip
+        aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
+	    aws.ec2.subnet.id_by_ip(options[:region],$stdout,(options[:verbose]?$stdout:nil),options[:vpcid],options[:privateip])
+	  end
+
+	  desc "id_subnet_by_cidrblock","get subnet id by specifying cidrblock for subnet"
+	  option :cidrblock, :type => :string, :desc => "cidrblock", :banner => "<cidrblock>", :aliases => :c, :required => true
+	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :required => true
+	  def id_by_cidrblock
+        aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
+		aws.ec2.subnet.id_by_cidrblock(options[:region],$stdout,(options[:verbose]?$stdout:nil),options[:vpcid],options[:cidrblock])
+	  end
+
+	  desc "exists","determine if a subnet exists."
+	  option :cidrblock, :type => :string, :desc => "cidrblock", :banner => "<cidrblock>", :aliases => :c, :required => true
+	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :required => true
+	  def exists 
+        aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
+		aws.ec2.subnet.exists(options[:region],$stdout,(options[:verbose]?$stdout:nil),options[:vpcid],options[:cidrblock])
+	  end
+
+	  desc "declare","create a subnet if it does not exist already"
+	  option :cidrblock, :type => :string, :desc => "cidrblock", :banner => "<cidrblock>", :aliases => :c, :required => true
+	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :required => true
+      option :availabilityzone, :type => :string, :desc => "AWS availability zone (eg us-west-1,us-west-2,...)", :banner => "<azone>",  :aliases => :a, :required => true
+      option :availabilitytimeout, :type => :numeric, :desc => "AWS availability zone (eg us-west-1,us-west-2,...)", :banner => "<azone>",  :aliases => :t, :default => 30
+      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 
+        aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
+		exitcode=aws.ec2.subnet.declare(options[:region],options[:vpcid],options[:cidrblock],options[:availabilityzone],options[:availabilitytimeout],$stdout,(options[:verbose]?$stdout:nil),options[:nagios],options[:undofile])
+		exit exitcode
+	  end
+
+	  desc "delete","delete a subnet if it exists already"
+	  option :cidrblock, :type => :string, :desc => "cidrblock", :banner => "<cidrblock>", :aliases => :c, :required => true
+	  option :vpcid, :type => :string, :desc => "AWS VPC id", :banner => "<vpcid>",  :aliases => :v, :required => true
+	  def delete 
+        aws=(ZAWS::AWS.new(ZAWS::Helper::Shell.new))
+		aws.ec2.subnet.delete(options[:region],$stdout,(options[:verbose]?$stdout:nil),options[:vpcid],options[:cidrblock])
+	  end
+
+
+	end
+  end
+end