knife-ionoscloud 6.1.2 → 6.2.0

data/lib/chef/knife/ionoscloud_applicationloadbalancer_list.rb

@@ -0,0 +1,56 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudApplicationloadbalancerList < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud applicationloadbalancer list (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'Name of the data center'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Retrieve a list of Application Load Balancers within the datacenter.'
+        @directory = 'application-loadbalancer'
+        @required_options = [:datacenter_id]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        application_load_balancers_list = [
+          ui.color('ID', :bold),
+          ui.color('Name', :bold),
+          ui.color('Listener LAN', :bold),
+          ui.color('Target LAN', :bold),
+          ui.color('Rules', :bold),
+          ui.color('IPS', :bold),
+          ui.color('Private IPS', :bold),
+        ]
+
+        application_load_balancers_api = Ionoscloud::ApplicationLoadBalancersApi.new(api_client)
+
+        application_load_balancers_api.datacenters_applicationloadbalancers_get(config[:datacenter_id], { depth: 2 }).items.each do |application_load_balancer|
+          application_load_balancers_list << application_load_balancer.id
+          application_load_balancers_list << application_load_balancer.properties.name
+          application_load_balancers_list << application_load_balancer.properties.listener_lan
+          application_load_balancers_list << application_load_balancer.properties.target_lan
+          application_load_balancers_list << application_load_balancer.entities.forwardingrules.items.length
+          application_load_balancers_list << application_load_balancer.properties.ips
+          application_load_balancers_list << application_load_balancer.properties.lb_private_ips
+        end
+
+        puts ui.list(application_load_balancers_list, :uneven_columns_across, 7)
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_applicationloadbalancer_rule_add.rb

@@ -0,0 +1,129 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudApplicationloadbalancerRuleAdd < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud applicationloadbalancer rule add (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'Name of the data center'
+
+      option :application_loadbalancer_id,
+              short: '-L APPLICATION_LOADBALANCER_ID',
+              long: '--application-loadbalancer APPLICATION_LOADBALANCER_ID',
+              description: 'ID of the Application Loadbalancer'
+
+      option :name,
+              short: '-n NAME',
+              long: '--name NAME',
+              description: 'A name of that Application Load Balancer forwarding rule'
+
+      option :protocol,
+              long: '--protocol PROTOCOL',
+              description: 'Protocol of the balancing',
+              default: 'HTTP'
+
+      option :listener_ip,
+              short: '-i LISTENER_IP',
+              long: '--ip LISTENER_IP',
+              description: 'Listening IP. (inbound)'
+
+      option :listener_port,
+              short: '-p LISTENER_PORT',
+              long: '--port LISTENER_PORT',
+              description: 'Listening port number. (inbound) (range: 1 to 65535)'
+
+      option :client_timeout,
+              long: '--client-timeout CLIENT_TIMEOUT',
+              description: 'ClientTimeout is expressed in milliseconds. This inactivity timeout applies when '\
+              'the client is expected to acknowledge or send data. If unset the default of 50 seconds will be used.',
+              default: 50
+
+      option :server_certificates,
+              long: '--certificates SERVER_CERTIFICATES',
+              description: 'Array of server certificates'
+
+      option :http_rules,
+              long: '--http-rules HTTP_RULES',
+              description: 'Array of HTTP Rules'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Adds a Forwarding Rule to a Application Load Balancer under a data center.'
+        @directory = 'application-loadbalancer'
+        @required_options = [
+          :datacenter_id, :application_loadbalancer_id, :name, :listener_ip, :listener_port,
+        ]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        application_loadbalancers_api = Ionoscloud::ApplicationLoadBalancersApi.new(api_client)
+
+        config[:server_certificates] = config[:server_certificates].split(',') if config[:server_certificates] && config[:server_certificates].instance_of?(String)
+
+        unless config[:http_rules].nil?
+          config[:http_rules] = JSON[config[:http_rules]] if config[:http_rules].instance_of?(String)
+
+          config[:http_rules].map! do |target|
+            Ionoscloud::ApplicationLoadBalancerHttpRule.new(
+              name: target['name'],
+              type: target['type'],
+              target_group: target['target_group'],
+              drop_query: target['drop_query'],
+              location: target['location'],
+              status_code: target['status_code'],
+              response_message: target['response_message'],
+              content_type: target['content_type'],
+              conditions: target['conditions'].nil? ? nil : target['conditions'].map do |condition|
+                Ionoscloud::ApplicationLoadBalancerHttpRuleCondition.new(
+                  type: condition['type'],
+                  condition: condition['condition'],
+                  negate: condition['negate'],
+                  key: condition['key'],
+                  value: condition['value'],
+                )
+              end,
+            )
+          end
+        end
+
+        application_loadbalancer_forwarding_rule = Ionoscloud::ApplicationLoadBalancerForwardingRule.new(
+          properties: Ionoscloud::ApplicationLoadBalancerForwardingRuleProperties.new(
+            name: config[:name],
+            protocol: config[:protocol],
+            listener_ip: config[:listener_ip],
+            listener_port: config[:listener_port],
+            client_timeout: config[:client_timeout],
+            server_certificates: config[:server_certificates],
+            http_rules: config[:http_rules],
+          ),
+        )
+
+        _, _, headers = application_loadbalancers_api.datacenters_applicationloadbalancers_forwardingrules_post_with_http_info(
+          config[:datacenter_id], config[:application_loadbalancer_id], application_loadbalancer_forwarding_rule,
+        )
+
+        print "#{ui.color('Adding the rule to the Application Loadbalancer...', :magenta)}"
+        dot = ui.color('.', :magenta)
+        api_client.wait_for { print dot; is_done? get_request_id headers }
+
+        print_application_loadbalancer(
+          application_loadbalancers_api.datacenters_applicationloadbalancers_find_by_application_load_balancer_id(
+            config[:datacenter_id], config[:application_loadbalancer_id], depth: 2,
+          ),
+        )
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_applicationloadbalancer_rule_httprule_add.rb

@@ -0,0 +1,159 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudApplicationloadbalancerRuleHttpruleAdd < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud applicationloadbalancer rule httprule add (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'Name of the data center'
+
+      option :application_loadbalancer_id,
+              short: '-L APPLICATION_LOADBALANCER_ID',
+              long: '--application-loadbalancer APPLICATION_LOADBALANCER_ID',
+              description: 'ID of the Application Loadbalancer'
+
+      option :forwarding_rule_id,
+              short: '-R FORWARDING_RULE_ID',
+              long: '--forwarding-rule FORWARDING_RULE_ID',
+              description: 'ID of the Application Loadbalancer Forwarding Rule'
+
+      option :name,
+              short: '-n NAME',
+              long: '--name NAME',
+              description: 'The name of a Application Load Balancer http rule; unique per forwarding rule'
+
+      option :type,
+              short: '-t TYPE',
+              long: '--type TYPE',
+              description: 'Type of the Http Rule.'
+
+      option :target_group,
+              long: '--target-group TARGET_GROUP_ID',
+              description: 'The UUID of the target group; mandatory and only valid for FORWARD action.'
+
+      option :drop_query,
+              short: '-q QUERY',
+              long: '--query QUERY',
+              description: 'Default is false; valid only for REDIRECT action.'
+
+      option :location,
+              short: '-l LOCATION',
+              long: '--location LOCATION',
+              description: 'The location for redirecting; mandatory and valid only for REDIRECT action.'
+
+      option :status_code,
+              long: '--code STATUS_CODE',
+              description: 'Valid only for action REDIRECT and STATIC; on REDIRECT action default is 301 '\
+              'and it can take the values 301, 302, 303, 307, 308; on STATIC action default is 503 and it can take a value between 200 and 599'
+
+      option :response_message,
+              short: '-m MESSAGE',
+              long: '--message MESSAGE',
+              description: 'The response message of the request; mandatory for STATIC action'
+
+      option :content_type,
+              long: '--content-type CONTENT_TYPE',
+              description: 'Valid only for action STATIC'
+
+      option :conditions,
+              long: '--conditions CONDITIONS',
+              description: 'Array of conditions for the HTTP Rule'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Adds a Http Rule to a Application Load Balancer Forwarding Rule under a data center or updates it if one already exists.'
+        @directory = 'application-loadbalancer'
+        @required_options = [
+          :datacenter_id, :application_loadbalancer_id, :forwarding_rule_id, :name, :type,
+        ]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        application_loadbalancers_api = Ionoscloud::ApplicationLoadBalancersApi.new(api_client)
+
+        application_load_balancer_rule = application_loadbalancers_api.datacenters_applicationloadbalancers_forwardingrules_find_by_forwarding_rule_id(
+          config[:datacenter_id], config[:application_loadbalancer_id], config[:forwarding_rule_id],
+        )
+
+        existing_http_rule = application_load_balancer_rule.properties.http_rules.nil? ? nil : application_load_balancer_rule.properties.http_rules.find do
+          |rule|
+          rule.name == config[:name]
+        end
+
+        unless config[:conditions].nil?
+          config[:conditions] = JSON[config[:conditions]] if config[:conditions].instance_of?(String)
+
+          config[:conditions].map! do |condition|
+            Ionoscloud::ApplicationLoadBalancerHttpRuleCondition.new(
+              type: condition['type'],
+              condition: condition['condition'],
+              negate: condition['negate'],
+              key: condition['key'],
+              value: condition['value'],
+            )
+          end
+        end
+
+        if existing_http_rule
+          existing_http_rule.type = config[:type] || existing_http_rule.type
+          existing_http_rule.target_group = config[:target_group] || existing_http_rule.target_group
+          existing_http_rule.drop_query = config[:drop_query] || existing_http_rule.drop_query
+          existing_http_rule.location = config[:location] || existing_http_rule.location
+          existing_http_rule.status_code = config[:status_code] || existing_http_rule.status_code
+          existing_http_rule.response_message = config[:response_message] || existing_http_rule.response_message
+          existing_http_rule.content_type = config[:content_type] || existing_http_rule.content_type
+          existing_http_rule.conditions = config[:conditions] || existing_http_rule.conditions
+        else
+          application_loadbalancer_forwarding_rule_httprule = Ionoscloud::ApplicationLoadBalancerHttpRule.new(
+            name: config[:name],
+            type: config[:type],
+            target_group: config[:target_group],
+            drop_query: config[:drop_query],
+            location: config[:location],
+            status_code: config[:status_code],
+            response_message: config[:response_message],
+            content_type: config[:content_type],
+            conditions: config[:conditions],
+          )
+
+          if application_load_balancer_rule.properties.http_rules.nil?
+            application_load_balancer_rule.properties.http_rules = [application_loadbalancer_forwarding_rule_httprule]
+          else
+            application_load_balancer_rule.properties.http_rules << application_loadbalancer_forwarding_rule_httprule
+          end
+        end
+
+        _, _, headers  = application_loadbalancers_api.datacenters_applicationloadbalancers_forwardingrules_patch_with_http_info(
+          config[:datacenter_id],
+          config[:application_loadbalancer_id],
+          config[:forwarding_rule_id],
+          Ionoscloud::ApplicationLoadBalancerForwardingRuleProperties.new({
+            http_rules: application_load_balancer_rule.properties.http_rules,
+          }),
+        )
+
+        print "#{ui.color('Adding the Http Rule to the Application Loadbalancer Forwarding Rule...', :magenta)}"
+        dot = ui.color('.', :magenta)
+        api_client.wait_for { print dot; is_done? get_request_id headers }
+
+        print_application_loadbalancer(
+          application_loadbalancers_api.datacenters_applicationloadbalancers_find_by_application_load_balancer_id(
+            config[:datacenter_id], config[:application_loadbalancer_id], depth: 2,
+          ),
+        )
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_applicationloadbalancer_rule_httprule_remove.rb

@@ -0,0 +1,89 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudApplicationloadbalancerRuleHttpruleRemove < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud applicationloadbalancer rule httprule remove HTTP_RULE_NAME [HTTP_RULE_NAME] (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'Name of the data center'
+
+      option :application_loadbalancer_id,
+              short: '-L APPLICATION_LOADBALANCER_ID',
+              long: '--application-loadbalancer APPLICATION_LOADBALANCER_ID',
+              description: 'ID of the Application Loadbalancer'
+
+      option :forwarding_rule_id,
+              short: '-R FORWARDING_RULE_ID',
+              long: '--forwarding-rule FORWARDING_RULE_ID',
+              description: 'ID of the Application Loadbalancer Forwarding Rule'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Removes a Http Rule from a Application Load Balancer Forwarding Rule.'
+        @directory = 'application-loadbalancer'
+        @required_options = [
+          :datacenter_id, :application_loadbalancer_id, :forwarding_rule_id,
+        ]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        application_loadbalancers_api = Ionoscloud::ApplicationLoadBalancersApi.new(api_client)
+
+        application_load_balancer_rule = application_loadbalancers_api.datacenters_applicationloadbalancers_forwardingrules_find_by_forwarding_rule_id(
+          config[:datacenter_id], config[:application_loadbalancer_id], config[:forwarding_rule_id],
+        )
+
+        if application_load_balancer_rule.properties.http_rules.nil?
+          ui.warn("The Forwarding Rule #{config[:forwarding_rule_id]} has no Http Rules.")
+        else
+
+          existing_http_rules_names = application_load_balancer_rule.properties.http_rules.map { |rule| rule.name }
+
+          valid_names = @name_args.select do |http_rule_name|
+            existing_http_rules_names.include? http_rule_name
+          end
+
+          if valid_names.empty?
+            ui.warn('No name of an existing Http Rule was given.')
+          else
+            application_load_balancer_rule.properties.http_rules = application_load_balancer_rule.properties.http_rules.reject do
+              |rule|
+              valid_names.include? rule.name
+            end
+
+            _, _, headers  = application_loadbalancers_api.datacenters_applicationloadbalancers_forwardingrules_patch_with_http_info(
+              config[:datacenter_id],
+              config[:application_loadbalancer_id],
+              config[:forwarding_rule_id],
+              Ionoscloud::ApplicationLoadBalancerForwardingRuleProperties.new({
+                http_rules: application_load_balancer_rule.properties.http_rules,
+              }),
+            )
+
+            print "#{ui.color("Removing the Http Rules #{valid_names} from the Application Loadbalancer Forwarding Rule...", :magenta)}"
+            dot = ui.color('.', :magenta)
+            api_client.wait_for { print dot; is_done? get_request_id headers }
+          end
+        end
+
+        print_application_loadbalancer(
+          application_loadbalancers_api.datacenters_applicationloadbalancers_find_by_application_load_balancer_id(
+            config[:datacenter_id], config[:application_loadbalancer_id], depth: 2,
+          ),
+        )
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_applicationloadbalancer_rule_remove.rb

@@ -0,0 +1,70 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudApplicationloadbalancerRuleRemove < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud applicationloadbalancer rule remove RULE_ID [RULE_ID] (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'The ID of the data center'
+
+      option :application_loadbalancer_id,
+              short: '-L APPLICATION_LOADBALANCER_ID',
+              long: '--application-loadbalancer APPLICATION_LOADBALANCER_ID',
+              description: 'ID of the Application Loadbalancer'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Removes the specified rules from a Application Loadbalancer under a data center.'
+        @directory = 'application-loadbalancer'
+        @required_options = [:datacenter_id, :application_loadbalancer_id]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        return unless @name_args.length > 0
+
+        application_loadbalancers_api = Ionoscloud::ApplicationLoadBalancersApi.new(api_client)
+
+        headers_to_wait = []
+        removed_rules = []
+        @name_args.each do |rule_id|
+          begin
+            _, _, headers = application_loadbalancers_api.datacenters_applicationloadbalancers_forwardingrules_delete_with_http_info(
+              config[:datacenter_id], config[:application_loadbalancer_id], rule_id,
+            )
+            headers_to_wait << headers
+            removed_rules << rule_id
+          rescue
+            ui.warn("Error removing Forwarding Rule #{rule_id}. Skipping.")
+          end
+        end
+
+        if removed_rules.empty?
+          ui.warn('No valid rules to remove.')
+        else
+          print "#{ui.color("Removing rules #{removed_rules} from the Application Loadbalancer...", :magenta)}"
+          dot = ui.color('.', :magenta)
+
+          headers_to_wait.each { |headers| api_client.wait_for { print dot; is_done? get_request_id headers } }
+        end
+
+        print_application_loadbalancer(
+          application_loadbalancers_api.datacenters_applicationloadbalancers_find_by_application_load_balancer_id(
+            config[:datacenter_id], config[:application_loadbalancer_id], depth: 2,
+          ),
+        )
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_applicationloadbalancer_rule_update.rb

@@ -0,0 +1,137 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudApplicationloadbalancerRuleUpdate < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud applicationloadbalancer rule update (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'ID of the data center'
+
+      option :application_loadbalancer_id,
+              short: '-L APPLICATION_LOADBALANCER_ID',
+              long: '--application-loadbalancer APPLICATION_LOADBALANCER_ID',
+              description: 'ID of the Application Loadbalancer'
+
+      option :forwarding_rule_id,
+              short: '-R FORWARDING_RULE_ID',
+              long: '--forwarding-rule FORWARDING_RULE_ID',
+              description: 'ID of the Application Loadbalancer Forwarding Rule'
+
+      option :name,
+              short: '-n NAME',
+              long: '--name NAME',
+              description: 'A name of that Application Load Balancer forwarding rule'
+
+      option :protocol,
+              long: '--protocol PROTOCOL',
+              description: 'Protocol of the balancing',
+              default: 'HTTP'
+
+      option :listener_ip,
+              short: '-i LISTENER_IP',
+              long: '--ip LISTENER_IP',
+              description: 'Listening IP. (inbound)'
+
+      option :listener_port,
+              short: '-p LISTENER_PORT',
+              long: '--port LISTENER_PORT',
+              description: 'Listening port number. (inbound) (range: 1 to 65535)'
+
+      option :client_timeout,
+              long: '--client-timeout CLIENT_TIMEOUT',
+              description: 'ClientTimeout is expressed in milliseconds. This inactivity timeout applies when '\
+              'the client is expected to acknowledge or send data. If unset the default of 50 seconds will be used.',
+              default: 50
+
+      option :server_certificates,
+              long: '--certificates SERVER_CERTIFICATES',
+              description: 'Array of server certificates'
+
+      option :http_rules,
+              long: '--http-rules HTTP_RULES',
+              description: 'Array of HTTP Rules'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Updates information about a Ionoscloud Application LoadBalancer Forwarding Rule.'
+        @directory = 'application-loadbalancer'
+        @required_options = [:datacenter_id, :application_loadbalancer_id, :forwarding_rule_id]
+        @updatable_fields = [:name, :protocol, :listener_ip, :listener_port, :client_timeout, :server_certificates, :http_rules]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        application_load_balancers_api = Ionoscloud::ApplicationLoadBalancersApi.new(api_client)
+
+        if @updatable_fields.map { |el| config[el] }.any?
+          print "#{ui.color('Updating Application LoadBalancer Forwarding Rule...', :magenta)}"
+
+          config[:server_certificates] = config[:server_certificates].split(',') if config[:server_certificates] && config[:server_certificates].instance_of?(String)
+
+          unless config[:http_rules].nil?
+            config[:http_rules] = JSON[config[:http_rules]] if config[:http_rules].instance_of?(String)
+
+            config[:http_rules].map! do |target|
+              Ionoscloud::ApplicationLoadBalancerHttpRule.new(
+                name: target['name'],
+                type: target['type'],
+                target_group: target['target_group'],
+                drop_query: target['drop_query'],
+                location: target['location'],
+                status_code: target['status_code'],
+                response_message: target['response_message'],
+                content_type: target['content_type'],
+                conditions: target['conditions'].nil? ? nil : target['conditions'].map do |condition|
+                  Ionoscloud::ApplicationLoadBalancerHttpRuleCondition.new(
+                    type: condition['type'],
+                    condition: condition['condition'],
+                    negate: condition['negate'],
+                    key: condition['key'],
+                    value: condition['value'],
+                  )
+                end,
+              )
+            end
+          end
+
+          _, _, headers  = application_load_balancers_api.datacenters_applicationloadbalancers_forwardingrules_patch_with_http_info(
+            config[:datacenter_id],
+            config[:application_loadbalancer_id],
+            config[:forwarding_rule_id],
+            Ionoscloud::ApplicationLoadBalancerForwardingRuleProperties.new(
+              name: config[:name],
+              protocol: config[:protocol],
+              listener_ip: config[:listener_ip],
+              listener_port: config[:listener_port],
+              client_timeout: config[:client_timeout],
+              server_certificates: config[:server_certificates],
+              http_rules: config[:http_rules],
+            ),
+          )
+
+          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_application_loadbalancer(
+          application_load_balancers_api.datacenters_applicationloadbalancers_find_by_application_load_balancer_id(
+            config[:datacenter_id], config[:application_loadbalancer_id], depth: 2,
+          ),
+        )
+      end
+    end
+  end
+end