knife-ionoscloud 6.0.0.beta.1 → 6.0.0.beta.2

data/lib/chef/knife/ionoscloud_natgateway_rule_update.rb

@@ -0,0 +1,116 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudNatgatewayRuleUpdate < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud natgateway rule update (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'ID of the data center'
+
+      option :natgateway_id,
+              short: '-G NATGATEWAY_ID',
+              long: '--natgateway-id NATGATEWAY_ID',
+              description: 'ID of the NAT Gateway'
+
+      option :natgateway_rule_id,
+              short: '-R RULE_ID',
+              long: '--rule-id RULE_ID',
+              description: 'ID of the NAT Gateway Rule'
+
+      option :name,
+              short: '-n NAME',
+              long: '--name NAME',
+              description: 'Name of the NAT gateway rule'
+
+      option :type,
+              short: '-t TYPE',
+              long: '--type TYPE',
+              description: 'Type of the NAT gateway rule'
+
+      option :protocol,
+              short: '-p PROTOCOL',
+              long: '--protocol PROTOCOL',
+              description: "Protocol of the NAT gateway rule. Defaults to ALL. If protocol is "\
+              "'ICMP' then target_port_range start and end cannot be set."
+
+      option :source_subnet,
+              long: '--source SOURCE_SUBNET',
+              description: 'Source subnet of the NAT gateway rule. For SNAT rules it specifies '\
+              'which packets this translation rule applies to based on the packets source IP address.'
+
+      option :public_ip,
+              short: '-i PUBLIC_IP',
+              long: '--ip PUBLIC_IP',
+              description: 'Public IP address of the NAT gateway rule. Specifies the address used for masking outgoing '\
+              'packets source address field. Should be one of the customer reserved IP address already configured on the NAT gateway resource'
+
+      option :target_subnet,
+              long: '--target TARGET_SUBNET',
+              description: 'Target or destination subnet of the NAT gateway rule. For SNAT rules it specifies which packets '\
+              'this translation rule applies to based on the packets destination IP address. If none is provided, rule will match any address'
+
+      option :target_port_range_start,
+              long: '--port-start PORT_RANGE_START',
+              description: 'Target port range start associated with the NAT gateway rule'
+
+      option :target_port_range_end,
+              long: '--port-end PORT_RANGE_START',
+              description: 'Target port range end associated with the NAT gateway rule'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Updates information about a Ionoscloud NAT Gateway.'
+        @required_options = [:datacenter_id, :natgateway_id, :ionoscloud_username, :ionoscloud_password]
+        @updatable_fields = [
+          :name, :type, :protocol, :source_subnet, :public_ip, :target_subnet,
+          :target_port_range_start, :target_port_range_end,
+        ]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        natgateways_api = Ionoscloud::NATGatewaysApi.new(api_client)
+
+        if @updatable_fields.map { |el| config[el] }.any?
+          print "#{ui.color('Updating NAT Gateway Rule...', :magenta)}"
+
+          _, _, headers  = natgateways_api.datacenters_natgateways_rules_patch_with_http_info(
+            config[:datacenter_id],
+            config[:natgateway_id],
+            config[:natgateway_rule_id],
+            Ionoscloud::NatGatewayRuleProperties.new(
+              name: config[:name],
+              type: config[:type],
+              protocol: config[:protocol],
+              public_ip: config[:public_ip],
+              source_subnet: config[:source_subnet],
+              target_subnet: config[:target_subnet],
+              target_port_range: Ionoscloud::TargetPortRange.new(
+                start: config[:target_port_range_start],
+                _end: config[:target_port_range_end],
+              ),
+            ),
+          )
+
+          dot = ui.color('.', :magenta)
+          api_client.wait_for { print dot; is_done? get_request_id headers }
+        else
+          ui.warn("Nothing to update, please set one of the attributes #{@updatable_fields}.")
+        end
+
+        print_natgateway(natgateways_api.datacenters_natgateways_find_by_nat_gateway_id(config[:datacenter_id], config[:natgateway_id], depth: 2))
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_natgateway_update.rb

@@ -0,0 +1,84 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudNatgatewayUpdate < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud natgateway update (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'ID of the data center'
+
+      option :natgateway_id,
+              short: '-G NATGATEWAY_ID',
+              long: '--natgateway-id NATGATEWAY_ID',
+              description: 'ID of the NAT Gateway'
+
+      option :name,
+              short: '-n NAME',
+              long: '--name NAME',
+              description: 'Name of the NAT gateway'
+
+      option :ips,
+              short: '-i IP[,IP,...]',
+              long: '--ips IP[,IP,...]',
+              description: 'Collection of public IP addresses of the NAT gateway. Should be customer reserved IP addresses in that location'
+
+      option :lans,
+              long: '--lans LAN[,LAN,...]',
+              description: 'Collection of LANs connected to the NAT gateway. IPs must contain valid subnet mask. If user will not provide any IP then system will generate an IP with /24 subnet.'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Updates information about a Ionoscloud NAT Gateway.'
+        @required_options = [:datacenter_id, :natgateway_id, :ionoscloud_username, :ionoscloud_password]
+        @updatable_fields = [:name, :ips, :lans]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        natgateways_api = Ionoscloud::NATGatewaysApi.new(api_client)
+
+        config[:ips] = config[:ips].split(',') if config[:ips] && config[:ips].instance_of?(String)
+        config[:lans] = JSON[config[:lans]] if config[:lans] && config[:lans].instance_of?(String)
+        config[:lans] = config[:lans].map do
+          |lan|
+          Ionoscloud::NatGatewayLanProperties.new(
+            id: lan['id'],
+            gateway_ips: lan['gateway_ips'],
+          )
+        end if config[:lans]
+
+        if @updatable_fields.map { |el| config[el] }.any?
+          print "#{ui.color('Updating NAT Gateway...', :magenta)}"
+
+          _, _, headers  = natgateways_api.datacenters_natgateways_patch_with_http_info(
+            config[:datacenter_id],
+            config[:natgateway_id],
+            Ionoscloud::NatGatewayProperties.new(
+              name: config[:name],
+              public_ips: config[:ips],
+              lans: config[:lans],
+            ),
+          )
+
+          dot = ui.color('.', :magenta)
+          api_client.wait_for { print dot; is_done? get_request_id headers }
+        else
+          ui.warn("Nothing to update, please set one of the attributes #{@updatable_fields}.")
+        end
+
+        print_natgateway(natgateways_api.datacenters_natgateways_find_by_nat_gateway_id(config[:datacenter_id], config[:natgateway_id], depth: 2))
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_networkloadbalancer_create.rb

@@ -78,18 +78,11 @@ class Chef
         dot = ui.color('.', :magenta)
         api_client.wait_for { print dot; is_done? get_request_id headers }
 
-        network_load_balancer = network_load_balancers_api.datacenters_networkloadbalancers_find_by_network_load_balancer_id(
-          config[:datacenter_id], network_load_balancer.id,
+        print_network_load_balancer(
+          network_load_balancers_api.datacenters_networkloadbalancers_find_by_network_load_balancer_id(
+            config[:datacenter_id], network_load_balancer.id, depth: 2,
+          ),
         )
-
-        puts "\n"
-        puts "#{ui.color('ID', :cyan)}: #{network_load_balancer.id}"
-        puts "#{ui.color('Name', :cyan)}: #{network_load_balancer.properties.name}"
-        puts "#{ui.color('Listener LAN', :cyan)}: #{network_load_balancer.properties.listener_lan}"
-        puts "#{ui.color('IPS', :cyan)}: #{network_load_balancer.properties.ips}"
-        puts "#{ui.color('Target LAN', :cyan)}: #{network_load_balancer.properties.target_lan}"
-        puts "#{ui.color('Private IPS', :cyan)}: #{network_load_balancer.properties.lb_private_ips}"
-        puts 'done'
       end
     end
   end

data/lib/chef/knife/ionoscloud_networkloadbalancer_delete.rb

@@ -33,7 +33,7 @@ class Chef
             network_load_balancer = network_load_balancers_api.datacenters_networkloadbalancers_find_by_network_load_balancer_id(
               config[:datacenter_id],
               network_load_balancer_id,
-              { depth: 1 },
+              depth: 2,
             )
           rescue Ionoscloud::ApiError => err
             raise err unless err.code == 404
@@ -41,27 +41,7 @@ class Chef
             next
           end
 
-          msg_pair('ID', network_load_balancer.id)
-          msg_pair('Name', network_load_balancer.properties.name)
-          msg_pair('Listener LAN', network_load_balancer.properties.listener_lan)
-          msg_pair('IPS', network_load_balancer.properties.ips)
-          msg_pair('Target LAN', network_load_balancer.properties.target_lan)
-          msg_pair('Private IPS', network_load_balancer.properties.lb_private_ips)
-          msg_pair('Forwarding Rules', network_load_balancer.entities.forwardingrules.items.map do |rule|
-              {
-                id: rule.id,
-                name: rule.properties.name,
-                algorithm: rule.properties.algorithm,
-                protocol: rule.properties.protocol,
-                listener_ip: rule.properties.listener_ip,
-                listener_port: rule.properties.listener_port,
-                health_check: rule.properties.health_check,
-                targets: rule.properties.targets,
-              }
-            end
-          )
-          # msg_pair('Flowlogs', network_load_balancer.entities.flowlogs.items.map { |flowlog| flowlog.id })
-
+          print_network_load_balancer(network_load_balancer)
           puts "\n"
 
           begin

data/lib/chef/knife/ionoscloud_networkloadbalancer_get.rb

@@ -0,0 +1,42 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudNetworkloadbalancerGet < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud networkloadbalancer get (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'ID of the data center'
+
+      option :network_loadbalancer_id,
+              short: '-L NETWORK_LOADBALANCER_ID',
+              long: '--network-loadbalancer NETWORK_LOADBALANCER_ID',
+              description: 'ID of the Network Loadbalancer'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Retrieves the attributes of a given Network Load Balancer.'
+        @required_options = [:datacenter_id, :network_loadbalancer_id, :ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        print_network_load_balancer(
+          Ionoscloud::NetworkLoadBalancersApi.new(api_client).datacenters_networkloadbalancers_find_by_network_load_balancer_id(
+            config[:datacenter_id], config[:network_loadbalancer_id], depth: 2,
+          ),
+        )
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_networkloadbalancer_rule_add.rb

@@ -49,13 +49,6 @@ class Chef
               'the client is expected to acknowledge or send data. If unset the default of 50 seconds will be used.',
               default: 50
 
-      option :check_timeout,
-              long: '--check-timeout CLIENT_TIMEOUT',
-              description: 'It specifies the time (in milliseconds) for a target VM in this pool to answer the check. '\
-              'If a target VM has CheckInterval set and CheckTimeout is set too, then the smaller value of the two is '\
-              'used after the TCP connection is established.',
-              default: 2000
-
       option :connect_timeout,
               long: '--connect-timeout CONNECT_TIMEOUT',
               description: 'It specifies the maximum time (in milliseconds) to wait for a connection attempt to a '\
@@ -75,6 +68,10 @@ class Chef
               'If unset, the default value of 3 will be used. (valid range: [0, 65535])',
               default: 3
 
+      option :targets,
+              long: '--targets TARGETS',
+              description: 'Array of targets'
+
       attr_reader :description, :required_options
 
       def initialize(args = [])
@@ -91,9 +88,22 @@ class Chef
 
         network_loadbalancers_api = Ionoscloud::NetworkLoadBalancersApi.new(api_client)
 
-        if config[:gateway_ips]
-          config[:gateway_ips] = config[:gateway_ips].split(',')
-        end
+        config[:gateway_ips] = config[:gateway_ips].split(',') if config[:gateway_ips] && config[:gateway_ips].instance_of?(String)
+        config[:targets] = JSON[config[:targets]] if config[:targets] && config[:targets].instance_of?(String)
+
+        config[:targets] = config[:targets].map do
+          |condition|
+          Ionoscloud::NetworkLoadBalancerForwardingRuleTarget.new(
+            ip: condition['ip'],
+            port: condition['port'],
+            weight: condition['weight'],
+            health_check: Ionoscloud::NetworkLoadBalancerForwardingRuleTargetHealthCheck.new(
+              check: condition['check'],
+              check_interval: condition['check_interval'],
+              maintenance: condition['maintenance'],
+            ),
+          )
+        end if config[:targets]
 
         network_loadbalancer_forwarding_rule = Ionoscloud::NetworkLoadBalancerForwardingRule.new(
           properties: Ionoscloud::NetworkLoadBalancerForwardingRuleProperties.new(
@@ -102,9 +112,9 @@ class Chef
             protocol: config[:protocol],
             listener_ip: config[:listener_ip],
             listener_port: config[:listener_port],
+            targets: config[:targets],
             health_check: Ionoscloud::NetworkLoadBalancerForwardingRuleHealthCheck.new(
               client_timeout: config[:client_timeout],
-              check_timeout: config[:check_timeout],
               connect_timeout: config[:connect_timeout],
               target_timeout: config[:target_timeout],
               retries: config[:retries],
@@ -120,31 +130,11 @@ class Chef
         dot = ui.color('.', :magenta)
         api_client.wait_for { print dot; is_done? get_request_id headers }
 
-        network_load_balancer = network_loadbalancers_api.datacenters_networkloadbalancers_find_by_network_load_balancer_id(
-          config[:datacenter_id], config[:network_loadbalancer_id], depth: 2,
+        print_network_load_balancer(
+          network_loadbalancers_api.datacenters_networkloadbalancers_find_by_network_load_balancer_id(
+            config[:datacenter_id], config[:network_loadbalancer_id], depth: 2,
+          ),
         )
-
-        puts "\n"
-        puts "#{ui.color('ID', :cyan)}: #{network_load_balancer.id}"
-        puts "#{ui.color('Name', :cyan)}: #{network_load_balancer.properties.name}"
-        puts "#{ui.color('Listener LAN', :cyan)}: #{network_load_balancer.properties.listener_lan}"
-        puts "#{ui.color('IPS', :cyan)}: #{network_load_balancer.properties.ips}"
-        puts "#{ui.color('Target LAN', :cyan)}: #{network_load_balancer.properties.target_lan}"
-        puts "#{ui.color('Private IPS', :cyan)}: #{network_load_balancer.properties.lb_private_ips}"
-        puts "#{ui.color('Forwarding Rules', :cyan)}: #{network_load_balancer.entities.forwardingrules.items.map do |rule|
-          {
-            id: rule.id,
-            name: rule.properties.name,
-            algorithm: rule.properties.algorithm,
-            protocol: rule.properties.protocol,
-            listener_ip: rule.properties.listener_ip,
-            listener_port: rule.properties.listener_port,
-            health_check: rule.properties.health_check,
-            targets: rule.properties.targets,
-          }
-        end}"
-        puts "#{ui.color('Flowlogs', :cyan)}: #{network_load_balancer.entities.flowlogs.items.map { |flowlog| flowlog.id }}"
-        puts 'done'
       end
     end
   end

data/lib/chef/knife/ionoscloud_networkloadbalancer_rule_list.rb

@@ -32,6 +32,7 @@ class Chef
         validate_required_params(@required_options, config)
 
         $stdout.sync = true
+        handle_extra_config
         network_loadbalancer_rule_list = [
           ui.color('ID', :bold),
           ui.color('Name', :bold),

data/lib/chef/knife/ionoscloud_networkloadbalancer_rule_remove.rb

@@ -37,42 +37,31 @@ class Chef
 
         headers_to_wait = []
         @name_args.each do |rule_id|
-          _, _, headers = network_loadbalancers_api.datacenters_networkloadbalancers_forwardingrules_delete_with_http_info(
-            config[:datacenter_id], config[:network_loadbalancer_id], rule_id,
-          )
-          headers_to_wait << headers
+          begin
+            _, _, headers = network_loadbalancers_api.datacenters_networkloadbalancers_forwardingrules_delete_with_http_info(
+              config[:datacenter_id], config[:network_loadbalancer_id], rule_id,
+            )
+            headers_to_wait << headers
+
+            ui.warn(
+              "Removed Forwarding Rule #{rule_id} from the Network Load balancer "\
+              "#{config[:network_loadbalancer_id]}. Request ID: #{get_request_id headers}.",
+            )
+          rescue Ionoscloud::ApiError => err
+            raise err unless err.code == 404
+            ui.error("Forwarding rule ID #{rule_id} not found. Skipping.")
+            next
+          end
         end
 
-        print "#{ui.color("Removing rules #{@name_args} from the NAT Gateway...", :magenta)}"
         dot = ui.color('.', :magenta)
-
         headers_to_wait.each { |headers| api_client.wait_for { print dot; is_done? get_request_id headers } }
 
-        network_load_balancer = network_loadbalancers_api.datacenters_networkloadbalancers_find_by_network_load_balancer_id(
-          config[:datacenter_id], config[:network_loadbalancer_id], depth: 2,
+        print_network_load_balancer(
+          network_loadbalancers_api.datacenters_networkloadbalancers_find_by_network_load_balancer_id(
+            config[:datacenter_id], config[:network_loadbalancer_id], depth: 2,
+          ),
         )
-
-        puts "\n"
-        puts "#{ui.color('ID', :cyan)}: #{network_load_balancer.id}"
-        puts "#{ui.color('Name', :cyan)}: #{network_load_balancer.properties.name}"
-        puts "#{ui.color('Listener LAN', :cyan)}: #{network_load_balancer.properties.listener_lan}"
-        puts "#{ui.color('IPS', :cyan)}: #{network_load_balancer.properties.ips}"
-        puts "#{ui.color('Target LAN', :cyan)}: #{network_load_balancer.properties.target_lan}"
-        puts "#{ui.color('Private IPS', :cyan)}: #{network_load_balancer.properties.lb_private_ips}"
-        puts "#{ui.color('Forwarding Rules', :cyan)}: #{network_load_balancer.entities.forwardingrules.items.map do |rule|
-          {
-            id: rule.id,
-            name: rule.properties.name,
-            algorithm: rule.properties.algorithm,
-            protocol: rule.properties.protocol,
-            listener_ip: rule.properties.listener_ip,
-            listener_port: rule.properties.listener_port,
-            health_check: rule.properties.health_check,
-            targets: rule.properties.targets,
-          }
-        end}"
-        puts "#{ui.color('Flowlogs', :cyan)}: #{network_load_balancer.entities.flowlogs.items.map { |flowlog| flowlog.id }}"
-        puts 'done'
       end
     end
   end

data/lib/chef/knife/ionoscloud_networkloadbalancer_rule_target_add.rb

@@ -113,29 +113,11 @@ class Chef
         dot = ui.color('.', :magenta)
         api_client.wait_for { print dot; is_done? get_request_id headers }
 
-        network_load_balancer_rule = network_loadbalancers_api.datacenters_networkloadbalancers_forwardingrules_find_by_forwarding_rule_id(
-          config[:datacenter_id], config[:network_loadbalancer_id], config[:forwarding_rule_id], depth: 2,
+        print_network_load_balancer(
+          network_loadbalancers_api.datacenters_networkloadbalancers_find_by_network_load_balancer_id(
+            config[:datacenter_id], config[:network_loadbalancer_id], depth: 2,
+          ),
         )
-
-        puts "\n"
-        puts "#{ui.color('ID', :cyan)}: #{network_load_balancer_rule.id}"
-        puts "#{ui.color('Name', :cyan)}: #{network_load_balancer_rule.properties.name}"
-        puts "#{ui.color('Algorithm', :cyan)}: #{network_load_balancer_rule.properties.algorithm}"
-        puts "#{ui.color('Protocol', :cyan)}: #{network_load_balancer_rule.properties.protocol}"
-        puts "#{ui.color('Listener IP', :cyan)}: #{network_load_balancer_rule.properties.listener_ip}"
-        puts "#{ui.color('Listener Port', :cyan)}: #{network_load_balancer_rule.properties.listener_port}"
-        puts "#{ui.color('Health Check', :cyan)}: #{network_load_balancer_rule.properties.health_check}"
-        puts "#{ui.color('Targets', :cyan)}: #{network_load_balancer_rule.properties.targets.map do |target|
-          {
-            ip: target.ip,
-            port: target.port,
-            weight: target.weight,
-            check: target.health_check.check,
-            check_interval: target.health_check.check_interval,
-            maintenance: target.health_check.maintenance,
-          }
-        end}"
-        puts 'done'
       end
     end
   end

data/lib/chef/knife/ionoscloud_networkloadbalancer_rule_target_list.rb

@@ -39,6 +39,7 @@ class Chef
         validate_required_params(@required_options, config)
 
         $stdout.sync = true
+        handle_extra_config
         target_list = [
           ui.color('IP', :bold),
           ui.color('Port', :bold),

data/lib/chef/knife/ionoscloud_networkloadbalancer_rule_target_remove.rb

@@ -77,29 +77,11 @@ class Chef
           api_client.wait_for { print dot; is_done? get_request_id headers }
         end
 
-        network_load_balancer_rule = network_loadbalancers_api.datacenters_networkloadbalancers_forwardingrules_find_by_forwarding_rule_id(
-          config[:datacenter_id], config[:network_loadbalancer_id], config[:forwarding_rule_id], depth: 2,
+        print_network_load_balancer(
+          network_loadbalancers_api.datacenters_networkloadbalancers_find_by_network_load_balancer_id(
+            config[:datacenter_id], config[:network_loadbalancer_id], depth: 2,
+          ),
         )
-
-        puts "\n"
-        puts "#{ui.color('ID', :cyan)}: #{network_load_balancer_rule.id}"
-        puts "#{ui.color('Name', :cyan)}: #{network_load_balancer_rule.properties.name}"
-        puts "#{ui.color('Algorithm', :cyan)}: #{network_load_balancer_rule.properties.algorithm}"
-        puts "#{ui.color('Protocol', :cyan)}: #{network_load_balancer_rule.properties.protocol}"
-        puts "#{ui.color('Listener IP', :cyan)}: #{network_load_balancer_rule.properties.listener_ip}"
-        puts "#{ui.color('Listener Port', :cyan)}: #{network_load_balancer_rule.properties.listener_port}"
-        puts "#{ui.color('Health Check', :cyan)}: #{network_load_balancer_rule.properties.health_check}"
-        puts "#{ui.color('Targets', :cyan)}: #{network_load_balancer_rule.properties.targets.map do |target|
-          {
-            ip: target.ip,
-            port: target.port,
-            weight: target.weight,
-            check: target.health_check.check,
-            check_interval: target.health_check.check_interval,
-            maintenance: target.health_check.maintenance,
-          }
-        end}"
-        puts 'done'
       end
     end
   end