aws-eni 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5bd70f82e45aa8e1c89003fefe1118b3c3e7a0ff
-  data.tar.gz: 8f7c1cbbb2136f722d34f8d414a167327e6920f0
+  metadata.gz: fe0e076295a17d9cc4c63a7227f83be289fcb4b3
+  data.tar.gz: 51dfdb49ec4bba211e5105f3eafed74fc210cdcc
 SHA512:
-  metadata.gz: 3d7d4e8422d6232c893375f284b4cbc33b232c2cbc2af731be6f679540c017ab97e6162a22ce52ca011a49ca11dac653f862b51bba9893ebf5ed6a78ca280b89
-  data.tar.gz: 09dafcec8f9c13900c99754f0dfad80b7a912da55512de34f163a8a546fc4cdd2efaba04b8eb34032f5dd6857a95e35c9cce5c686272818cf32093c81af0ec24
+  metadata.gz: aa9fd08058dfda15e1c473108105d37e6aaf1c64a322fe249a1c5f469b494399895395f2df2c18d12df7a1d5cbac8811393693e48d032d5824c0b70fc6880b72
+  data.tar.gz: 7da3b4bd53b7944f744e02c76bc9dc7a691cde2b76ecb708dba83006045e21a3dd30e4c8f35cc0f149762079e4d94f4a9c732e38c2bfb4e54a0fe7c886ccdfae

data/bin/aws-eni

@@ -24,6 +24,7 @@ desc 'Display all system commands and warnings'
 switch [:V,:verbose], negatable: false
 
 pre do |opt|
+  Aws::ENI.timeout 90
   Aws::ENI::IFconfig.verbose = opt[:verbose]
   true
 end
@@ -236,13 +237,13 @@ arg 'security-groups', :optional
 arg 'ip-address', :optional
 command [:attach] do |c|
   c.desc 'Do not configure or enable the device after attachment (implies block)'
-  c.switch [:n,'no-config'], negatable: false
+  c.switch [:n,:noconfig], negatable: false
 
   c.desc 'Do not return until attachment is complete'
   c.switch [:b,:block], negatable: false
 
   c.action do |global,opts,args|
-    config = !opts['no_config']
+    config = !opts[:noconfig]
     if args.first =~ /^eni-/
       help_now! 'Too many arguments' if args.count > 1
       id = args.first
@@ -275,6 +276,9 @@ command [:detach] do |c|
   c.desc 'Delete (or preserve) the unused ENI resource after dataching (implies block)'
   c.switch [:d,:delete], default_value: :not_provided # GLI behavior workaround
 
+  c.desc 'Release any associated public IP addresses'
+  c.switch [:r,:release], negatable: false
+
   c.desc 'Do not return until detachment is complete'
   c.switch [:b,:block], negatable: false
 
@@ -283,9 +287,18 @@ command [:detach] do |c|
     params = parse_args args, :interface_id, :device_name
     params[:block] = opts[:block]
     params[:delete] = opts[:delete] unless opts[:delete] == :not_provided
+    params[:release] = opts[:release]
     id = params[:device_name] || params[:interface_id]
 
     device = Aws::ENI.detach_interface(id, params)
+
+    device[:public_ips].each do |address|
+      if device[:released]
+        puts "EIP #{address[:public_ip]} (#{address[:allocation_id]}) dissociated and released"
+      else
+        puts "EIP #{address[:public_ip]} (#{address[:allocation_id]}) dissociated"
+      end
+    end
     if device[:deleted]
       puts "interface #{device[:interface_id]} detached from #{device[:device_name]} and deleted"
     else
@@ -310,10 +323,24 @@ command [:clean] do |c|
   c.desc 'Force deletion of all unattached interfaces which meet our criteria'
   c.switch [:f,:force], negatable: false
 
+  c.desc 'Release any associated public IP addresses'
+  c.switch [:r,:release], negatable: false
+
   c.action do |global,opts,args|
     help_now! "Too many arguments" if args.count > 1
-    deleted = Aws::ENI.clean_interfaces(args.first, safe_mode: !opts[:force])
-    puts "#{deleted[:count]} interfaces deleted"
+    deleted = Aws::ENI.clean_interfaces(args.first, safe_mode: !opts[:force], release: opts[:release])
+
+    deleted[:public_ips].each do |address|
+      if deleted[:released]
+        puts "EIP #{address[:public_ip]} (#{address[:allocation_id]}) dissociated and released"
+      else
+        puts "EIP #{address[:public_ip]} (#{address[:allocation_id]}) dissociated"
+      end
+    end
+    deleted[:interfaces].each do |interface_id|
+      puts "interface #{interface_id} deleted"
+    end
+    puts "#{deleted[:interfaces].count} interfaces deleted"
   end
 end
 
@@ -328,7 +355,7 @@ arg 'ip-address', :optional
 arg 'interface-id OR device-name'
 command [:assign] do |c|
   c.desc 'Do not configure the interface after assignment'
-  c.switch [:n,'no-config'], negatable: false
+  c.switch [:n,:noconfig], negatable: false
 
   c.desc 'Do not return until connection is verified'
   c.switch [:b,:block], negatable: false
@@ -338,7 +365,7 @@ command [:assign] do |c|
     device = params[:device_name] || params[:interface_id]
     help_now! "Missing argument" if device.nil?
 
-    params.merge! configure: !opts['no-config'], block: opts[:block]
+    params.merge! configure: !opts[:noconfig], block: opts[:block]
     Aws::ENI.assert_ifconfig_access if params[:configure]
 
     assignment = Aws::ENI.assign_secondary_ip(device, params)
@@ -395,10 +422,11 @@ command [:associate] do |c|
   c.switch [:b,:block], negatable: false
 
   c.action do |global,opts,args|
-    help_now! "Missing argument" if args.empty?
     args.delete('new')
     params = parse_args args, :private_ip, :public_ip, :allocation_id, :interface_id, :device_name
     params[:block] = opts[:block]
+    help_now! "Missing argument" unless params[:private_ip]
+
     assoc = Aws::ENI.associate_elastic_ip(params[:private_ip], params)
     puts "EIP #{assoc[:public_ip]} (#{assoc[:allocation_id]}) associated with #{assoc[:private_ip]} on #{assoc[:device_name]} (#{assoc[:interface_id]})"
   end
@@ -418,6 +446,7 @@ command [:dissociate] do |c|
 
   c.action do |global,opts,args|
     params = parse_args args, :private_ip, :public_ip, :allocation_id, :association_id, :interface_id, :device_name
+    params[:release] = opts[:release]
     address = params[:private_ip] || params[:public_ip] || params[:association_id] || params[:allocation_id]
     help_now! "Missing argument" unless address
     dissoc = Aws::ENI.dissociate_elastic_ip(address, params)

data/lib/aws-eni.rb

@@ -123,6 +123,9 @@ module Aws
         interface_id:  options[:interface_id],
         device_number: options[:device_number]
       )
+      if device.name == 'eth0'
+        raise InvalidParameterError, "For safety, interface eth0 cannot be detached."
+      end
       interface_id = device.interface_id
 
       response = client.describe_network_interfaces(filters: [{
@@ -142,7 +145,19 @@ module Aws
         force: true
       )
       created_by_us = interface.tag_set.any? { |tag| tag.key == 'created by' && tag.value == owner_tag }
-      do_delete = options[:delete] || options[:delete].nil? && created_by_us
+      do_delete = options[:delete] != false && created_by_us
+      do_release = !!options[:release]
+
+      public_ips = []
+      interface[:private_ip_addresses].each do |addr|
+        if assoc = addr[:association]
+          public_ips << {
+            public_ip:     assoc[:public_ip],
+            allocation_id: assoc[:allocation_id]
+          }
+          dissociate_elastic_ip(assoc[:allocation_id], release: true) if do_release
+        end
+      end
 
       if options[:block] || do_delete
         wait_for 'the interface to detach', interval: 0.3 do
@@ -156,12 +171,16 @@ module Aws
         device_number: device.device_number,
         created_by_us: created_by_us,
         deleted:       do_delete,
+        released:      do_release,
+        public_ips:    public_ips,
         api_response:  interface
       }
     end
 
     # delete unattached network interfaces
     def clean_interfaces(filter = nil, options = {})
+      public_ips = []
+      do_release = !!options[:release]
       safe_mode = true unless options[:safe_mode] == false
 
       filters = [
@@ -186,20 +205,30 @@ module Aws
 
       descriptions = client.describe_network_interfaces(filters: filters)
       interfaces = descriptions[:network_interfaces].select do |interface|
-        unless safe_mode && interface.tag_set.any? do |tag|
+        created_recently = interface.tag_set.any? do |tag|
           begin
             tag.key == 'created on' && Time.now - Time.parse(tag.value) < 60
           rescue ArgumentError
-            false
           end
         end
+        unless safe_mode && created_recently
+          interface[:private_ip_addresses].each do |addr|
+            if assoc = addr[:association]
+              public_ips << {
+                public_ip:     assoc[:public_ip],
+                allocation_id: assoc[:allocation_id]
+              }
+              dissociate_elastic_ip(assoc[:allocation_id], release: true) if do_release
+            end
+          end
           client.delete_network_interface(network_interface_id: interface[:network_interface_id])
           true
         end
       end
       {
-        count:        interfaces.count,
-        deleted:      interfaces.map { |eni| eni[:network_interface_id] },
+        interfaces:   interfaces.map { |eni| eni[:network_interface_id] },
+        public_ips:   public_ips,
+        released:     do_release,
         api_response: interfaces
       }
     end
@@ -216,7 +245,7 @@ module Aws
       current_ips = interface_ips(interface_id)
       new_ip = options[:private_ip]
 
-      if new_ip = options[:private_ip]
+      if new_ip
         if current_ips.include?(new_ip)
           raise InvalidParameterError, "IP #{new_ip} already assigned to #{device.name}"
         end
@@ -226,7 +255,8 @@ module Aws
           allow_reassignment: false
         )
         wait_for 'private ip address to be assigned' do
-          interface_ips(interface_id).include?(new_ip)
+          interface_ips(interface_id).include?(new_ip) ||
+          device.local_ips.include?(new_ip)
         end
       else
         client.assign_private_ip_addresses(
@@ -236,6 +266,7 @@ module Aws
         )
         wait_for 'new private ip address to be assigned' do
           new_ips = interface_ips(interface_id) - current_ips
+          new_ips = device.local_ips - current_ips if new_ips.empty?
           new_ip = new_ips.first if new_ips
         end
       end
@@ -279,7 +310,7 @@ module Aws
       end
 
       if assoc = addr_info[:association]
-        client.release_address(allocation_id: assoc[:allocation_id]) if do_release
+        dissociate_elastic_ip(assoc[:allocation_id], release: do_release)
       end
 
       device.remove_alias(private_ip)
@@ -291,15 +322,17 @@ module Aws
         private_ip:     private_ip,
         device_name:    device.name,
         interface_id:   device.interface_id,
-        public_ip:      assoc[:public_ip],
-        allocation_id:  assoc[:allocation_id],
-        association_id: assoc[:association_id],
+        public_ip:      assoc && assoc[:public_ip],
+        allocation_id:  assoc && assoc[:allocation_id],
+        association_id: assoc && assoc[:association_id],
         released:       assoc && do_release
       }
     end
 
     # associate a private ip with an elastic ip through the AWS api
     def associate_elastic_ip(private_ip, options = {})
+      raise MissingParameterError, "You must specify a private ip address" unless private_ip
+
       find = options[:device_name] || options[:device_number] || options[:interface_id] || private_ip
       device = IFconfig[find].assert(
         exists: true,
@@ -345,32 +378,54 @@ module Aws
 
     # dissociate a public ip from a private ip through the AWS api and
     # optionally release the public ip
-    def dissociate_elastic_ip(ip, options = {})
+    def dissociate_elastic_ip(address, options = {})
       do_release = !!options[:release]
-      eip = describe_address(ip)
 
-      if find = options[:device_name] || options[:device_number] || options[:interface_id]
+      # assert device attributes if we've specified a device
+      if find = options[:device_name] || options[:device_number]
         device = IFconfig[find].assert(
           device_name:   options[:device_name],
           device_number: options[:device_number],
-          interface_id:  options[:interface_id]
+          interface_id:  options[:interface_id],
+          private_ip:    options[:private_ip],
+          public_ip:     options[:public_ip]
         )
-        if device.interface_id != eip[:network_interface_id]
-          raise UnknownInterfaceError, "EIP #{public_ip} is not associated with interface #{device.name} (#{device.interface_id})"
-        end
-      else
-        begin
-          device = IFconfig[eip[:network_interface_id]]
-        rescue UnknownInterfaceError
-          raise UnknownInterfaceError, "EIP #{public_ip} is not associated with an interface on this machine"
+      end
+
+      # get our address info
+      eip = describe_address(address)
+      device ||= IFconfig.find { |dev| dev.interface_id == eip[:network_interface_id] }
+
+      # assert eip attributes if options provided
+      if options[:private_ip] && eip[:private_ip_address] != options[:private_ip]
+        raise InvalidParameterError, "#{address} is not associated with IP #{options[:private_ip]}"
+      end
+      if options[:public_ip] && eip[:public_ip] != options[:public_ip]
+        raise InvalidParameterError, "#{address} is not associated with public IP #{options[:public_ip]}"
+      end
+      if options[:allocation_id] && eip[:allocation_id] != options[:allocation_id]
+        raise InvalidParameterError, "#{address} is not associated with allocation ID #{options[:allocation_id]}"
+      end
+      if options[:association_id] && eip[:association_id] != options[:association_id]
+        raise InvalidParameterError, "#{address} is not associated with association ID #{options[:association_id]}"
+      end
+      if options[:interface_id] && eip[:network_interface_id] != options[:interface_id]
+        raise InvalidParameterError, "#{address} is not associated with interface ID #{options[:interface_id]}"
+      end
+
+      if device
+        if device.name == 'eth0' && device.local_ips.first == eip[:private_ip_address]
+          raise InvalidParameterError, "For safety, a public address cannot be dissociated from the primary IP on eth0"
         end
+      elsif interface_status(eip[:network_interface_id]) != 'available'
+        raise InvalidParameterError, "#{address} is associated with an interface attached to another machine"
       end
 
       client.disassociate_address(association_id: eip[:association_id])
       client.release_address(allocation_id: eip[:allocation_id]) if do_release
       {
         private_ip:     eip[:private_ip_address],
-        device_name:    device.name,
+        device_name:    device && device.name,
         interface_id:   eip[:network_interface_id],
         public_ip:      eip[:public_ip],
         allocation_id:  eip[:allocation_id],
@@ -478,7 +533,7 @@ module Aws
         when /^eipalloc-/
           'allocation-id'
         when /^eipassoc-/
-          'allocation-id'
+          'association-id'
         else
           if IPAddr.new(environment[:vpc_cidr]) === IPAddr.new(address)
             'private-ip-address'

data/lib/aws-eni/version.rb

@@ -1,5 +1,5 @@
 module Aws
   module ENI
-    VERSION = "0.2.0"
+    VERSION = "0.2.1"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: aws-eni
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Mike Greiling
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-01 00:00:00.000000000 Z
+date: 2015-05-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: gli