knife-ionoscloud 6.0.0.alpha.1 → 6.1.0

data/lib/chef/knife/ionoscloud_networkloadbalancer_rule_update.rb

@@ -0,0 +1,147 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudNetworkloadbalancerRuleUpdate < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud networkloadbalancer rule update (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'
+
+      option :forwarding_rule_id,
+              short: '-R FORWARDING_RULE_ID',
+              long: '--forwarding-rule FORWARDING_RULE_ID',
+              description: 'ID of the Network Loadbalancer Forwarding Rule'
+
+      option :name,
+              short: '-n NAME',
+              long: '--name NAME',
+              description: 'A name of that Network Load Balancer forwarding rule'
+
+      option :algorithm,
+              short: '-a ALGORITHM',
+              long: '--algorithm ALGORITHM',
+              description: 'Algorithm for the balancing'
+
+      option :protocol,
+              long: '--protocol PROTOCOL',
+              description: 'Protocol of the balancing'
+
+      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.'
+
+      option :connect_timeout,
+              long: '--connect-timeout CONNECT_TIMEOUT',
+              description: 'It specifies the maximum time (in milliseconds) to wait for a connection attempt to a '\
+              'target VM to succeed. If unset, the default of 5 seconds will be used.'
+
+      option :target_timeout,
+              long: '--terget-timeout TARGET_TIMEOUT',
+              description: 'TargetTimeout specifies the maximum inactivity time (in milliseconds) on the target VM side. '\
+              'If unset, the default of 50 seconds will be used.'
+
+      option :retries,
+              short: '-r RETRIES',
+              long: '--retries RETRIES',
+              description: 'Retries specifies the number of retries to perform on a target VM after a connection failure. '\
+              'If unset, the default value of 3 will be used. (valid range: [0, 65535])'
+
+      option :targets,
+              long: '--targets TARGETS',
+              description: 'Array of targets'
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Updates information about a Ionoscloud Network Load Balancer.'
+        @directory = 'compute-engine'
+        @required_options = [:datacenter_id, :network_loadbalancer_id, :ionoscloud_username, :ionoscloud_password]
+        @updatable_fields = [
+          :name, :algorithm, :protocol, :listener_ip, :listener_port, :targets,
+          :client_timeout, :connect_timeout, :target_timeout, :retries,
+        ]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        network_load_balancer_api = Ionoscloud::NetworkLoadBalancersApi.new(api_client)
+
+        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
+          |target|
+          Ionoscloud::NetworkLoadBalancerForwardingRuleTarget.new(
+            ip: target['ip'],
+            port: target['port'],
+            weight: target['weight'],
+            health_check: Ionoscloud::NetworkLoadBalancerForwardingRuleTargetHealthCheck.new(
+              check: target['health_check']['check'],
+              check_interval: target['health_check']['check_interval'],
+              maintenance: target['health_check']['maintenance'],
+            ),
+          )
+        end if config[:targets]
+
+        if @updatable_fields.map { |el| config[el] }.any?
+          print "#{ui.color('Updating Network Load Balancer...', :magenta)}"
+
+          _, _, headers  = network_load_balancer_api.datacenters_networkloadbalancers_forwardingrules_patch_with_http_info(
+            config[:datacenter_id],
+            config[:network_loadbalancer_id],
+            config[:forwarding_rule_id],
+            Ionoscloud::NetworkLoadBalancerForwardingRuleProperties.new(
+              name: config[:name],
+              algorithm: config[:algorithm],
+              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],
+                connect_timeout: config[:connect_timeout],
+                target_timeout: config[:target_timeout],
+                retries: config[:retries],
+              ),
+            ),
+          )
+
+          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_network_load_balancer(
+          network_load_balancer_api.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_update.rb

@@ -0,0 +1,97 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudNetworkloadbalancerUpdate < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud networkloadbalancer update (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'
+
+      option :name,
+              short: '-n NAME',
+              long: '--name NAME',
+              description: 'Name of the load balancer'
+
+      option :listener_lan,
+              short: '-l LISTENER_LAN_ID',
+              long: '--listener-lan LISTENER_LAN_ID',
+              description: 'Id of the listening LAN. (inbound)'
+
+      option :target_lan,
+              short: '-t TARGET_LAN_ID',
+              long: '--target-lan TARGET_LAN_ID',
+              description: 'Id of the balanced private target LAN. (outbound)'
+
+      option :ips,
+              short: '-i IP[,IP,...]',
+              long: '--ips IP[,IP,...]',
+              description: 'Collection of IP addresses of the Network Load Balancer. (inbound and outbound) '\
+                          'IP of the listenerLan must be a customer reserved IP for the public load balancer '\
+                          'and private IP for the private load balancer.'
+
+      option :lb_private_ips,
+              long: '--private-ips IP[,IP,...]',
+              description: 'Collection of private IP addresses with subnet mask of the Network Load Balancer. '\
+                          'IPs must contain valid subnet mask. If user will not provide any IP then the system '\
+                          'will generate one IP with /24 subnet.'
+
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Updates information about a Ionoscloud Network Load Balancer.'
+        @directory = 'compute-engine'
+        @required_options = [:datacenter_id, :network_loadbalancer_id, :ionoscloud_username, :ionoscloud_password]
+        @updatable_fields = [:name, :listener_lan, :target_lan, :ips, :lb_private_ips]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        config[:ips] = config[:ips].split(',') if config[:ips] && config[:ips].instance_of?(String)
+        config[:lb_private_ips] = config[:lb_private_ips].split(',') if config[:lb_private_ips] && config[:lb_private_ips].instance_of?(String)
+
+        network_load_balancer_api = Ionoscloud::NetworkLoadBalancersApi.new(api_client)
+
+        if @updatable_fields.map { |el| config[el] }.any?
+          print "#{ui.color('Updating Network Load Balancer...', :magenta)}"
+
+          _, _, headers  = network_load_balancer_api.datacenters_networkloadbalancers_patch_with_http_info(
+            config[:datacenter_id],
+            config[:network_loadbalancer_id],
+            Ionoscloud::NetworkLoadBalancerProperties.new({
+              name: config[:name],
+              ips: config[:ips],
+              listener_lan: config[:listener_lan],
+              target_lan: config[:target_lan],
+              lb_private_ips: config[:lb_private_ips],
+            }.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_network_load_balancer(
+          network_load_balancer_api.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_nic_create.rb

@@ -31,7 +31,6 @@ class Chef
               short: '-d',
               long: '--dhcp',
               boolean: true | false,
-              default: true,
               description: 'Set to false if you wish to disable DHCP'
 
       option :lan,
@@ -43,28 +42,25 @@ class Chef
               short: '-t FIREWALL_TYPE',
               long: '--firewall-type FIREWALL_TYPE',
               description: 'The type of firewall rules that will be allowed on the NIC. If it is not specified it will take the '\
-              'default value INGRESS',
-              default: 'INGRESS'
-
-      attr_reader :description, :required_options
+              'default value INGRESS'
 
       def initialize(args = [])
         super(args)
         @description =
         "Creates a NIC on the specified server. The Ionoscloud platform supports adding multiple NICs to a server. These NICs "\
         "can be used to create different, segmented networks on the platform."
+        @directory = 'compute-engine'
         @required_options = [:datacenter_id, :server_id, :lan, :ionoscloud_username, :ionoscloud_password]
       end
 
       def run
         $stdout.sync = true
+        handle_extra_config
         validate_required_params(@required_options, config)
 
         print "#{ui.color('Creating nic...', :magenta)}"
 
-        if config[:ips]
-          config[:ips] = config[:ips].split(',')
-        end
+        config[:ips] = config[:ips].split(',') if config[:ips] && config[:ips].instance_of?(String)
 
         nic_properties = {
           name: config[:name],
@@ -85,23 +81,13 @@ class Chef
         dot = ui.color('.', :magenta)
         api_client.wait_for { print dot; is_done? get_request_id headers }
 
-        nic = nic_api.datacenters_servers_nics_find_by_id(
-          config[:datacenter_id],
-          config[:server_id],
-          nic.id,
+        print_nic(
+          nic_api.datacenters_servers_nics_find_by_id(
+            config[:datacenter_id],
+            config[:server_id],
+            nic.id,
+          ),
         )
-
-        puts "\n"
-        puts "#{ui.color('ID', :cyan)}: #{nic.id}"
-        puts "#{ui.color('Name', :cyan)}: #{nic.properties.name}"
-        puts "#{ui.color('IPs', :cyan)}: #{nic.properties.ips.to_s}"
-        puts "#{ui.color('DHCP', :cyan)}: #{nic.properties.dhcp}"
-        puts "#{ui.color('LAN', :cyan)}: #{nic.properties.lan}"
-        puts "#{ui.color('Firewall Type', :cyan)}: #{nic.properties.firewall_type}"
-        puts "#{ui.color('Device Number', :cyan)}: #{nic.properties.device_number}"
-        puts "#{ui.color('PCI Slot', :cyan)}: #{nic.properties.pci_slot}"
-
-        puts 'done'
       end
     end
   end

data/lib/chef/knife/ionoscloud_nic_delete.rb

@@ -17,17 +17,17 @@ class Chef
               long: '--server-id SERVER_ID',
               description: 'The ID of the server assigned the NIC'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
         'Deletes an existing NIC from a server.'
+        @directory = 'compute-engine'
         @required_options = [:datacenter_id, :server_id, :ionoscloud_username, :ionoscloud_password]
       end
 
       def run
         $stdout.sync = true
+        handle_extra_config
         validate_required_params(@required_options, config)
 
         nic_api = Ionoscloud::NetworkInterfacesApi.new(api_client)
@@ -40,14 +40,8 @@ class Chef
             next
           end
 
-          msg_pair('ID', nic.id)
-          msg_pair('Name', nic.properties.name)
-          msg_pair('IPs', nic.properties.ips)
-          msg_pair('DHCP', nic.properties.dhcp)
-          msg_pair('LAN', nic.properties.lan)
-          msg_pair('Firewall Type', nic.properties.firewall_type)
-          msg_pair('Device Number', nic.properties.device_number)
-          msg_pair('PCI Slot', nic.properties.pci_slot)
+          print_nic(nic)
+          puts "\n"
 
           begin
             confirm('Do you really want to delete this Nic')

data/lib/chef/knife/ionoscloud_nic_get.rb

@@ -0,0 +1,48 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudNicGet < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud nic get (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'ID of the data center'
+
+      option :server_id,
+              short: '-S SERVER_ID',
+              long: '--server-id SERVER_ID',
+              description: 'The ID of the server to which the NIC is assigned'
+
+      option :nic_id,
+              short: '-N NIC_ID',
+              long: '--nic-id NIC_ID',
+              description: 'ID of the load balancer'
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Retrieves the attributes of a given NIC.'
+        @directory = 'compute-engine'
+        @required_options = [:datacenter_id, :server_id, :nic_id, :ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        print_nic(
+          Ionoscloud::NetworkInterfacesApi.new(api_client).datacenters_servers_nics_find_by_id(
+            config[:datacenter_id],
+            config[:server_id],
+            config[:nic_id],
+          ),
+        )
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_nic_list.rb

@@ -17,17 +17,17 @@ class Chef
               long: '--server-id SERVER_ID',
               description: 'The ID of the server assigned the NIC'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
         'List all available NICs connected to a server.'
+        @directory = 'compute-engine'
         @required_options = [:datacenter_id, :server_id, :ionoscloud_username, :ionoscloud_password]
       end
 
       def run
         $stdout.sync = true
+        handle_extra_config
         validate_required_params(@required_options, config)
 
         nic_list = [

data/lib/chef/knife/ionoscloud_nic_update.rb

@@ -0,0 +1,95 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudNicUpdate < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud nic update (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'ID of the data center'
+
+      option :server_id,
+              short: '-S SERVER_ID',
+              long: '--server-id SERVER_ID',
+              description: 'The ID of the server to which the NIC is assigned'
+
+      option :nic_id,
+              short: '-N NIC_ID',
+              long: '--nic-id NIC_ID',
+              description: 'ID of the load balancer'
+
+      option :name,
+              short: '-n NAME',
+              long: '--name NAME',
+              description: 'Name of the NIC'
+
+      option :ips,
+              short: '-i IP[,IP,...]',
+              long: '--ips IP[,IP,...]',
+              description: 'IPs assigned to the NIC'
+
+      option :dhcp,
+              long: '--dhcp DHCP',
+              description: 'Set to false if you wish to disable DHCP'
+
+      option :lan,
+              short: '-l ID',
+              long: '--lan ID',
+              description: 'The LAN ID the NIC will reside on; if the LAN ID does not exist it will be created'
+
+
+      option :firewall_type,
+              short: '-t FIREWALL_TYPE',
+              long: '--firewall-type FIREWALL_TYPE',
+              description: 'The type of firewall rules that will be allowed on the NIC. If it is not specified it will take the '\
+              'default value INGRESS'
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Updates information about a Ionoscloud NIC.'
+        @directory = 'compute-engine'
+        @required_options = [:datacenter_id, :server_id, :nic_id, :ionoscloud_username, :ionoscloud_password]
+        @updatable_fields = [:name, :ips, :dhcp, :lan, :nat]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        config[:ips] = config[:ips].split(',') if config[:ips] && config[:ips].instance_of?(String)
+
+        nic_api = Ionoscloud::NetworkInterfacesApi.new(api_client)
+
+        if @updatable_fields.map { |el| config[el] }.any?
+          print "#{ui.color('Updating NIC...', :magenta)}"
+
+          _, _, headers  = nic_api.datacenters_servers_nics_patch_with_http_info(
+            config[:datacenter_id],
+            config[:server_id],
+            config[:nic_id],
+            Ionoscloud::NicProperties.new(
+              name: config[:name],
+              ips: config[:ips],
+              dhcp: (config.key?(:dhcp) ? config[:dhcp].to_s.downcase == 'true' : nil),
+              lan: config[:lan],
+              firewall_type: config[:firewall_type],
+            ),
+          )
+
+          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_nic(nic_api.datacenters_servers_nics_find_by_id(config[:datacenter_id], config[:server_id], config[:nic_id]))
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_node_delete.rb

@@ -18,17 +18,17 @@ class Chef
               long: '--nodepool-id NODEPOOL_ID',
               description: 'The ID of the K8s Nodepool'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
         'Delete a single Kubernetes Node.'
+        @directory = 'kubernetes'
         @required_options = [:cluster_id, :nodepool_id, :ionoscloud_username, :ionoscloud_password]
       end
 
       def run
         $stdout.sync = true
+        handle_extra_config
         validate_required_params(@required_options, config)
 
         kubernetes_api = Ionoscloud::KubernetesApi.new(api_client)

data/lib/chef/knife/ionoscloud_node_get.rb

@@ -0,0 +1,48 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudNodeGet < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud node get (options)'
+
+      option :cluster_id,
+              short: '-C CLUSTER_ID',
+              long: '--cluster-id CLUSTER_ID',
+              description: 'The ID of the K8s Cluster'
+
+      option :nodepool_id,
+              short: '-P NODEPOOL_ID',
+              long: '--nodepool-id NODEPOOL_ID',
+              description: 'The ID of the K8s Nodepool'
+
+      option :node_id,
+              short: '-N NODE_ID',
+              long: '--node-id NODE_ID',
+              description: 'ID of the load balancer'
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Retrieves the attributes of a given K8S Node.'
+        @directory = 'kubernetes'
+        @required_options = [:cluster_id, :nodepool_id, :node_id, :ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        print_k8s_node(
+          Ionoscloud::KubernetesApi.new(api_client).k8s_nodepools_nodes_find_by_id(
+            config[:cluster_id],
+            config[:nodepool_id],
+            config[:node_id],
+          ),
+        )
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_node_list.rb

@@ -17,17 +17,17 @@ class Chef
               long: '--nodepool-id NODEPOOL_ID',
               description: 'The ID of the K8s Nodepool'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
         'Retrieve a list of Kubernetes Nodes in a Nodepool.'
+        @directory = 'kubernetes'
         @required_options = [:cluster_id, :nodepool_id, :ionoscloud_username, :ionoscloud_password]
       end
 
       def run
         $stdout.sync = true
+        handle_extra_config
         validate_required_params(@required_options, config)
 
         node_list = [

data/lib/chef/knife/ionoscloud_node_replace.rb

@@ -18,8 +18,6 @@ class Chef
               long: '--nodepool-id NODEPOOL_ID',
               description: 'The ID of the K8s Nodepool'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
@@ -28,11 +26,13 @@ class Chef
         "template creates & configures a new node, waits for status \"ACTIVE\", "\
         "and migrates all the pods from the faulty node, deleting it once empty. "\
         "While this operation occurs, the nodepool will have an extra billable \"ACTIVE\" node."
+        @directory = 'kubernetes'
         @required_options = [:cluster_id, :nodepool_id, :ionoscloud_username, :ionoscloud_password]
       end
 
       def run
         $stdout.sync = true
+        handle_extra_config
         validate_required_params(@required_options, config)
 
         kubernetes_api = Ionoscloud::KubernetesApi.new(api_client)