zaws 0.0.1

data/lib/zaws/ec2/subnet.rb

@@ -0,0 +1,108 @@
+require 'json'
+require 'netaddr'
+require 'timeout'
+
+module ZAWS
+  module EC2Services
+	class Subnet 
+
+	  def initialize(shellout,aws)
+		@shellout=shellout
+		@aws=aws
+	  end
+
+	  def view(region,view,textout=nil,verbose=nil,vpcid=nil,cidrblock=nil)
+		comline="aws --output #{view} --region #{region} ec2 describe-subnets"
+		if vpcid || cidrblock
+		  comline = comline + " --filter"
+		end
+		comline = comline + " 'Name=vpc-id,Values=#{vpcid}'" if vpcid 
+		comline = comline + " 'Name=cidr,Values=#{cidrblock}'" if cidrblock 
+		subnets=@shellout.cli(comline,verbose)
+		textout.puts(subnets) if textout
+		return subnets
+	  end
+
+	  def id_by_ip(region,textout=nil,verbose=nil,vpcid,ip)
+		subnets=JSON.parse(view(region,'json',nil,verbose,vpcid))
+		subnet_id=nil
+		subnets["Subnets"].each { |x| subnet_id = x["SubnetId"] if (NetAddr::CIDR.create(x["CidrBlock"])).contains?(ip) }
+		textout.puts subnet_id if textout
+		return subnet_id
+	  end
+
+	  def id_by_cidrblock(region,textout=nil,verbose=nil,vpcid,cidrblock)
+		subnets=JSON.parse(view(region,'json',nil,verbose,vpcid,cidrblock))
+		subnet_id= subnets["Subnets"].count == 1 ? subnets["Subnets"][0]["SubnetId"] : nil
+		textout.puts subnet_id if textout
+		return subnet_id
+	  end
+
+      def id_array_by_cidrblock_array(region,textout=nil,verbose=nil,vpcid,cidrblock_array)
+		return cidrblock_array.map {|x| id_by_cidrblock(region,nil,verbose,vpcid,x)}
+	  end
+
+	  def exists(region,textout=nil,verbose=nil,vpcid,cidrblock)
+		val = id_by_cidrblock(region,nil,verbose,vpcid,cidrblock) ? true : false
+		textout.puts val.to_s if textout
+		return val 
+	  end
+
+	  def declare(region,vpcid,cidrblock,availabilityzone,statetimeout,textout=nil,verbose=nil,nagios=false,ufile=nil)
+        if ufile
+          ZAWS::Helper::File.prepend("zaws subnet delete --region #{region} --cidrblock #{cidrblock} --vpcid #{vpcid} $XTRA_OPTS",'#Delete subnet',ufile)
+		end
+		if not exists(region,nil,verbose,vpcid,cidrblock) 
+          if nagios
+            textout.puts "CRITICAL: Subnet Does Not Exist."
+			return 2
+		  end
+		  comline="aws --output json --region #{region} ec2 create-subnet --vpc-id #{vpcid} --cidr-block #{cidrblock} --availability-zone #{availabilityzone}"
+		  subnet=@shellout.cli(comline,verbose)
+		  begin
+			Timeout.timeout(statetimeout) do
+			  until available(subnet,verbose)
+				sleep(1)
+				subnet=view(region,'json',nil,verbose,vpcid,cidrblock)
+			  end
+			end
+			textout.puts "Subnet created."
+		  rescue Timeout::Error
+			throw 'Timeout before Subnet made available.'
+		  end
+		else
+          if nagios
+            textout.puts "OK: Subnet Exists."
+			return 0
+		  end
+		  textout.puts "No action needed. Subnet exists already."
+		end
+	  end
+
+	  def available(subnet,verbose)
+		#based on the structure of the return from create-subnet and describe-subnet determine if subnet is available
+		subnet_hash=JSON.parse(subnet)
+		if subnet_hash["Subnet"]
+		  return (subnet_hash["Subnet"]["State"] == "available")
+		end
+		if subnet_hash["Subnets"] and subnet_hash["Subnets"].count == 1
+		  return (subnet_hash["Subnets"][0]["State"] == "available")
+		end
+		return false
+	  end
+
+	  def delete(region,textout=nil,verbose=nil,vpcid,cidrblock)
+        subnetid=id_by_cidrblock(region,nil,verbose,vpcid,cidrblock)
+		if subnetid 
+		  comline="aws --region #{region} ec2 delete-subnet --subnet-id #{subnetid}"
+          val=JSON.parse(@shellout.cli(comline,verbose))
+		  textout.puts "Subnet deleted." if val["return"] == "true"
+		else
+		  textout.puts "Subnet does not exist. Skipping deletion."
+		end
+	  end
+
+	end
+  end
+end
+

data/lib/zaws/ec2.rb

@@ -0,0 +1,40 @@
+require 'json'
+require 'netaddr'
+require 'timeout'
+
+module ZAWS
+  class EC2
+
+	def initialize(shellout,aws)
+	  @shellout=shellout
+	  @aws=aws
+	end
+
+	def subnet 
+	  @_subnet ||= (ZAWS::EC2Services::Subnet.new(@shellout,@aws))
+	  return @_subnet
+	end
+	
+	def security_group
+	  @_security_group ||= (ZAWS::EC2Services::SecurityGroup.new(@shellout,@aws))
+	  return @_security_group
+	end
+
+	def route_table 
+	  @_route_table ||= (ZAWS::EC2Services::RouteTable.new(@shellout,@aws))
+	  return @_route_table
+	end
+	
+	def compute 
+	  @_compute ||= (ZAWS::EC2Services::Compute.new(@shellout,@aws))
+	  return @_compute
+	end
+		
+	def elasticip 
+	  @_elasticip ||= (ZAWS::EC2Services::Elasticip.new(@shellout,@aws))
+	  return @_elasticip
+	end
+	
+  end
+end
+

data/lib/zaws/elb/load_balancer.rb

@@ -0,0 +1,157 @@
+require 'json'
+require 'netaddr'
+require 'timeout'
+
+module ZAWS
+  module ELBServices
+	class LoadBalancer 
+
+	  def initialize(shellout,aws)
+		@shellout=shellout
+		@aws=aws
+	  end
+
+	  def view(region,view,textout=nil,verbose=nil)
+		comline="aws --output #{view} --region #{region} elb describe-load-balancers"
+		lbs=@shellout.cli(comline,verbose)
+		textout.puts(lbs) if textout
+		return lbs
+	  end
+
+	  def exists(region,lbname,textout=nil,verbose=nil)
+		lbs=JSON.parse(view(region,'json',nil,verbose))
+		val = lbs["LoadBalancerDescriptions"].any? { |x| x["LoadBalancerName"]=="#{lbname}" }
+		instances = val ? (lbs["LoadBalancerDescriptions"].select { |x| x["LoadBalancerName"]=="#{lbname}" })[0]["Instances"] : nil
+		ldescriptions = val ? (lbs["LoadBalancerDescriptions"].select { |x| x["LoadBalancerName"]=="#{lbname}" })[0]["ListenerDescriptions"] : nil
+		textout.puts(val) if textout
+		return val,instances,ldescriptions 
+	  end
+
+	  def calculated_listener(lbprotocol,lbport,inprotocol,inport,sslcert=nil)
+		listeners = []
+		single_listener = {}
+		single_listener["Protocol"]="#{lbprotocol}"
+		single_listener["LoadBalancerPort"]=lbport.to_i
+		single_listener["InstanceProtocol"]="#{inprotocol}"
+		single_listener["InstancePort"]=inport.to_i
+		single_listener["SSLCertificateId"]="#{sslcert}" if sslcert
+		listeners << single_listener
+		return listeners.to_json
+	  end
+
+	  def create_in_subnet(region,lbname,lbprotocol,lbport,inprotocol,inport,securitygroup,cidrblocks,vpcid,nagios=false,textout=nil,verbose=nil,ufile=nil)
+		if ufile
+		  ZAWS::Helper::File.prepend("zaws load_balancer delete #{lbname} --region #{region} $XTRA_OPTS",'#Delete load balancer',ufile)
+		end
+		lbexists,instances,ldescriptions=exists(region,lbname,nil,verbose)
+		return ZAWS::Helper::Output.binary_nagios_check(lbexists,"OK: Load Balancer Exists.","CRITICAL: Load Balancer does not exist.",textout) if nagios
+		if not lbexists
+		  comline="aws --region #{region} elb create-load-balancer"
+		  comline+=" --load-balancer-name #{lbname}"
+		  comline+=" --listeners '#{calculated_listener(lbprotocol,lbport,inprotocol,inport)}'"
+		  comline+=" --subnets #{@aws.ec2.subnet.id_array_by_cidrblock_array(region,nil,nil,vpcid,cidrblocks).join(" ")}"
+		  sgroup_exists,sgroupid = @aws.ec2.security_group.exists(region,nil,nil,vpcid,securitygroup)
+		  comline+=" --security-groups #{sgroupid}"
+		  newlb=JSON.parse(@shellout.cli(comline,verbose))
+		  textout.puts "Load balancer created." if newlb["DNSName"]
+		else
+		  textout.puts "Load balancer already exists. Skipping creation."
+		end
+	  end
+
+	  def delete(region,lbname,textout=nil,verbose=nil)
+		lbexists,instances,ldescriptions=exists(region,lbname,nil,verbose)
+		if lbexists
+		  comline="aws --region #{region} elb delete-load-balancer"
+		  comline+=" --load-balancer-name #{lbname}"
+		  deletelb=JSON.parse(@shellout.cli(comline,verbose))
+		  textout.puts "Load balancer deleted." if deletelb["return"] == "true"
+		else
+		  textout.puts "Load balancer does not exist. Skipping deletion." 
+		end
+	  end
+
+	  def exists_instance(region,lbname,instance_external_id,vpcid,textout=nil,verbose=nil)
+		lbexists,instances,ldescriptions=exists(region,lbname,nil,verbose)
+		instance_exists,instance_id = @aws.ec2.compute.exists(region,nil,verbose,vpcid,instance_external_id)          
+		val = (lbexists and instance_exists and (instances.any? { |x| x["InstanceId"]==instance_id }))
+		textout.puts(val) if textout
+		return val, instance_id
+	  end
+
+	  def register_instance(region,lbname,instance_external_id,vpcid,nagios=false,textout=nil,verbose=nil,ufile=nil)
+        if ufile
+		  ZAWS::Helper::File.prepend("zaws load_balancer deregister_instance #{lbname} #{instance_external_id} --region #{region} --vpcid my_vpc_id $XTRA_OPTS",'#Deregister instance',ufile)
+		end
+        instance_registered,instance_id = exists_instance(region,lbname,instance_external_id,vpcid,nil,verbose) 
+		return ZAWS::Helper::Output.binary_nagios_check(instance_registered,"OK: Instance registerd.","CRITICAL: Instance not registered.",textout) if nagios
+		if not instance_registered
+          comline="aws --region #{region} elb register-instances-with-load-balancer"
+		  comline+=" --load-balancer-name #{lbname}"
+          comline+=" --instances #{instance_id}"
+		  newinstance=JSON.parse(@shellout.cli(comline,verbose))
+		  verbose.puts "DEBUG: newinstance=#{newinstance} TODO: need to know if it is returning a json object with a return key." if verbose
+		  textout.puts "New instance registered." if newinstance["return"] == "true"
+		else
+		  textout.puts "Instance already registered. Skipping registration."
+		end
+	  end
+
+	  def deregister_instance(region,lbname,instance_external_id,vpcid,textout=nil,verbose=nil)
+        instance_registered,instance_id = exists_instance(region,lbname,instance_external_id,vpcid,nil,verbose) 
+		if instance_registered
+		  comline="aws --region #{region} elb deregister-instances-with-load-balancer"
+		  comline+=" --load-balancer-name #{lbname}"
+          comline+=" --instances #{instance_id}"
+		  newinstance=JSON.parse(@shellout.cli(comline,verbose))
+		  verbose.puts "DEBUG: newinstance=#{newinstance} TODO: need to know if it is returning a json object with a return key." if verbose
+		  textout.puts "Instance deregistered." if newinstance["return"] == "true"
+		else
+		  textout.puts "Instance not registered. Skipping deregistration."
+		end
+	  end
+
+	  def exists_listener(region,lbname,lbprotocol,lbport,inprotocol,inport,textout=nil,verbose=nil)
+		lbexists,instances,ldescriptions=exists(region,lbname,nil,verbose)
+	    verbose.puts ldescriptions if verbose
+		val = (lbexists and (ldescriptions.any? { |x| x["Listener"]["LoadBalancerPort"]==(lbport.to_i) && x["Listener"]["Protocol"]==lbprotocol && x["Listener"]["InstancePort"]==(inport.to_i) && x["Listener"]["InstanceProtocol"]==inprotocol }))
+		textout.puts(val) if textout
+		return val
+	  end
+
+	  def declare_listener(region,lbname,lbprotocol,lbport,inprotocol,inport,nagios=false,textout=nil,verbose=nil,ufile=nil)
+        if ufile
+		  ZAWS::Helper::File.prepend("zaws load_balancer delete_listener #{lbname} #{lbprotocol} #{lbport} #{inprotocol} #{inport} --region #{region} $XTRA_OPTS",'#Delete listener',ufile)
+		end
+        lexists=exists_listener(region,lbname,lbprotocol,lbport,inprotocol,inport,nil,verbose)
+		return ZAWS::Helper::Output.binary_nagios_check(lexists,"OK: Listerner exists.","CRITICAL: Listener does not exist.",textout) if nagios
+        if not lexists
+     	  comline="aws --region #{region} elb create-load-balancer-listeners"
+		  comline+=" --load-balancer-name #{lbname}"
+          comline+=" --listeners '#{calculated_listener(lbprotocol,lbport,inprotocol,inport)}'"
+		  newlistener=JSON.parse(@shellout.cli(comline,verbose))
+		  verbose.puts "DEBUG: newinstance=#{newlistener} TODO: need to know if it is returning a json object with a return key." if verbose
+		  textout.puts "Listener created." if newlistener["return"] == "true"
+		else
+          textout.puts "Listerner exists. Skipping creation."
+		end
+	  end
+
+      def delete_listener(region,lbname,lbprotocol,lbport,inprotocol,inport,textout=nil,verbose=nil)
+        lexists=exists_listener(region,lbname,lbprotocol,lbport,inprotocol,inport,nil,verbose)
+        if lexists
+     	  comline="aws --region #{region} elb delete-load-balancer-listeners"
+		  comline+=" --load-balancer-name #{lbname}"
+          comline+=" --load-balancer-ports '#{lbport}'"
+		  dellistener=JSON.parse(@shellout.cli(comline,verbose))
+		  verbose.puts "DEBUG: newinstance=#{dellistener} TODO: need to know if it is returning a json object with a return key." if verbose
+		  textout.puts "Listerner deleted." if dellistener["return"] == "true"
+		else
+           textout.puts "Listener does not exist. Skipping deletion."
+		end
+	  end
+
+	end
+  end
+end
+

data/lib/zaws/elb.rb

@@ -0,0 +1,20 @@
+require 'json'
+require 'netaddr'
+require 'timeout'
+
+module ZAWS
+  class ELB
+
+	def initialize(shellout,aws)
+	  @shellout=shellout
+	  @aws=aws
+	end
+
+	def load_balancer 
+	  @_load_balancer ||= (ZAWS::ELBServices::LoadBalancer.new(@shellout,@aws))
+	  return @_load_balancer
+	end
+
+  end
+end
+

data/lib/zaws/helper/file.rb

@@ -0,0 +1,23 @@
+module ZAWS
+  module Helper
+	class File
+
+	  # This prepend function not currently unit tested, 
+	  # see "thor/spec/actions/file_manipulation_spec" 
+	  # for ideas on how to accomplish this.
+	  def self.prepend(command,description,filepath)
+        new_file=filepath + ".new"
+        IO::File.open(new_file, 'w') do |fo|
+          fo.puts description
+          fo.puts command
+          IO::File.foreach(filepath) do |li|
+            fo.puts li
+          end
+        end
+        IO::File.rename(new_file, filepath)
+	  end
+
+	end
+  end
+end
+

data/lib/zaws/helper/option.rb

@@ -0,0 +1,24 @@
+
+module ZAWS
+  module Helper
+	class Option
+
+	  def self.exists?(optarr,opt_hash)
+		optarr.all? { |opt| opt_hash[opt] }
+	  end
+
+      def self.absent(optarr,opt_hash)
+        optarr.inject([]) { |missing,opt| opt_hash[opt] ? missing : missing << opt }
+	  end
+
+      def self.exclusive?(optarr,opt_hash)
+		(optarr.inject(0) { |total,opt| opt_hash[opt] ? total + 1 : total }) <= 1
+	  end
+
+	  def self.minimum?(min,optarr,opt_hash)
+		(optarr.inject(0) { |total,opt| opt_hash[opt] ? total + 1 : total }) >= min 
+	  end
+
+	end
+  end
+end

data/lib/zaws/helper/output.rb

@@ -0,0 +1,46 @@
+
+module AWS_consts
+  # Color codes http://kpumuk.info/ruby-on-rails/colorizing-console-ruby-script-output/
+   COLOR_RED=31
+   COLOR_GREEN=32
+   COLOR_YELLOW=33
+   COLOR_DEFAULT=39
+   COLOR_BLUE=34
+   COLOR_CYAN=36
+end
+
+module ZAWS
+  module Helper
+	class Output 
+
+	  def self.colorize(text, color_code)
+		"\e[#{color_code}m#{text}\e[0m"
+	  end
+
+	  def self.opt_required(output,opt_arr)
+		opt_arr.each { |opt| output.puts(" --#{opt} required!") }
+	  end
+
+      def self.opt_exclusive(output,opt_arr)
+        output.puts("  These options cannot be combined:")
+		opt_arr.each { |opt| output.puts("    --#{opt}") }
+	  end
+
+      def self.opt_minimum(output,min,opt_arr)
+        output.puts("  At mininum, #{min} of the following is required:")
+		opt_arr.each { |opt| output.puts("    --#{opt}") }
+	  end
+
+      def self.binary_nagios_check(ok_condition,ok_msg,critical_msg,textout=nil)
+        if ok_condition
+          textout.puts ok_msg if textout
+		  return 0
+		else
+          textout.puts critical_msg if textout
+		  return 2
+		end
+	  end
+
+	end
+  end
+end

data/lib/zaws/helper/shell.rb

@@ -0,0 +1,25 @@
+require 'mixlib/shellout'
+
+module ZAWS
+  module Helper
+	class Shell 
+
+	  def cli(command,output=nil)
+		output.puts ZAWS::Helper::Output.colorize(command,AWS_consts::COLOR_BLUE) if output
+        list = Mixlib::ShellOut.new(command)
+		list.run_command
+		list.error!
+		return list.stdout
+	  end
+
+	  def if_then(condition,command,output=nil)
+		if not condition
+		  output.puts ZAWS::Helper::Output.colorize(command,AWS_consts::COLOR_BLUE) if output
+		  return nil 	
+		end
+		return cli(command,output)
+	  end
+
+	end
+  end
+end

data/lib/zaws/route53/hosted_zone.rb

@@ -0,0 +1,36 @@
+require 'json'
+require 'netaddr'
+require 'timeout'
+
+module ZAWS
+  module Route53Services
+	class HostedZone 
+
+	  def initialize(shellout,aws)
+		@shellout=shellout
+		@aws=aws
+	  end
+
+ 	  def view(viewtype,textout=nil,verbose=nil)
+		comline="aws --output #{viewtype} route53 list-hosted-zones"
+		zones=@shellout.cli(comline,verbose)
+		textout.puts(zones) if textout
+		return zones 
+	  end
+
+	  def view_records(viewtype,textout=nil,verbose=nil,zonename)
+        zones=JSON.parse(view('json',nil,verbose))
+		zone_id=nil
+		zones["HostedZones"].each { |x| zone_id = ("#{x["Name"]}"=="#{zonename}") ? x["Id"] : nil }
+        if zone_id
+		  comline="aws --output #{viewtype} route53 list-resource-record-sets --hosted-zone-id #{zone_id}"
+		  records=@shellout.cli(comline,verbose)
+		  textout.puts(records) if textout
+		  return records 
+		end
+	  end
+
+	end
+  end
+end
+

data/lib/zaws/route53.rb

@@ -0,0 +1,20 @@
+require 'json'
+require 'netaddr'
+require 'timeout'
+
+module ZAWS
+  class Route53
+
+	def initialize(shellout,aws)
+	  @shellout=shellout
+	  @aws=aws
+	end
+
+	def hosted_zone 
+	  @_hosted_zone ||= (ZAWS::Route53Services::HostedZone.new(@shellout,@aws))
+	  return @_hosted_zone
+	end
+		
+  end
+end
+

data/lib/zaws/version.rb

@@ -0,0 +1,3 @@
+module ZAWS
+  VERSION = "0.0.1"
+end

data/lib/zaws.rb

@@ -0,0 +1,57 @@
+require "zaws/version"
+require "zaws/helper/option"
+require "zaws/helper/output"
+require "zaws/helper/shell"
+require "zaws/helper/file"
+require "zaws/command/subnet"
+require "zaws/command/security_group"
+require "zaws/command/route_table"
+require "zaws/command/compute"
+require "zaws/command/elasticip"
+require "zaws/command/load_balancer"
+require "zaws/command/hosted_zone"
+require "zaws/aws"
+require "zaws/ec2"
+require "zaws/elb"
+require "zaws/route53"
+require "zaws/ec2/subnet"
+require "zaws/ec2/security_group"
+require "zaws/ec2/route_table"
+require "zaws/ec2/compute"
+require "zaws/ec2/elasticip"
+require "zaws/elb/load_balancer"
+require "zaws/route53/hosted_zone"
+require "thor"
+
+module ZAWS
+  class ZAWSCLI < Thor
+
+	desc "subnet","ec2 subnet(s)"
+	subcommand "subnet",ZAWS::Command::Subnet
+
+	desc "security_group","ec2 security group(s)"
+	subcommand "security_group",ZAWS::Command::Security_Group
+
+	desc "route_table","ec2 route table(s)"
+	subcommand "route_table",ZAWS::Command::Route_Table
+
+	desc "compute","ec2 compute instance(s)"
+	subcommand "compute",ZAWS::Command::Compute
+
+        desc "elasticip","ec2 elasticip(s)"
+	subcommand "elasticip",ZAWS::Command::Elasticip
+
+        desc "load_balancer","elb load balancer(s)"
+	subcommand "load_balancer",ZAWS::Command::Load_Balancer
+
+        desc "hosted_zone","elb hosted_zone(s)"
+	subcommand "hosted_zone",ZAWS::Command::Hosted_Zone
+
+	desc "version","Get the version of the Zynx AWS Automation Tool."
+	def version
+	  puts "zaws version #{ZAWS::VERSION}"
+	end
+
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+require 'coveralls'
+Coveralls.wear_merged!
+require 'zaws'
+

data/spec/zaws/ec2/compute/add_volume_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe ZAWS::EC2Services::Compute do 
+
+  it "add volume to instance" do
+
+	volumes = <<-eos
+    { "VolumeId": "vol-1234abcd" }
+	eos
+
+	attachvolume = <<-eos
+    {
+       "AttachTime": "YYYY-MM-DDTHH:MM:SS.000Z",
+	   "InstanceId": "id-X",
+	   "VolumeId": "vol-1234abcd",
+	   "State": "attaching",
+	   "Device": "/dev/sda"		}
+	eos
+	
+	tag_created = <<-eos
+      { "return":"true" }
+	eos
+
+	textout=double('outout')
+	shellout=double('ZAWS::Helper::Shell')
+	expect(shellout).to receive(:cli).with("aws --output json --region us-west-1 ec2 create-volume --availability-zone us-west-1a --size 70",nil).and_return(volumes)
+	expect(shellout).to receive(:cli).with("aws --output json --region us-west-1 ec2 create-tags --resources vol-1234abcd --tags Key=externalid,Value=extername",nil).and_return(tag_created)
+	expect(shellout).to receive(:cli).with("aws --output json --region us-west-1 ec2 create-tags --resources vol-1234abcd --tags Key=Name,Value=extername",nil).and_return(tag_created)
+    expect(shellout).to receive(:cli).with('ping -q -c 2 0.0.0.0',nil).and_return(true)
+	expect(shellout).to receive(:cli).with("aws --output json ec2 attach-volume --region us-west-1 --volume-id vol-1234abcd --instance-id id-X --device /dev/sda",nil).and_return(attachvolume)
+    aws=ZAWS::AWS.new(shellout)
+	bdm = aws.ec2.compute.add_volume('us-west-1','id-X','extername','0.0.0.0','/dev/sda','us-west-1a',70,nil)
+
+  end
+
+end
+
+
+

data/spec/zaws/ec2/compute/block_device_mapping_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+
+describe ZAWS::EC2Services::Compute do 
+
+  it "provides a block device mapping overriding the root size" do
+
+	images = <<-eos
+      { "Images": [
+		 { "RootDeviceName": "/dev/sda1", 
+		   "BlockDeviceMappings": [
+		    { "DeviceName": "/dev/sda1",
+			  "Ebs": {
+			    "DeleteOnTermination": true,
+			    "SnapshotId": "snap-XXX",
+				"VolumeSize": 7,
+				"VolumeType": "standard" } } ] } ] }
+	eos
+
+	textout=double('outout')
+	shellout=double('ZAWS::Helper::Shell')
+	expect(shellout).to receive(:cli).with("aws --output json --region us-west-1 ec2 describe-images --owner me --image-ids X",nil).and_return(images)
+	aws=ZAWS::AWS.new(shellout)
+	bdm = aws.ec2.compute.block_device_mapping('us-west-1','me',nil,70,'X')
+	expect(bdm).to eq('[{"DeviceName":"/dev/sda1","Ebs":{"DeleteOnTermination":true,"SnapshotId":"snap-XXX","VolumeSize":70,"VolumeType":"standard"}}]')
+
+  end
+
+end
+
+
+

data/spec/zaws/ec2/compute/instance_id_by_external_id_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe ZAWS::EC2Services::Compute do 
+
+  it "provides an instance id when you give it a external id" do
+
+	compute_instances = <<-eos
+	 {  "Reservations": [ 
+	   { "Instances" : [ {"InstanceId": "i-XXXXXXX","Tags": [ { "Value": "my_instance","Key": "externalid" } ] } ] } 
+	   ] } 
+	eos
+
+	textout=double('outout')
+	shellout=double('ZAWS::Helper::Shell')
+	expect(shellout).to receive(:cli).with("aws --output json --region us-west-1 ec2 describe-instances --filter 'Name=vpc-id,Values=my_vpc_id' 'Name=tag:externalid,Values=my_instance'",nil).and_return(compute_instances)
+	aws=ZAWS::AWS.new(shellout)
+	instanceid = aws.ec2.compute.instance_id_by_external_id('us-west-1','my_instance','my_vpc_id',nil,nil)
+	expect(instanceid).to eq("i-XXXXXXX")
+  end
+
+end
+
+