knife-ionoscloud 5.1.1 → 6.0.0.beta.2

data/lib/chef/knife/ionoscloud_firewall_update.rb

@@ -0,0 +1,133 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudFirewallUpdate < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud firewall update (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'The ID of the data center'
+
+      option :server_id,
+              short: '-S SERVER_ID',
+              long: '--server-id SERVER_ID',
+              description: 'The ID of the server'
+
+      option :nic_id,
+              short: '-N NIC_ID',
+              long: '--nic-id NIC_ID',
+              description: 'ID of the NIC'
+
+      option :firewall_id,
+              short: '-F FIREWALL_ID',
+              long: '--firewall-id FIREWALL_ID',
+              description: 'ID of the Firewall Rule'
+
+      option :name,
+              short: '-n NAME',
+              long: '--name NAME',
+              description: 'Name of the Firewall Rule'
+
+      option :protocol,
+              short: '-P PROTOCOL',
+              long: '--protocol PROTOCOL',
+              default: 'TCP',
+              description: 'The protocol of the firewall rule (TCP, UDP, ICMP, ANY)'
+
+      option :source_mac,
+              short: '-m MAC',
+              long: '--source-mac MAC',
+              description: 'Only traffic originating from the respective MAC address is allowed'
+
+      option :source_ip,
+              short: '-I IP',
+              long: '--source-ip IP',
+              description: 'Only traffic originating from the respective IPv4' \
+                          ' address is allowed; null allows all source IPs'
+
+      option :target_ip,
+              long: '--target-ip IP',
+              description: 'In case the target NIC has multiple IP addresses,' \
+                          ' only traffic directed to the respective IP' \
+                          ' address of the NIC is allowed; null value allows' \
+                          ' all target IPs'
+
+      option :port_range_start,
+              short: '-p PORT',
+              long: '--port-range-start PORT',
+              description: 'Defines the start range of the allowed port(s)'
+
+      option :port_range_end,
+              short: '-t PORT',
+              long: '--port-range-end PORT',
+              description: 'Defines the end range of the allowed port(s)'
+
+      option :icmp_type,
+              long: '--icmp-type INT',
+              description: 'Defines the allowed type (from 0 to 254) if the' \
+                          ' protocol ICMP is chosen; null allows all types'
+
+      option :icmp_code,
+              long: '--icmp-code INT',
+              description: 'Defines the allowed code (from 0 to 254) if the' \
+                          ' protocol ICMP is chosen; null allows all codes'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Updates information about a Ionoscloud Firewall Rule.'
+        @required_options = [:datacenter_id, :ionoscloud_username, :ionoscloud_password]
+        @updatable_fields = [
+          :name, :protocol, :source_mac, :source_ip, :target_ip,
+          :port_range_start, :port_range_end, :icmp_type, :icmp_code,
+        ]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        firewall_rules_api = Ionoscloud::FirewallRulesApi.new(api_client)
+
+        if @updatable_fields.map { |el| config[el] }.any?
+          print "#{ui.color('Updating Firewall Rule...', :magenta)}"
+
+          params = {
+            name: config[:name],
+            protocol: config[:protocol],
+            source_mac: config[:source_mac],
+            source_ip: config[:source_ip],
+            target_ip: config[:target_ip],
+            port_range_start: config[:port_range_start],
+            port_range_end: config[:port_range_end],
+            icmp_type: config[:icmp_type],
+            icmp_code: config[:icmp_code],
+          }
+
+          _, _, headers  = firewall_rules_api.datacenters_servers_nics_firewallrules_patch_with_http_info(
+            config[:datacenter_id], config[:server_id], config[:nic_id], config[:firewall_id],
+            Ionoscloud::FirewallruleProperties.new(params.compact),
+          )
+
+          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_firewall_rule(
+          firewall_rules_api.datacenters_servers_nics_firewallrules_find_by_id(
+            config[:datacenter_id], config[:server_id], config[:nic_id], config[:firewall_id],
+          ),
+        )
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_flowlog_create.rb

@@ -0,0 +1,116 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudFlowlogCreate < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud flowlog create (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'ID of the data center'
+
+      option :type,
+              short: '-t FLOWLOG_TYPE',
+              long: '--type FLOWLOG_TYPE',
+              description: 'The object to which the flow log will be attached'
+
+      option :server_id,
+              short: '-S SERVER_ID',
+              long: '--server-id SERVER_ID',
+              description: 'ID of the server'
+
+      option :nic_id,
+              short: '-N NIC_ID',
+              long: '--nic-id NIC_ID',
+              description: 'ID of the NIC'
+
+      option :natgateway_id,
+              short: '-G NAT_GATEWAY_ID',
+              long: '--natgateway NAT_GATEWAY_ID',
+              description: 'ID of the NAT Gateway'
+
+      option :network_loadbalancer_id,
+              short: '-L NETWORK_LOADBALANCER',
+              long: '--network-loadbalancer NETWORK_LOADBALANCER',
+              description: 'ID of the Network Load Balancer'
+
+      option :name,
+              short: '-n NAME',
+              long: '--name NAME',
+              description: 'Name of the Flow Log'
+
+      option :action,
+              short: '-a ACTION',
+              long: '--action ACTION',
+              default: 'ALL',
+              description: 'Specifies the traffic action pattern. Must be one of ["ALL", "ACCEPTED", "REJECTED"].'
+
+      option :direction,
+              long: '--direction DIRECTION',
+              default: 'BIDIRECTIONAL',
+              description: 'Specifies the traffic direction pattern. Must be one of ["INGRESS", "EGRESS", "BIDIRECTIONAL"].'
+
+      option :bucket,
+              short: '-b BUCKET',
+              long: '--bucket BUCKET',
+              description: 'S3 bucket name of an existing IONOS Cloud S3 bucket. Ex. bucketName/key'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'This will add a Flow Log to the network interface, NAT Gateway or Network Load Balancer.'
+        @required_options = [:datacenter_id, :type, :ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        print "#{ui.color('Creating Flow Log...', :magenta)}"
+
+        case config[:type]
+        when 'nic'
+          validate_required_params([:server_id, :nic_id], config)
+          flowlogs_api = Ionoscloud::FlowLogsApi.new(api_client)
+          method = flowlogs_api.method(:datacenters_servers_nics_flowlogs_post_with_http_info)
+          args = [config[:datacenter_id], config[:server_id], config[:nic_id]]
+        when 'natgateway'
+          validate_required_params([:natgateway_id], config)
+          flowlogs_api = Ionoscloud::NATGatewaysApi.new(api_client)
+          method = flowlogs_api.method(:datacenters_natgateways_flowlogs_post_with_http_info)
+          args = [config[:datacenter_id], config[:natgateway_id]]
+        when 'networkloadbalancer'
+          validate_required_params([:network_loadbalancer_id], config)
+          flowlogs_api = Ionoscloud::NetworkLoadBalancersApi.new(api_client)
+          method = flowlogs_api.method(:datacenters_networkloadbalancers_flowlogs_post_with_http_info)
+          args = [config[:datacenter_id], config[:network_loadbalancer_id]]
+        else
+          ui.error "Flow Log cannot belong to #{config[:type]}. Value must be one of ['nic', 'natgateway', 'networkloadbalancer']"
+          exit(1)
+        end
+
+        flowlog = Ionoscloud::FlowLog.new(
+          properties: Ionoscloud::FlowLogProperties.new({
+            name: config[:name],
+            action: config[:action],
+            direction: config[:direction],
+            bucket: config[:bucket],
+          }.compact),
+        )
+
+        flowlog, _, headers = method.call(*args, flowlog)
+
+        dot = ui.color('.', :magenta)
+        api_client.wait_for { print dot; is_done? get_request_id headers }
+
+        print_flowlog(flowlog)
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_flowlog_delete.rb

@@ -0,0 +1,103 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudFlowlogDelete < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud flowlog delete FLOWLOG_ID [FLOWLOG_ID] (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'The ID of the data center'
+
+      option :type,
+              short: '-t FLOWLOG_TYPE',
+              long: '--type FLOWLOG_TYPE',
+              description: 'The object to which the Flow Log will be attached'
+
+      option :server_id,
+              short: '-S SERVER_ID',
+              long: '--server-id SERVER_ID',
+              description: 'The ID of the server'
+
+      option :nic_id,
+              short: '-N NIC_ID',
+              long: '--nic-id NIC_ID',
+              description: 'ID of the NIC'
+
+      option :natgateway_id,
+              short: '-G NAT_GATEWAY_ID',
+              long: '--nat-gateway NAT_GATEWAY_ID',
+              description: 'ID of the NAT Gateway'
+
+      option :network_loadbalancer_id,
+              short: '-L NETWORK_LOADBALANCER',
+              long: '--network-loadbalancer NETWORK_LOADBALANCER',
+              description: 'ID of the Network Load Balancer'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Removes the specified Flow Logs.'
+        @required_options = [:datacenter_id, :type, :ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        flowlogs_api = Ionoscloud::FlowLogsApi.new(api_client)
+
+        case config[:type]
+        when 'nic'
+          validate_required_params([:server_id, :nic_id], config)
+          flowlogs_api = Ionoscloud::FlowLogsApi.new(api_client)
+          delete_method = flowlogs_api.method(:datacenters_servers_nics_flowlogs_delete_with_http_info)
+          get_method = flowlogs_api.method(:datacenters_servers_nics_flowlogs_find_by_id)
+          args = [config[:datacenter_id], config[:server_id], config[:nic_id]]
+        when 'natgateway'
+          validate_required_params([:natgateway_id], config)
+          flowlogs_api = Ionoscloud::NATGatewaysApi.new(api_client)
+          delete_method = flowlogs_api.method(:datacenters_natgateways_flowlogs_delete_with_http_info)
+          get_method = flowlogs_api.method(:datacenters_natgateways_flowlogs_find_by_flow_log_id)
+          args = [config[:datacenter_id], config[:natgateway_id]]
+        when 'networkloadbalancer'
+          validate_required_params([:network_loadbalancer_id], config)
+          flowlogs_api = Ionoscloud::NetworkLoadBalancersApi.new(api_client)
+          delete_method = flowlogs_api.method(:datacenters_networkloadbalancers_flowlogs_delete_with_http_info)
+          get_method = flowlogs_api.method(:datacenters_networkloadbalancers_flowlogs_find_by_flow_log_id)
+          args = [config[:datacenter_id], config[:network_loadbalancer_id]]
+        else
+          ui.error "Flow Log cannot belong to #{config[:type]}. Value must be one of ['nic', 'natgateway', 'networkloadbalancer']"
+          exit(1)
+        end
+
+        @name_args.each do |flowlog_id|
+          begin
+            flowlog = get_method.call(*args, flowlog_id)
+          rescue Ionoscloud::ApiError => err
+            raise err unless err.code == 404
+            ui.error("Flow Log ID #{flowlog_id} not found. Skipping.")
+            next
+          end
+
+          print_flowlog(flowlog)
+
+          begin
+            confirm('Do you really want to delete this Flow Log')
+          rescue SystemExit => exc
+            next
+          end
+
+          _, _, headers = delete_method.call(*args, flowlog_id)
+          ui.warn("Deleted Flow Log #{flowlog.id}. Request ID: #{get_request_id headers}")
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_flowlog_get.rb

@@ -0,0 +1,84 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudFlowlogGet < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud flowlog get (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'The ID of the data center'
+
+      option :type,
+              short: '-t FLOWLOG_TYPE',
+              long: '--type FLOWLOG_TYPE',
+              description: 'The object to which the Flow Log will be attached'
+
+      option :server_id,
+              short: '-S SERVER_ID',
+              long: '--server-id SERVER_ID',
+              description: 'The ID of the server'
+
+      option :nic_id,
+              short: '-N NIC_ID',
+              long: '--nic-id NIC_ID',
+              description: 'ID of the NIC'
+
+      option :natgateway_id,
+              short: '-G NAT_GATEWAY_ID',
+              long: '--nat-gateway NAT_GATEWAY_ID',
+              description: 'ID of the NAT Gateway'
+
+      option :network_loadbalancer_id,
+              short: '-L NETWORK_LOADBALANCER',
+              long: '--network-loadbalancer NETWORK_LOADBALANCER',
+              description: 'ID of the Network Load Balancer'
+
+      option :flowlog_id,
+              short: '-F FLOWLOG_ID',
+              long: '--flowlog-id FLOWLOG_ID',
+              description: 'The ID of the Flow Log'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Retrieves information about a Ionoscloud Flow Log.'
+        @required_options = [:flowlog_id, :datacenter_id, :type, :ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        case config[:type]
+        when 'nic'
+          validate_required_params([:server_id, :nic_id], config)
+          flowlog = Ionoscloud::FlowLogsApi.new(api_client).datacenters_servers_nics_flowlogs_find_by_id(
+            config[:datacenter_id], config[:server_id], config[:nic_id], config[:flowlog_id],
+          )
+        when 'natgateway'
+          validate_required_params([:natgateway_id], config)
+          flowlog = Ionoscloud::NATGatewaysApi.new(api_client).datacenters_natgateways_flowlogs_find_by_flow_log_id(
+            config[:datacenter_id], config[:natgateway_id], config[:flowlog_id],
+          )
+        when 'networkloadbalancer'
+          validate_required_params([:network_loadbalancer_id], config)
+          flowlog = Ionoscloud::NetworkLoadBalancersApi.new(api_client).datacenters_networkloadbalancers_flowlogs_find_by_flow_log_id(
+            config[:datacenter_id], config[:network_loadbalancer_id], config[:flowlog_id],
+          )
+        else
+          ui.error "Flow Log cannot belong to #{config[:type]}. Value must be one of ['nic', 'natgateway', 'networkloadbalancer']"
+          exit(1)
+        end
+
+        print_flowlog(flowlog)
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_flowlog_list.rb

@@ -0,0 +1,101 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudFlowlogList < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud flowlog list (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'ID of the data center'
+
+      option :type,
+              short: '-t FLOWLOG_TYPE',
+              long: '--type FLOWLOG_TYPE',
+              description: 'The object to which the flow log will be attached'
+
+      option :server_id,
+              short: '-S SERVER_ID',
+              long: '--server-id SERVER_ID',
+              description: 'The ID of the server'
+
+      option :nic_id,
+              short: '-N NIC_ID',
+              long: '--nic-id NIC_ID',
+              description: 'ID of the NIC'
+
+      option :natgateway_id,
+              short: '-G NAT_GATEWAY_ID',
+              long: '--nat-gateway NAT_GATEWAY_ID',
+              description: 'ID of the NAT Gateway'
+
+      option :network_loadbalancer_id,
+              short: '-L NETWORK_LOADBALANCER',
+              long: '--network-loadbalancer NETWORK_LOADBALANCER',
+              description: 'ID of the Network Load Balancer'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Lists all available flow logs assigned to a NIC, NAT Gateway or Network Load Balancer.'
+        @required_options = [:datacenter_id, :type, :ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        flowlog_list = [
+          ui.color('ID', :bold),
+          ui.color('Name', :bold),
+          ui.color('Action', :bold),
+          ui.color('Direction', :bold),
+          ui.color('Bucket', :bold),
+        ]
+        flowlogs = []
+
+        case config[:type]
+        when 'nic'
+          validate_required_params([:server_id, :nic_id], config)
+          flowlogs_api = Ionoscloud::FlowLogsApi.new(api_client)
+          flowlogs = flowlogs_api.datacenters_servers_nics_flowlogs_get(
+            config[:datacenter_id], config[:server_id], config[:nic_id], { depth: 1 }
+          )
+        when 'natgateway'
+          validate_required_params([:natgateway_id], config)
+          flowlogs_api = Ionoscloud::NATGatewaysApi.new(api_client)
+          flowlogs = flowlogs_api.datacenters_natgateways_flowlogs_get(
+            config[:datacenter_id], config[:natgateway_id], { depth: 1 }
+          )
+        when 'networkloadbalancer'
+          validate_required_params([:network_loadbalancer_id], config)
+          flowlogs_api = Ionoscloud::NetworkLoadBalancersApi.new(api_client)
+          flowlogs = flowlogs_api.datacenters_networkloadbalancers_flowlogs_get(
+            config[:datacenter_id], config[:network_loadbalancer_id], { depth: 1 }
+          )
+        else
+          ui.error "Flow log cannot belong to #{config[:type]}. Value must be one of ['nic', 'natgateway', 'networkloadbalancer']"
+          exit(1)
+        end
+
+        flowlogs_api = Ionoscloud::FlowLogsApi.new(api_client)
+
+        flowlogs.items.each do |flowlog|
+          flowlog_list << flowlog.id
+          flowlog_list << flowlog.properties.name
+          flowlog_list << flowlog.properties.action.to_s
+          flowlog_list << flowlog.properties.direction.to_s
+          flowlog_list << flowlog.properties.bucket.to_s
+        end
+
+        puts ui.list(flowlog_list, :uneven_columns_across, 5)
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_flowlog_update.rb

@@ -0,0 +1,127 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudFlowlogUpdate < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud flowlog update (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'The ID of the data center'
+
+      option :type,
+              short: '-t FLOWLOG_TYPE',
+              long: '--type FLOWLOG_TYPE',
+              description: 'The object to which the Flow Log will be attached'
+
+      option :server_id,
+              short: '-S SERVER_ID',
+              long: '--server-id SERVER_ID',
+              description: 'The ID of the server'
+
+      option :nic_id,
+              short: '-N NIC_ID',
+              long: '--nic-id NIC_ID',
+              description: 'ID of the NIC'
+
+      option :natgateway_id,
+              short: '-G NAT_GATEWAY_ID',
+              long: '--nat-gateway NAT_GATEWAY_ID',
+              description: 'ID of the NAT Gateway'
+
+      option :network_loadbalancer_id,
+              short: '-L NETWORK_LOADBALANCER',
+              long: '--network-loadbalancer NETWORK_LOADBALANCER',
+              description: 'ID of the Network Load Balancer'
+
+      option :flowlog_id,
+              short: '-F FLOWLOG_ID',
+              long: '--flowlog-id FLOWLOG_ID',
+              description: 'The ID of the Flow Log'
+
+      option :name,
+              short: '-n NAME',
+              long: '--name NAME',
+              description: 'Name of the Flow Log'
+
+      option :action,
+              short: '-a ACTION',
+              long: '--action ACTION',
+              default: 'ALL',
+              description: 'Specifies the traffic action pattern. Must be one of ["ALL", "ACCEPTED", "REJECTED"].'
+
+      option :direction,
+              long: '--direction DIRECTION',
+              default: 'BIDIRECTIONAL',
+              description: 'Specifies the traffic direction pattern. Must be one of ["INGRESS", "EGRESS", "BIDIRECTIONAL"].'
+
+      option :bucket,
+              short: '-b BUCKET',
+              long: '--bucket BUCKET',
+              description: 'S3 bucket name of an existing IONOS Cloud S3 bucket. Ex. bucketName/key'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Updates information about a Ionoscloud Flow Log.'
+        @required_options = [:flowlog_id, :datacenter_id, :type, :ionoscloud_username, :ionoscloud_password]
+        @updatable_fields = [:name, :action, :direction, :bucket]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        case config[:type]
+        when 'nic'
+          validate_required_params([:server_id, :nic_id], config)
+          flowlogs_api = Ionoscloud::FlowLogsApi.new(api_client)
+          patch_method = flowlogs_api.method(:datacenters_servers_nics_flowlogs_patch_with_http_info)
+          get_method = flowlogs_api.method(:datacenters_servers_nics_flowlogs_find_by_id)
+          args = [config[:datacenter_id], config[:server_id], config[:nic_id], config[:flowlog_id]]
+        when 'natgateway'
+          validate_required_params([:natgateway_id], config)
+          flowlogs_api = Ionoscloud::NATGatewaysApi.new(api_client)
+          patch_method = flowlogs_api.method(:datacenters_natgateways_flowlogs_patch_with_http_info)
+          get_method = flowlogs_api.method(:datacenters_natgateways_flowlogs_find_by_flow_log_id)
+          args = [config[:datacenter_id], config[:natgateway_id], config[:flowlog_id]]
+        when 'networkloadbalancer'
+          validate_required_params([:network_loadbalancer_id], config)
+          flowlogs_api = Ionoscloud::NetworkLoadBalancersApi.new(api_client)
+          patch_method = flowlogs_api.method(:datacenters_networkloadbalancers_flowlogs_patch_with_http_info)
+          get_method = flowlogs_api.method(:datacenters_networkloadbalancers_flowlogs_find_by_flow_log_id)
+          args = [config[:datacenter_id], config[:network_loadbalancer_id], config[:flowlog_id]]
+        else
+          ui.error "Flow Log cannot belong to #{config[:type]}. Value must be one of ['nic', 'natgateway', 'networkloadbalancer']"
+          exit(1)
+        end
+
+        if @updatable_fields.map { |el| config[el] }.any?
+          print "#{ui.color('Updating Flow Log...', :magenta)}"
+
+          flowlog_properties = Ionoscloud::FlowLogProperties.new({
+            name: config[:name],
+            action: config[:action],
+            direction: config[:direction],
+            bucket: config[:bucket],
+          }.compact)
+
+          _, _, headers  = patch_method.call(*args, flowlog_properties)
+
+          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_flowlog(get_method.call(*args))
+      end
+    end
+  end
+end