knife-ionoscloud 5.0.0.beta.1

data/lib/chef/knife/ionoscloud_nodepool_delete.rb

@@ -0,0 +1,60 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudNodepoolDelete < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud nodepool delete NODEPOOL_ID [NODEPOOL_ID] (options)'
+
+      option :cluster_id,
+              short: '-C CLUSTER_ID',
+              long: '--cluster-id CLUSTER_ID',
+              description: 'The ID of the K8s Cluster'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Deletes a node pool within an existing Kubernetes cluster.'
+        @required_options = [:cluster_id, :ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        validate_required_params(@required_options, config)
+
+        kubernetes_api = Ionoscloud::KubernetesApi.new(api_client)
+
+        @name_args.each do |nodepool_id|
+          begin
+            nodepool = kubernetes_api.k8s_nodepools_find_by_id(config[:cluster_id], nodepool_id)
+          rescue Ionoscloud::ApiError => err
+            raise err unless err.code == 404
+            ui.error("K8s Nodepool ID #{nodepool_id} not found. Skipping.")
+            next
+          end
+
+          msg_pair('ID', nodepool.id)
+          msg_pair('Name', nodepool.properties.name)
+          msg_pair('K8s Version', nodepool.properties.k8s_version)
+          msg_pair('Datacenter ID', nodepool.properties.datacenter_id)
+          msg_pair('Node Count', nodepool.properties.node_count)
+          msg_pair('State', nodepool.metadata.state)
+
+          puts "\n"
+
+          begin
+            confirm('Do you really want to delete this K8s Nodepool')
+          rescue SystemExit => exc
+            next
+          end
+
+          kubernetes_api.k8s_nodepools_delete(config[:cluster_id], nodepool.id)
+          ui.warn("Deleted K8s Nodepool #{nodepool.id}.")
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_nodepool_list.rb

@@ -0,0 +1,51 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudNodepoolList < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud nodepool list'
+
+      option :cluster_id,
+              short: '-C CLUSTER_ID',
+              long: '--cluster-id CLUSTER_ID',
+              description: 'The ID of the K8s Cluster'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Retrieve a list of all node pools contained in a selected Kubernetes cluster.'
+        @required_options = [:cluster_id, :ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        validate_required_params(@required_options, config)
+
+        nodepool_list = [
+          ui.color('ID', :bold),
+          ui.color('Name', :bold),
+          ui.color('K8s Version', :bold),
+          ui.color('Datacenter ID', :bold),
+          ui.color('Node Count', :bold),
+          ui.color('State', :bold),
+        ]
+
+        kubernetes_api = Ionoscloud::KubernetesApi.new(api_client)
+
+        kubernetes_api.k8s_nodepools_get(config[:cluster_id], { depth: 1 }).items.each do |nodepool|
+          nodepool_list << nodepool.id
+          nodepool_list << nodepool.properties.name
+          nodepool_list << nodepool.properties.k8s_version
+          nodepool_list << nodepool.properties.datacenter_id
+          nodepool_list << nodepool.properties.node_count.to_s
+          nodepool_list << nodepool.metadata.state
+        end
+        puts ui.list(nodepool_list, :uneven_columns_across, 6)
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_pcc_create.rb

@@ -0,0 +1,68 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudPccCreate < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud pcc create (options)'
+
+      option :name,
+              short: '-n NAME',
+              long: '--name NAME',
+              description: 'Name of the data center'
+
+      option :description,
+              short: '-D DESCRIPTION',
+              long: '--description DESCRIPTION',
+              description: 'Description of the data center'
+
+      option :peers,
+              long: '--peers LAN_ID [LAN_ID]',
+              description: 'An array of LANs joined to this private cross connect'
+
+      option :datacenters,
+              long: '--datacenters DATACENTER_IS [DATACENTER_IS]',
+              description: 'An array of datacenters joined to this private cross connect'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Creates a Private Cross-Connect.'
+        @required_options = [:ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        validate_required_params(@required_options, config)
+
+        print "#{ui.color('Creating private cross connect...', :magenta)}"
+
+        pcc_api = Ionoscloud::PrivateCrossConnectApi.new(api_client)
+
+        config[:peers] = config[:peers].split(',').map { |peer| { id: peer } } unless config[:peers].nil?
+        config[:datacenters] = config[:datacenters].split(',').map { |datacenter| { id: datacenter } } unless config[:datacenters].nil?
+
+        pcc, _, headers  = pcc_api.pccs_post_with_http_info({
+          properties: {
+            name: config[:name],
+            description: config[:description],
+          }.compact,
+        })
+
+        dot = ui.color('.', :magenta)
+        api_client.wait_for { print dot; is_done? get_request_id headers }
+
+        puts "\n"
+        puts "#{ui.color('ID', :cyan)}: #{pcc.id}"
+        puts "#{ui.color('Name', :cyan)}: #{pcc.properties.name}"
+        puts "#{ui.color('Description', :cyan)}: #{pcc.properties.description}"
+        puts "#{ui.color('Peers', :cyan)}: #{pcc.properties.peers.to_s}"
+        puts "#{ui.color('Datacenters', :cyan)}: #{pcc.properties.connectable_datacenters.to_s}"
+        puts 'done'
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_pcc_delete.rb

@@ -0,0 +1,57 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudPccDelete < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud pcc delete PCC_ID [PCC_ID]'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Deletes a Private Cross-Connect.'
+        @required_options = [:ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        validate_required_params(@required_options, config)
+
+        pcc_api = Ionoscloud::PrivateCrossConnectApi.new(api_client)
+
+        @name_args.each do |pcc_id|
+          begin
+            pcc = pcc_api.pccs_find_by_id(pcc_id)
+          rescue Ionoscloud::ApiError => err
+            raise err unless err.code == 404
+            ui.error("PCC ID #{pcc_id} not found. Skipping.")
+            next
+          end
+
+          peers = pcc.properties.peers.map { |peer| peer.id }
+          datacenters = pcc.properties.connectable_datacenters.map { |datacenter| datacenter.id }
+
+          msg_pair('ID', pcc.id)
+          msg_pair('Name', pcc.properties.name)
+          msg_pair('Description', pcc.properties.description)
+          msg_pair('Peers', peers.to_s)
+          msg_pair('Datacenters', datacenters.to_s)
+
+          puts "\n"
+
+          begin
+            confirm('Do you really want to delete this PCC')
+          rescue SystemExit => exc
+            next
+          end
+
+          _, _, headers = pcc_api.pccs_delete_with_http_info(pcc_id)
+          ui.warn("Deleted PCC #{pcc.id}. Request ID: #{get_request_id headers}")
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_pcc_list.rb

@@ -0,0 +1,41 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudPccList < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud pcc list'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Lists all Private Cross-Connect instances.'
+        @required_options = [:ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        validate_required_params(@required_options, config)
+
+        pcc_list = [
+          ui.color('ID', :bold),
+          ui.color('Name', :bold),
+          ui.color('Description', :bold),
+        ]
+
+        pcc_api = Ionoscloud::PrivateCrossConnectApi.new(api_client)
+
+        pcc_api.pccs_get({ depth: 1 }).items.each do |pcc|
+          pcc_list << pcc.id
+          pcc_list << pcc.properties.name
+          pcc_list << pcc.properties.description || ''
+        end
+
+        puts ui.list(pcc_list, :uneven_columns_across, 3)
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_request_list.rb

@@ -0,0 +1,94 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudRequestList < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud request list (options)'
+
+      option :limit,
+              short: '-l LIMIT',
+              long: '--limit LIMIT',
+              description: 'The maximum number of results.'
+
+      option :offset,
+              short: '-o OFFSET',
+              long: '--offset OFFSET',
+              description: 'The request number from which to return results.'
+
+      # option :status,
+      #         short: '-s STATUS',
+      #         long: '--status STATUS',
+      #         description: 'Request status filter to fetch all the request based on a particular status [QUEUED, RUNNING, DONE, FAILED]'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'This operation allows you to retrieve a list of requests. Cloud API calls generate a '\
+        'request which is assigned an id. This "request id" can be used to get information about '\
+        'the request and its current status. The "list request" operation described here will '\
+        'return an array of request items. Each returned request item will have an id that can be '\
+        'used to get additional information as described in the Get Request and Get Request Status sections.'
+        @required_options = [:ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        validate_required_params(@required_options, config)
+
+        request_list = [
+          ui.color('ID', :bold),
+          ui.color('Status', :bold),
+          ui.color('Method', :bold),
+          ui.color('Targets', :bold),
+        ]
+
+        request_api = Ionoscloud::RequestApi.new(api_client)
+
+        begin
+          config[:limit] = Integer(config[:limit])
+        rescue *[ArgumentError, TypeError]
+          if config[:limit]
+            ui.warn('limit should be an Integer!')
+          end
+          config[:limit] = 20
+        end
+
+        begin
+          config[:offset] = Integer(config[:offset])
+        rescue *[ArgumentError, TypeError]
+          if config[:offset]
+            ui.warn('offset should be an Integer!')
+          end
+          config[:offset] = 0
+        end
+
+        opts = {
+          depth: 2,
+          limit: config[:limit],
+          offset: config[:offset],
+        }
+
+        # if config[:status] && ['QUEUED', 'RUNNING', 'DONE', 'FAILED'].include?(config[:status])
+        #   opts[:status] = config[:status]
+        # end
+
+        # if config[:status] && !['QUEUED', 'RUNNING', 'DONE', 'FAILED'].include?(config[:status])
+        #   ui.warn('status should be one of [QUEUED, RUNNING, DONE, FAILED]')
+        # end
+
+        request_api.requests_get(opts).items.each do |request|
+          request_list << request.id
+          request_list << request.metadata.request_status.metadata.status
+          request_list << request.properties.method
+          request_list << request.metadata.request_status.metadata.targets.map { |target| [target.target.id, target.target.type] }.to_s
+        end
+
+        puts ui.list(request_list, :uneven_columns_across, 4)
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_request_status.rb

@@ -0,0 +1,37 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudRequestStatus < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud request status (options)'
+
+      option :request_id,
+              short: '-R REQUEST_ID',
+              long: '--request-id REQUEST_ID',
+              description: 'The ID of the Request.'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Retrieves the status of a specific request based on the supplied request id.'
+        @required_options = [:request_id, :ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        validate_required_params(@required_options, config)
+
+        begin
+          puts Ionoscloud::RequestApi.new(api_client).requests_status_get(config[:request_id]).metadata.status
+        rescue Ionoscloud::ApiError => err
+          raise err unless err.code == 404
+          ui.error("Request ID #{config[:request_id]} not found.")
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_request_wait.rb

@@ -0,0 +1,41 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudRequestWait < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud request wait (options)'
+
+      option :request_id,
+              short: '-R REQUEST_ID',
+              long: '--request-id REQUEST_ID',
+              description: 'The ID of the Backup unit.'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Waits until a request status is either DONE or FAILED.'
+        @required_options = [:request_id, :ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        validate_required_params(@required_options, config)
+
+        print "#{ui.color('Waiting for request...', :magenta)}"
+
+        begin
+          dot = ui.color('.', :magenta)
+          api_client.wait_for { print dot; is_done? config[:request_id] }
+        rescue Ionoscloud::ApiError => err
+          raise err unless err.code == 404
+          ui.error("Request ID #{config[:request_id]} not found.")
+        end
+        print "\n"
+      end
+    end
+  end
+end