smart_proxy_ipam 0.0.13 → 0.0.14

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e15677a434645d7983b2d76599f64846fd15676de6752fd552939463156e406c
-  data.tar.gz: a9905c07b628625af2f3d69507f8388d92cfec0cb16fb5bd4583e59ce488147f
+  metadata.gz: f4017f16c516229f75256a5faef4a29916ffd626784c643e77784a4cbb708ec6
+  data.tar.gz: c04dd0e4ee1e7402c02086a60b14360787627cc6a336e7d61d063541b494fad2
 SHA512:
-  metadata.gz: ca743342ca290e14d6c4116475b3106ae71cffff89d7192b7b9873082a5ccaa80b406b25c3d31676b6d51c6cb50efc94c4d821226214de93e1a3c654bb24caf7
-  data.tar.gz: a550aab54cfeff4b727a088cf34cb97deb6e3df0575572d6e007699b248e542840de35aa01ec587f5e75c4d9ed48f5b3ea03fcdefbe332ef76a9ee2478a5ad5c
+  metadata.gz: d8992cd2c717f34846b37b9d8d5e9955835a6e8946c9edfb4d9bb34b793f6e8cdd0ac0a6064479d1b1bbbe78c6345dd8bcf7658046f07e47df2e84458dfd0316
+  data.tar.gz: 42d32cb87be69dfb8467dd618e1ab539e6cef7081e6914ab461520af3ea83cfcdd6469e596efcc3fd75530843401e045a8297288f47dfa407a68445a5afe8ff3

data/lib/smart_proxy_ipam/phpipam/phpipam_api.rb

@@ -14,41 +14,43 @@ module Proxy::Phpipam
 
     # Gets the next available IP address based on a given subnet
     # 
-    # Input:   cidr(string): CIDR address in the format: "100.20.20.0/24"
-    # Returns: Hash with "next_ip", or hash with "error"
-    # Examples: 
-    #   Response if success: 
-    #     {"cidr":"100.20.20.0/24","next_ip":"100.20.20.11"}
-    #   Response if :error =>   
-    #     {"error":"The specified subnet does not exist in phpIPAM."}
-    get '/next_ip' do
+    # Inputs:   address:   Network address of the subnet(e.g. 100.55.55.0)
+    #           prefix:    Network prefix(e.g. 24)
+    # 
+    # Returns: Hash with next available IP address in "data", or hash with "message" containing
+    #          error message from phpIPAM.
+    #
+    # Response if success: 
+    #   {"code": 200, "success": true, "data": "100.55.55.3", "time": 0.012}
+    get '/subnet/:address/:prefix/next_ip' do
       content_type :json
 
       begin
-        err = validate_required_params(["cidr", "mac"], params)
+        err = validate_required_params(["address", "prefix", "mac"], params)
         return err if err.length > 0
 
-        cidr = params[:cidr]
         mac = params[:mac]
+        cidr = params[:address] + '/' + params[:prefix]
         phpipam_client = PhpipamClient.new
         subnet = JSON.parse(phpipam_client.get_subnet(cidr))
+        return {:code => subnet['code'], :error => subnet['message']}.to_json if no_subnets_found(subnet)
+        ipaddr = phpipam_client.get_next_ip(subnet['data'][0]['id'], mac, cidr)
+        return {:code => subnet['code'], :error => ipaddr['message']}.to_json if no_free_ip_found(JSON.parse(ipaddr))
 
-        return {:error => errors[:no_subnet]}.to_json if no_subnets_found(subnet)
-
-        ip = phpipam_client.get_next_ip(subnet[0]['id'], mac, cidr)
-
-        return {:error => errors[:no_free_ip]}.to_json if no_free_ip_found(ip)
-
-        {:cidr => cidr, :next_ip => ip['next_ip']}.to_json
+        ipaddr
       rescue Errno::ECONNREFUSED, Errno::ECONNRESET
-        return {:error => errors[:no_connection]}.to_json
+        logger.debug(errors[:no_connection])
+        raise 
       end
     end
 
     # Gets the subnet from phpIPAM
     # 
-    # Input:   cidr(string): CIDR address in the format: "100.20.20.0/24"
+    # Inputs:   address:   Network address of the subnet
+    #           prefix:    Network prefix(e.g. 24)
+    # 
     # Returns: JSON with "data" key on success, or JSON with "error" key when there is an error
+    # 
     # Examples: 
     #   Response if subnet exists:
     #     {
@@ -64,19 +66,20 @@ module Proxy::Phpipam
     #     {
     #       "code":200,"success":0,"message":"No subnets found","time":0.01
     #     }
-    get '/get_subnet' do
+    get '/subnet/:address/:prefix' do
       content_type :json
 
       begin
-        err = validate_required_params(["cidr"], params)
+        err = validate_required_params(["address", "prefix"], params)
         return err if err.length > 0
 
+        cidr = params[:address] + '/' + params[:prefix]
+
         phpipam_client = PhpipamClient.new
-        subnet = JSON.parse(phpipam_client.get_subnet(params[:cidr]))
-        return {:error => errors[:no_subnet]}.to_json if no_subnets_found(subnet)
-        subnet.to_json
+        phpipam_client.get_subnet(cidr)
       rescue Errno::ECONNREFUSED, Errno::ECONNRESET
-        return {:error => errors[:no_connection]}.to_json
+        logger.debug(errors[:no_connection])
+        raise 
       end
     end
 
@@ -97,9 +100,10 @@ module Proxy::Phpipam
 
       begin
         phpipam_client = PhpipamClient.new
-        phpipam_client.get_sections.to_json
+        phpipam_client.get_sections
       rescue Errno::ECONNREFUSED, Errno::ECONNRESET
-        return {:error => errors[:no_connection]}.to_json
+        logger.debug(errors[:no_connection])
+        raise 
       end
     end
 
@@ -165,107 +169,115 @@ module Proxy::Phpipam
         err = validate_required_params(["section_name"], params)
         return err if err.length > 0
  
-        section_name = URI.decode(params[:section_name])
+        section_name = CGI.unescape(params[:section_name])
         phpipam_client = PhpipamClient.new
-        section = phpipam_client.get_section(section_name)
+        section = JSON.parse(phpipam_client.get_section(section_name))
 
-        return {:error => errors[:no_section]}.to_json if section.nil?
+        return {:code => section['code'], :error => section['message']}.to_json if no_section_found(section)
 
-        subnets = phpipam_client.get_subnets(section['id'].to_s)
-        subnets.to_json
+        phpipam_client.get_subnets(section['data']['id'].to_s)
       rescue Errno::ECONNREFUSED, Errno::ECONNRESET
-        return {:error => errors[:no_connection]}.to_json
+        logger.debug(errors[:no_connection])
+        raise 
       end
     end
 
     # Checks whether an IP address has already been taken in external ipam.
     #
-    # Inputs: 1. ip(string). IP address to be checked.
-    #         2. cidr(string): CIDR address in the format: "100.20.20.0/24"
+    # Params: 1. address:   The network address of the IPv4 or IPv6 subnet.
+    #         2. prefix:    The subnet prefix(e.g. 24)
+    #         3. ip:        IP address to be queried
+    #
     # Returns: JSON object with 'exists' field being either true or false
+    # 
     # Example: 
     #   Response if exists: 
     #     {"ip":"100.20.20.18","exists":true}
     #   Response if not exists:
     #     {"ip":"100.20.20.18","exists":false}
-    get '/ip_exists' do
+    get '/subnet/:address/:prefix/:ip' do
       content_type :json 
 
       begin
-        err = validate_required_params(["cidr", "ip"], params)
+        err = validate_required_params(["address", "prefix", "ip"], params)
         return err if err.length > 0
 
+        ip = params[:ip]
+        cidr = params[:address] + '/' + params[:prefix]
         phpipam_client = PhpipamClient.new
-        subnet = JSON.parse(phpipam_client.get_subnet(params[:cidr]))
+        subnet = JSON.parse(phpipam_client.get_subnet(cidr))
 
-        return {:error => errors[:no_subnet]}.to_json if no_subnets_found(subnet)
+        return {:code => subnet['code'], :error => subnet['message']}.to_json if no_subnets_found(subnet)
 
-        phpipam_client.ip_exists(params[:ip], subnet[0]['id'])
+        phpipam_client.ip_exists(ip, subnet['data'][0]['id'])
       rescue Errno::ECONNREFUSED, Errno::ECONNRESET
-        return {:error => errors[:no_connection]}.to_json
+        logger.debug(errors[:no_connection])
+        raise 
       end
     end
 
-    # Adds an IP address to the specified subnet 
+    # Adds an IP address to the specified subnet
+    #
+    # Params: 1. address:   The network address of the IPv4 or IPv6 subnet.
+    #         2. prefix:    The subnet prefix(e.g. 24)
+    #         3. ip:        IP address to be added
     #
-    # Inputs: 1. ip(string). IP address to be added.
-    #         2. subnet_id(integer). The id of the external ipam subnet
-    #         3. description(string). IP address description
     # Returns: Hash with "message" on success, or hash with "error" 
+    # 
     # Examples:
     #   Response if success: 
-    #     {"message":"IP 100.10.10.123 added to subnet 100.10.10.0/24 successfully."}
+    #     IPv4: {"message":"IP 100.10.10.123 added to subnet 100.10.10.0/24 successfully."}
+    #     IPv6: {"message":"IP 2001:db8:abcd:12::3 added to subnet 2001:db8:abcd:12::/124 successfully."}
     #   Response if :error =>   
     #     {"error":"The specified subnet does not exist in phpIPAM."}
-    post '/add_ip_to_subnet' do
+    post '/subnet/:address/:prefix/:ip' do
       content_type :json
 
       begin
-        err = validate_required_params(["cidr", "ip"], params)
+        err = validate_required_params(["address", "ip", "prefix"], params)
         return err if err.length > 0
 
         ip = params[:ip]
-        cidr = params[:cidr]
+        cidr = params[:address] + '/' + params[:prefix]
         phpipam_client = PhpipamClient.new
         subnet = JSON.parse(phpipam_client.get_subnet(cidr))
 
-        return {:error => errors[:no_subnet]}.to_json if no_subnets_found(subnet)
-
-        phpipam_client.add_ip_to_subnet(ip, subnet[0]['id'], 'Address auto added by Foreman')
+        return {:code => subnet['code'], :error => subnet['message']}.to_json if no_subnets_found(subnet)
 
-        {:message => "IP #{ip} added to subnet #{cidr} successfully."}.to_json
+        phpipam_client.add_ip_to_subnet(ip, subnet['data'][0]['id'], 'Address auto added by Foreman')
       rescue Errno::ECONNREFUSED, Errno::ECONNRESET
-        return {:error => errors[:no_connection]}.to_json
+        logger.debug(errors[:no_connection])
+        raise 
       end
     end
 
     # Deletes IP address from a given subnet
     #
-    # Inputs: 1. ip(string). IP address to be checked.
-    #         2. cidr(string): CIDR address in the format: "100.20.20.0/24"
+    # Params: 1. address:   The network address of the IPv4 or IPv6 subnet.
+    #         2. prefix:    The subnet prefix(e.g. 24)
+    #         3. ip:        IP address to be deleted
+    #
     # Returns: JSON object
     # Example:
     #   Response if success: 
     #     {"code": 200, "success": true, "message": "Address deleted", "time": 0.017}
     #   Response if :error =>   
     #     {"code": 404, "success": 0, "message": "Address does not exist", "time": 0.008}
-    post '/delete_ip_from_subnet' do
+    delete '/subnet/:address/:prefix/:ip' do
       content_type :json
 
       begin
-        err = validate_required_params(["cidr", "ip"], params)
+        err = validate_required_params(["address", "prefix", "ip"], params)
         return err if err.length > 0
 
         ip = params[:ip]
-        cidr = params[:cidr]
+        cidr = params[:address] + '/' + params[:prefix]
         phpipam_client = PhpipamClient.new
         subnet = JSON.parse(phpipam_client.get_subnet(cidr))
 
-        return {:error => errors[:no_subnet]}.to_json if no_subnets_found(subnet)
-
-        phpipam_client.delete_ip_from_subnet(ip, subnet[0]['id'])
+        return {:code => subnet['code'], :error => subnet['message']}.to_json if no_subnets_found(subnet)
 
-        {:message => "IP #{ip} deleted from subnet #{cidr} successfully."}.to_json
+        phpipam_client.delete_ip_from_subnet(ip, subnet['data'][0]['id'])
       rescue Errno::ECONNREFUSED, Errno::ECONNRESET
         return {:error => errors[:no_connection]}.to_json
       end

data/lib/smart_proxy_ipam/phpipam/phpipam_client.rb

@@ -28,109 +28,72 @@ module Proxy::Phpipam
     end
 
     def get_subnet(cidr)
-      subnets = get("subnets/cidr/#{cidr.to_s}")
-      return {:error => errors[:no_subnet]}.to_json if no_subnets_found(subnets)
-      response = []
-
-      # Only return the relevant fields
-      subnets['data'].each do |subnet|
-        response.push({
-          :id => subnet['id'],
-          :subnet => subnet['subnet'],
-          :description => subnet['description'],
-          :mask => subnet['mask']
-        })
-      end
+      response = get("subnets/cidr/#{cidr.to_s}")
+      json_body = JSON.parse(response.body)
 
-      response.to_json
-    end
+      return response.body if no_subnets_found(json_body)
 
-    def add_ip_to_subnet(ip, subnet_id, desc)
-      data = {:subnetId => subnet_id, :ip => ip, :description => desc}
-      post('addresses/', data) 
+      json_body['data'] = filter_fields(json_body, [:id, :subnet, :description, :mask])
+      response.body = json_body.to_json
+      response.header['Content-Length'] = json_body.to_s.length
+      response.body
     end
 
     def get_section(section_name)
-      get("sections/#{section_name}/")["data"]
+      response = get("sections/#{section_name}/")
+      response.body
     end
 
     def get_sections
-      sections = get('sections/')['data']
-      response = []
-
-      if sections
-        sections.each do |section|
-          response.push({
-            :id => section['id'],
-            :name => section['name'],
-            :description => section['description']
-          })
-        end
-      end
-
-      response
+      response = get('sections/')
+      json_body = JSON.parse(response.body)
+      json_body['data'] = filter_fields(json_body, [:id, :name, :description])
+      logger.debug("=================")
+      logger.debug("SECTIONS JSON: " + json_body.to_s)
+      logger.debug("=================")
+      response.body = json_body.to_json
+      response.header['Content-Length'] = json_body.to_s.length
+      response.body
     end
 
     def get_subnets(section_id)
-      subnets = get("sections/#{section_id}/subnets/")
-      response = [] 
-
-      if subnets && subnets['data']
-        # Only return the relevant fields
-        subnets['data'].each do |subnet|
-          response.push({
-            :id => subnet['id'],
-            :subnet => subnet['subnet'],
-            :mask => subnet['mask'],
-            :sectionId => subnet['sectionId'],
-            :description => subnet['description']
-          })
-        end
-      end
-
-      response
+      response = get("sections/#{section_id}/subnets/")
+      json_body = JSON.parse(response.body)
+      json_body['data'] = filter_fields(json_body, [:id, :subnet, :mask, :sectionId, :description])
+      response.body = json_body.to_json
+      response.header['Content-Length'] = json_body.to_s.length
+      response.body
     end
 
     def ip_exists(ip, subnet_id)
-      usage = get_subnet_usage(subnet_id)
-
-      # We need to check subnet usage first in the case there are zero ips in the subnet. Checking
-      # the ip existence on an empty subnet returns a malformed response from phpIPAM(v1.3), containing
-      # HTML in the JSON response.
-      if usage['data']['used'] == "0"
-        return {:ip => ip, :exists => false}.to_json
-      else 
-        response = get("subnets/#{subnet_id.to_s}/addresses/#{ip}/")
-
-        if ip_not_found_in_ipam(response)
-          return {:ip => ip, :exists => false}.to_json
-        else 
-          return {:ip => ip, :exists => true}.to_json
-        end
-      end
+      response = get("subnets/#{subnet_id.to_s}/addresses/#{ip}/")
+      response.body
     end
 
-    
-    def get_subnet_usage(subnet_id)
-      get("subnets/#{subnet_id.to_s}/usage/")
+    def add_ip_to_subnet(ip, subnet_id, desc)
+      data = {:subnetId => subnet_id, :ip => ip, :description => desc}
+      response = post('addresses/', data)
+      response.body
     end
 
     def delete_ip_from_subnet(ip, subnet_id)
-      delete("addresses/#{ip}/#{subnet_id.to_s}/") 
+      response = delete("addresses/#{ip}/#{subnet_id.to_s}/") 
+      response.body
     end
 
     def get_next_ip(subnet_id, mac, cidr)
       response = get("subnets/#{subnet_id.to_s}/first_free/")
+      json_body = JSON.parse(response.body)
       subnet_hash = @@ip_cache[cidr.to_sym]
 
-      return response if response['message']
+      return {:code => json_body['code'], :error => json_body['message']}.to_json if json_body['message']
 
       if subnet_hash && subnet_hash.key?(mac.to_sym)
-        response['next_ip'] = @@ip_cache[cidr.to_sym][mac.to_sym][:ip]
+        json_body['data'] = @@ip_cache[cidr.to_sym][mac.to_sym][:ip]
       else
         next_ip = nil
-        new_ip = response['data']
-        ip_not_in_cache = subnet_hash && !subnet_hash.to_s.include?(new_ip.to_s)  
+        new_ip = json_body['data']
+        ip_not_in_cache = subnet_hash.nil? ? true : !subnet_hash.to_s.include?(new_ip.to_s)
 
         if ip_not_in_cache
           next_ip = new_ip.to_s
@@ -139,20 +102,15 @@ module Proxy::Phpipam
           next_ip = find_new_ip(subnet_id, new_ip, mac, cidr)
         end
 
-        if next_ip.nil?
-          response['error'] = "Unable to find another available IP address in subnet #{cidr}"
-          return response
-        end
-
-        unless usable_ip(next_ip, cidr)
-          response['error'] = "It is possible that there are no more free addresses in subnet #{cidr}. Available IP's may be cached, and could become available after in-memory IP cache is cleared(up to #{CLEAR_CACHE_DELAY} seconds)."
-          return response
-        end
+        return {:code => 404, :error => "Unable to find another available IP address in subnet #{cidr}"}.to_json if next_ip.nil?
+        return {:code => 404, :error => "It is possible that there are no more free addresses in subnet #{cidr}. Available IP's may be cached, and could become available after in-memory IP cache is cleared(up to #{DEFAULT_CLEANUP_INTERVAL} seconds)."}.to_json unless usable_ip(next_ip, cidr)
 
-        response['next_ip'] = next_ip
+        json_body['data'] = next_ip
       end
 
-      response
+      response.body = json_body.to_json
+      response.header['Content-Length'] = json_body.to_s.length
+      response.body
     end
 
     def start_cleanup_task
@@ -195,7 +153,7 @@ module Proxy::Phpipam
     def add_ip_to_cache(ip, mac, cidr)
       logger.debug("Adding IP #{ip} to cache for subnet #{cidr}")
       @@m.synchronize do
-        #clear cache data which has the same mac and ip with the new one 
+        # Clear cache data which has the same mac and ip with the new one 
         @@ip_cache.each do |key, values|
           if values.keys.include? mac.to_sym
             @@ip_cache[key].delete(mac.to_sym)
@@ -224,7 +182,7 @@ module Proxy::Phpipam
         verify_ip = JSON.parse(ip_exists(new_ip, subnet_id))
 
         # If new IP doesn't exist in IPAM and not in the cache
-        if verify_ip['exists'] == false && !ip_exists_in_cache(new_ip, cidr, mac)
+        if ip_not_found_in_ipam(verify_ip) && !ip_exists_in_cache(new_ip, cidr, mac)
           found_ip = new_ip.to_s
           add_ip_to_cache(found_ip, mac, cidr)
           break
@@ -255,18 +213,15 @@ module Proxy::Phpipam
       network.include?(IPAddr.new(ip)) && network.to_range.last != ip
     end
 
-    def get(path, body=nil)
+    def get(path)
       authenticate
       uri = URI(@api_base + path)
-      uri.query = URI.encode_www_form(body) if body
       request = Net::HTTP::Get.new(uri)
       request['token'] = @token
 
-      response = Net::HTTP.start(uri.hostname, uri.port) {|http|
+      Net::HTTP.start(uri.hostname, uri.port) {|http|
         http.request(request)
       }
-
-      JSON.parse(response.body)
     end
 
     def delete(path, body=nil)
@@ -276,11 +231,9 @@ module Proxy::Phpipam
       request = Net::HTTP::Delete.new(uri)
       request['token'] = @token
 
-      response = Net::HTTP.start(uri.hostname, uri.port) {|http|
+      Net::HTTP.start(uri.hostname, uri.port) {|http|
         http.request(request)
       }
-
-      JSON.parse(response.body)
     end
 
     def post(path, body=nil)
@@ -290,11 +243,9 @@ module Proxy::Phpipam
       request = Net::HTTP::Post.new(uri)
       request['token'] = @token
 
-      response = Net::HTTP.start(uri.hostname, uri.port) {|http|
+      Net::HTTP.start(uri.hostname, uri.port) {|http|
         http.request(request)
       }
-
-      JSON.parse(response.body)
     end
 
     def authenticate

data/lib/smart_proxy_ipam/phpipam/phpipam_helper.rb

@@ -6,13 +6,17 @@ module PhpipamHelper
         err.push errors[param.to_sym]
       end
     end
-    err.length == 0 ? [] : {:error => err}.to_json
+    err.length == 0 ? [] : {:code => 400, :error => err}.to_json
   end
 
   def no_subnets_found(subnet)
     !subnet.kind_of?(Array) && subnet['message'] && subnet['message'].downcase == "no subnets found"
   end
 
+  def no_section_found(section)
+    section['message'] && section['message'].downcase == "not found"
+  end
+
   def no_free_ip_found(ip)
     !ip.kind_of?(Array) && ip['message'] && ip['message'].downcase == "no free addresses found"
   end
@@ -21,15 +25,23 @@ module PhpipamHelper
     ip && ip['message'] && ip['message'].downcase == 'no addresses found'
   end
   
+  # Returns an array of hashes with only the fields given in the fields param
+  def filter_fields(json_body, fields)
+    data = []
+    json_body['data'].each do |subnet|
+      item = {}
+      fields.each do |field| item[field.to_sym] = subnet[field.to_s] end
+      data.push(item)
+    end if json_body && json_body['data']
+    data
+  end
+
   def errors
     {
-      :cidr => "A 'cidr' parameter for the subnet must be provided(e.g. 100.10.10.0/24)",
+      :cidr => "A 'cidr' parameter for the subnet must be provided(e.g. IPv4: 100.10.10.0/24, IPv6: 2001:db8:abcd:12::/124)",
       :mac => "A 'mac' address must be provided(e.g. 00:0a:95:9d:68:10)",
-      :ip => "Missing 'ip' parameter. An IPv4 address must be provided(e.g. 100.10.10.22)",
+      :ip => "Missing 'ip' parameter. An IPv4 or IPv6 address must be provided(e.g. IPv4: 100.10.10.22, IPv6: 2001:db8:abcd:12::3)",
       :section_name => "A 'section_name' must be provided",
-      :no_free_ip => "There are no more free addresses in this subnet",
-      :no_section => "Section not found in External IPAM.",
-      :no_subnet => "The specified subnet does not exist in External IPAM.",
       :no_connection => "Unable to connect to External IPAM server"
     }
   end

data/lib/smart_proxy_ipam/version.rb

@@ -1,6 +1,6 @@
 
 module Proxy
   module Ipam
-    VERSION = '0.0.13'
+    VERSION = '0.0.14'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: smart_proxy_ipam
 version: !ruby/object:Gem::Version
-  version: 0.0.13
+  version: 0.0.14
 platform: ruby
 authors:
 - Christopher Smith
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-10-16 00:00:00.000000000 Z
+date: 2019-12-17 00:00:00.000000000 Z
 dependencies: []
 description: Smart proxy plugin for IPAM integration with various IPAM providers
 email: chrisjsmith001@gmail.com