smart_proxy_efficient_ip 0.0.12

data/README.md

@@ -0,0 +1,51 @@
+# Smart Proxy EfficientIP (plugin)
+
+## Requirements
+- `Ruby >= 2.5`
+- `Smart Proxy >= 2.3`
+
+## Docker
+
+1. Copy example of settings
+```bash
+cp config/docker_smart-proxy_settings/settings.d/dhcp_efficient_ip.yml.example config/docker_smart-proxy_settings/settings.d/dhcp_efficient_ip.yml
+```
+2. Fill in 3 necessary settings in `dhcp_efficient_ip.yml`:
+- username
+- password
+- server_ip
+
+3. Build and run container:
+
+```bash
+$ docker build -t smart_proxy_efficient_ip:latest .
+$ docker run --rm --name smart_proxy_efficient_ip -it -p 4567:4567 smart_proxy_efficient_ip:latest
+```
+
+4. Enter to the container (optionally if needed)
+```bash
+$ docker exec -it smart_proxy_efficient_ip bash
+```
+
+## Testing
+
+To run all tests:
+`bundle exec rake test`
+
+## Postman
+
+### Import endpoints
+File > Import (Ctrl + O)
+
+file: `postman/smart_proxy.postman_collection.json`
+
+### Automated tests
+
+1. Install `newman`
+```bash
+npm install -g newman
+```
+2. Run tests
+```bash
+newname run postman/smart_proxy.postman_collection.json
+```

data/bundler.d/efficient_ip.rb

@@ -0,0 +1 @@
+gem 'smart_proxy_efficient_ip'

data/config/dhcp_efficient_ip.yml.example

@@ -0,0 +1,5 @@
+---
+:enabled: true
+:username: 'ipmadmin'
+:password: 'admin'
+:server_id: '3.65.1.16'

data/config/docker_smart-proxy_settings/settings.d/dhcp.yml

@@ -0,0 +1,3 @@
+---
+:enabled: http
+:use_provider: dhcp_efficient_ip

data/config/docker_smart-proxy_settings/settings.d/dhcp_efficient_ip.yml.example

@@ -0,0 +1,5 @@
+---
+:enabled: true
+:username: ''
+:password: ''
+:server_ip: ''

data/config/docker_smart-proxy_settings/settings.yml

@@ -0,0 +1,4 @@
+---
+:trusted_hosts: ['*']
+:bind_host: ['*']
+:http_port: 4567

data/lib/smart_proxy_efficient_ip.rb

@@ -0,0 +1,8 @@
+module Proxy
+  module DHCP
+    module EfficientIp
+    end
+  end
+end
+
+require 'smart_proxy_efficient_ip/plugin'

data/lib/smart_proxy_efficient_ip/api.rb

@@ -0,0 +1,102 @@
+module Proxy
+  module DHCP
+    module EfficientIp
+      class Api
+        attr_reader :connection
+
+        def initialize(connection)
+          @connection = connection
+        end
+
+        def find_subnet(network_address)
+          result = connection.ip_subnet_list(
+            where: "start_hostaddr='#{network_address}' and is_terminal='1'",
+            limit: 1
+          )
+          parse(result.body)&.first
+        end
+
+        def subnets
+          result = connection.ip_subnet_list(
+            where: "is_terminal='1' and start_hostaddr!='0.0.0.0'"
+          )
+          parse(result.body)
+        end
+
+        def find_free(network_address, start_ip, end_ip)
+          subnet = find_subnet(network_address)
+
+          result = connection.ip_address_find_free(
+            subnet_id: subnet['subnet_id'],
+            begin_addr: start_ip,
+            end_addr: end_ip,
+            max_find: 1
+          )
+          parse(result.body)&.first
+        end
+
+        def find_record(ip_or_mac)
+          result = connection.ip_address_list(
+            where: "type='ip' and (hostaddr='#{ip_or_mac}' or mac_addr='#{ip_or_mac}')",
+            limit: 1
+          )
+          parse(result.body)&.first
+        end
+
+        def find_records(ip_or_mac)
+          result = connection.ip_address_list(
+            where: "type='ip' and (hostaddr='#{ip_or_mac}' or mac_addr='#{ip_or_mac}')",
+          )
+          parse(result.body)
+        end
+
+        def hosts(network_address)
+          subnet = find_subnet(network_address)
+          result = connection.ip_address_list(
+            where: "subnet_id=#{subnet['subnet_id']} and dhcphost_id > 0"
+          )
+          parse(result.body)
+        end
+
+        def leases(network_address)
+          subnet = find_subnet(network_address)
+          lease_ids = parse(connection.ip_address_list(
+            where: "subnet_id=#{subnet['subnet_id']} and dhcplease_id > 0"
+          ).body).map { |r| r['dhcplease_id'] }
+
+          result = connection.dhcp_lease_list(
+            where: "dhcplease_id IN (#{lease_ids})"
+          )
+
+          parse(result.body)
+        end
+
+        def add_record(params)
+          subnet = find_subnet(params['network'])
+
+          connection.ip_address_add(
+            site_name: subnet['site_name'],
+            ip_addr: params['ip'],
+            mac_addr: params['mac'],
+            name: params['name']
+          )
+        end
+
+        def delete_record(record)
+          subnet = find_subnet(record.subnet.network)
+
+          connection.ip_address_delete(
+            hostaddr: record.ip,
+            site_name: subnet['site_name'],
+          )
+        end
+
+        private
+
+        def parse(response)
+          response.empty? ? nil : JSON.parse(response)
+        end
+      end
+    end
+  end
+end

data/lib/smart_proxy_efficient_ip/configuration.rb

@@ -0,0 +1,36 @@
+module Proxy
+  module DHCP
+    module EfficientIp
+      class Configuration
+        def load_classes
+          require 'SOLIDserver'
+          require 'smart_proxy_efficient_ip/api'
+          require 'smart_proxy_efficient_ip/main'
+        end
+
+        def load_dependency_injection_wirings(container_instance, settings)
+          container_instance.dependency :connection, (lambda do
+            ::SOLIDserver::SOLIDserver.new(
+              settings[:server_ip],
+              settings[:username],
+              settings[:password]
+            )
+          end)
+
+          container_instance.dependency :api, (lambda do
+            ::Proxy::DHCP::EfficientIp::Api.new(
+              container_instance.get_dependency(:connection)
+            )
+          end)
+
+          container_instance.dependency :dhcp_provider, (lambda do
+            ::Proxy::DHCP::EfficientIp::Provider.new(
+              container_instance.get_dependency(:api),
+              settings[:subnets]
+            )
+          end)
+        end
+      end
+    end
+  end
+end

data/lib/smart_proxy_efficient_ip/const.rb

@@ -0,0 +1,41 @@
+module Proxy
+  module DHCP
+    module EfficientIp
+      SIZE_TO_MASK = {
+        1 => '255.255.255.255',
+        2 => '255.255.255.254',
+        4 => '255.255.255.252',
+        8 => '255.255.255.248',
+        16 => '55.255.255.240',
+        32 => '55.255.255.224',
+        64 => '55.255.255.192',
+        128 => '255.255.255.128',
+        256 => '255.255.255.0',
+        512 => '255.255.254.0',
+        1024 => '55.255.252.0',
+        2048 => '55.255.248.0',
+        4096 => '55.255.240.0',
+        8192 => '55.255.224.0',
+        16384 => '255.255.192.0',
+        32768 => '255.255.128.0',
+        65536 => '255.255.0.0',
+        131072 => '55.254.0.0',
+        262144 => '55.252.0.0',
+        524288 => '55.248.0.0',
+        1048576 => '255.240.0.0',
+        2097152 => '255.224.0.0',
+        4194304 => '255.192.0.0',
+        8388608 => '255.128.0.0',
+        16777216 => '55.0.0.0',
+        33554432 => '54.0.0.0',
+        67108864 => '52.0.0.0',
+        134217728 => '248.0.0.0',
+        268435456 => '240.0.0.0',
+        536870912 => '224.0.0.0',
+        1073741824 => '92.0.0.0',
+        2147483648 => '28.0.0.0',
+        4294967296 => '0.0.0.0'
+      }.freeze
+    end
+  end
+end

data/lib/smart_proxy_efficient_ip/main.rb

@@ -0,0 +1,132 @@
+require 'dhcp_common/server'
+require 'smart_proxy_efficient_ip/const'
+require 'smart_proxy_efficient_ip/api'
+
+module Proxy
+  module DHCP
+    module EfficientIp
+      class Provider < ::Proxy::DHCP::Server
+        alias_method :find_record_by_mac, :find_record
+        alias_method :find_record_by_ip, :find_record
+
+        def initialize(api, managed_subnets)
+          @managed_subnets = managed_subnets
+          @api = api
+          super('efficient_ip', managed_subnets, nil)
+        end
+
+        def find_subnet(network_address)
+          logger.debug("Finding subnet #{network_address}")
+          subnet = api.find_subnet(network_address)
+          return nil unless subnet
+
+          netmask = SIZE_TO_MASK[subnet['subnet_size'].to_i]
+          ::Proxy::DHCP::Subnet.new(network_address, netmask)
+        end
+
+        def get_subnet(network_address)
+          find_subnet(network_address) ||
+            raise(Proxy::DHCP::SubnetNotFound.new("No such subnet: %s" % [network_address]))
+        end
+
+        def subnets
+          result = api.subnets
+
+          result.map do |subnet|
+            address = subnet['start_hostaddr']
+            subnet_size = subnet['subnet_size'].to_i
+            netmask = SIZE_TO_MASK[subnet_size]
+
+            if subnet_size >= 1 && managed_subnet?("#{address}/#{netmask}")
+              Proxy::DHCP::Subnet.new(address, netmask)
+            end
+          end.compact
+        end
+
+        def all_hosts(network_address)
+          logger.debug("Fetching hosts for #{network_address}")
+          hosts = api.hosts(network_address)
+          return [] unless hosts
+
+          subnet = find_subnet(network_address)
+          hosts.map do |host|
+            Proxy::DHCP::Reservation.new(
+              host['name'], host['hostaddr'], host['mac_addr'], subnet
+            )
+          end
+        end
+
+        def all_leases(network_address)
+          logger.debug("Fetching leases for #{network_address}")
+          leases = api.leases(network_address)
+          return [] unless leases
+
+          subnet = find_subnet(network_address)
+          leases.map do |lease|
+            Proxy::DHCP::Lease.new(
+              lease['dhcplease_name'],
+              lease['dhcplease_addr'],
+              lease['dhcplease_mac_addr'].split(':')[1..6].join(':'),
+              subnet,
+              DateTime.strptime(lease['dhcplease_first_time'], '%s'),
+              DateTime.strptime(lease['dhcplease_end_time'], '%s'),
+              lease['time_to_expire'].to_i > 0 ? 'active' : 'free'
+            )
+          end
+        end
+
+        def unused_ip(network_address, _, from_ip_address, to_ip_address)
+          logger.debug("Searching first unused ip from:#{from_ip_address} to:#{to_ip_address}")
+
+          free_ip =  api.find_free(network_address, from_ip_address, to_ip_address)
+          free_ip['hostaddr'] if free_ip
+        end
+
+        def find_record(subnet_address, ip_or_mac_address)
+          logger.debug("Finding record for subnet:#{subnet_address} and address:#{ip_or_mac_address}")
+
+          subnet = find_subnet(subnet_address)
+          record = api.find_record(ip_or_mac_address)
+
+          record ? build_reservation(subnet, record) : nil
+        end
+
+        def find_records_by_ip(subnet_address, ip_or_mac)
+          logger.debug("Finding records by address: #{ip_or_mac}")
+
+          records = api.find_records(ip_or_mac)
+          return [] if records.empty?
+          subnet = find_subnet(subnet_address)
+
+          records.map do |record|
+            reserv = build_reservation(subnet, record)
+            reserv unless reserv.nil?
+          end.compact
+        end
+
+        def add_record(params)
+          logger.debug("Adding record with: #{params.to_s}")
+          api.add_record(params)
+        end
+
+        def del_record(record)
+          logger.debug("Deleting record: #{record.to_s}")
+          api.delete_record(record)
+        end
+
+        private
+
+        attr_reader :api, :managed_subnets
+
+        def build_reservation(subnet, record)
+          return nil if record.empty? || record['hostaddr'].empty? || record['mac_addr'].empty?
+
+          opts = { hostname: record['name'] }
+          Proxy::DHCP::Reservation.new(
+            record['name'], record['hostaddr'], record['mac_addr'], subnet, opts
+          )
+        end
+      end
+    end
+  end
+end

data/lib/smart_proxy_efficient_ip/plugin.rb

@@ -0,0 +1,28 @@
+require 'smart_proxy_efficient_ip/version'
+require 'smart_proxy_efficient_ip/configuration'
+
+module Proxy
+  module DHCP
+    module EfficientIp
+      class Plugin < ::Proxy::Provider
+        plugin :dhcp_efficient_ip, ::Proxy::DHCP::EfficientIp::VERSION
+
+        validate_presence :username, :password, :server_ip
+
+        # Settings listed under default_settings are required.
+        # An exception will be raised if they are initialized with nil values.
+        # Settings not listed under default_settings are considered optional and by default have nil value.
+        # default_settings :required_setting => 'default_value'
+
+        requires :dhcp, '>= 2.3'
+
+        # Verifies that a file exists and is readable.
+        # Uninitialized optional settings will not trigger validation errors.
+        # validate_readable :required_path, :optional_path
+
+        load_classes ::Proxy::DHCP::EfficientIp::Configuration
+        load_dependency_injection_wirings ::Proxy::DHCP::EfficientIp::Configuration
+      end
+    end
+  end
+end

data/lib/smart_proxy_efficient_ip/version.rb

@@ -0,0 +1,7 @@
+module Proxy
+  module DHCP
+    module EfficientIp
+      VERSION = '0.0.12'.freeze
+    end
+  end
+end