knife-ionoscloud 6.0.0 → 6.1.2

data/lib/chef/knife/ionoscloud_dbaas_postgres_cluster_list.rb

@@ -0,0 +1,54 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudDbaasPostgresClusterList < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud dbaas postgres cluster list'
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Retrieves a list of PostgreSQL clusters.'
+        @directory = 'dbaas-postgres'
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        dbaas_cluster_list = [
+          ui.color('ID', :bold),
+          ui.color('Display Name', :bold),
+          ui.color('Postgres Version', :bold),
+          ui.color('Location', :bold),
+          ui.color('Backup location', :bold),
+          ui.color('Instances', :bold),
+          ui.color('Datacenter ID', :bold),
+          ui.color('Lan ID', :bold),
+          ui.color('cidr', :bold),
+          ui.color('Status', :bold),
+        ]
+
+        clusters_api = IonoscloudDbaasPostgres::ClustersApi.new(api_client_dbaas)
+
+        clusters_api.clusters_get(depth: 1).items.each do |cluster|
+          dbaas_cluster_list << cluster.id
+          dbaas_cluster_list << cluster.properties.display_name
+          dbaas_cluster_list << cluster.properties.postgres_version
+          dbaas_cluster_list << cluster.properties.location
+          dbaas_cluster_list << cluster.properties.backup_location
+          dbaas_cluster_list << cluster.properties.instances
+          dbaas_cluster_list << cluster.properties.connections.first.datacenter_id
+          dbaas_cluster_list << cluster.properties.connections.first.lan_id
+          dbaas_cluster_list << cluster.properties.connections.first.cidr
+          dbaas_cluster_list << cluster.metadata.state
+        end
+
+        puts ui.list(dbaas_cluster_list, :uneven_columns_across, 10)
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_dbaas_postgres_cluster_restore.rb

@@ -0,0 +1,48 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudDbaasPostgresClusterRestore < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud dbaas postgres cluster restore (options)'
+
+      option :cluster_id,
+              short: '-C CLUSTER_ID',
+              long: '--cluster-id CLUSTER_ID',
+              description: 'ID of the cluster'
+
+      option :backup_id,
+              short: '-B BACKUP_ID',
+              long: '--backup-id BACKUP_ID',
+              description: 'ID of backup'
+
+      option :recovery_target_time,
+              short: '-T RECOVERY_TARGET_TIME',
+              long: '--recovery-target-time RECOVERY_TARGET_TIME',
+              description: 'Recovery target time'
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Triggers an in-place restore of the given PostgreSQL.'
+        @directory = 'dbaas-postgres'
+        @required_options = [:cluster_id]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        print "#{ui.color('Restoring Cluster...', :magenta)}"
+
+        restore_request = IonoscloudDbaasPostgres::CreateRestoreRequest.new(backup_id: config[:backup_id], recovery_target_time: config[:recovery_target_time])
+
+        IonoscloudDbaasPostgres::RestoresApi.new(api_client_dbaas).cluster_restore_post(config[:cluster_id], restore_request)
+
+        puts("\nCluster restored succsefully.")
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_dbaas_postgres_cluster_update.rb

@@ -0,0 +1,100 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudDbaasPostgresClusterUpdate < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud dbaas postgres cluster update (options)'
+
+      option :cluster_id,
+              short: '-C CLUSTER_ID',
+              long: '--cluster-id CLUSTER_ID',
+              description: 'ID of the cluster'
+
+      option :cores,
+              short: '-C CORES',
+              long: '--cores CORES',
+              description: 'The number of CPU cores per instance.'
+
+      option :ram_size,
+              short: '-r RAM',
+              long: '--ram RAM',
+              description: 'The amount of memory per instance.'
+
+      option :storage_size,
+              long: '--size STORAGE_SIZE',
+              description: 'The amount of storage per instance.'
+
+      option :connections,
+              long: '--connections CONNECTIONS',
+              description: 'Array of VDCs to connect to your cluster.'
+
+      option :display_name,
+              short: '-n DISPLAY_NAME',
+              long: '--name DISPLAY_NAME',
+              description: 'The friendly name of your cluster.'
+
+      option :time,
+              long: '--time TIME',
+              description: 'Time Of the day when to perform the maintenance.'
+
+      option :day_of_the_week,
+              short: '-d DAY_OF_THE_WEEK',
+              long: '--day-of-the-week DAY_OF_THE_WEEK',
+              description: 'Day Of the week when to perform the maintenance.'
+
+      option :postgres_version,
+              long: '--postgres-version POSTGRES_VERSION',
+              description: 'The PostgreSQL version of your cluster'
+
+      option :instances,
+              short: '-R INSTANCES',
+              long: '--instances INSTANCES',
+              description: 'The total number of instances in the cluster (one master and n-1 standbys).'
+
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Updates information about a Ionoscloud Dbaas Cluster.'
+        @directory = 'dbaas-postgres'
+        @required_options = [:cluster_id]
+        @updatable_fields = [:cores, :ram, :storage_size, :display_name, :time, :day_of_the_week, :postgres_version, :instances]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        clusters_api = IonoscloudDbaasPostgres::ClustersApi.new(api_client_dbaas)
+
+        if @updatable_fields.map { |el| config[el] }.any?
+          print "#{ui.color('Updating cluster...', :magenta)}"
+
+          cluster_properties = IonoscloudDbaasPostgres::PatchClusterProperties.new(
+            cores: (config[:cores].nil? ? nil : Integer(config[:cores])),
+            ram: (config[:ram].nil? ? nil : Integer(config[:ram])),
+            storage_size: (config[:storage_size].nil? ? nil : Integer(config[:storage_size])),
+            display_name: config[:display_name],
+            maintenance_window: (config[:time] && config[:day_of_the_week]) ? IonoscloudDbaasPostgres::MaintenanceWindow.new(
+              time: config[:time],
+              day_of_the_week: config[:day_of_the_week],
+            ) : nil,
+            postgres_version: config[:postgres_version],
+            instances: config[:instances],
+          )
+          cluster_request = IonoscloudDbaasPostgres::PatchClusterRequest.new()
+          cluster_request.properties = cluster_properties
+
+          clusters_api.clusters_patch_with_http_info(config[:cluster_id], cluster_request)
+        else
+          ui.warn("Nothing to update, please set one of the attributes #{@updatable_fields}.")
+        end
+
+        print_cluster(clusters_api.clusters_find_by_id(config[:cluster_id]))
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_dbaas_postgres_logs_get.rb

@@ -0,0 +1,90 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudDbaasPostgresLogsGet < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud dbaas postgres logs get'
+
+      option :cluster_id,
+              short: '-C CLUSTER_ID',
+              long: '--cluster-id CLUSTER_ID',
+              description: 'ID of the cluster'
+
+      option :limit,
+              short: '-l LIMIT',
+              long: '--limit LIMIT',
+              description: 'The maximal number of log lines to return.'
+
+      option :start,
+              long: '--start START',
+              description: 'The start time for the query in RFC3339 format. If both start and since are set, start will be used.'
+
+      option :since,
+              long: '--since SINCE',
+              description: 'The start time for the query using a time delta since the current moment: 2h - 2 hours ago, 20m - 20 minutes ago. '\
+              'Only hours and minutes ar supported, and not at the same time. If both start and since are set, start will be used.'
+
+      option :end,
+              long: '--end END',
+              description: 'The end time for the query in RFC3339 format. If both end and until are set, end will be used.'
+
+      option :until,
+              long: '--until UNTIL',
+              description: 'The end time for the query using a time delta since the current moment: 2h - 2 hours ago, 20m - 20 minutes ago. '\
+              'Only hours and minutes ar supported, and not at the same time. If both end and until are set, end will be used.'
+
+      option :direction,
+              long: '--direction DIRECTION',
+              description: 'The direction in which to scan through the logs. '\
+                           'The logs are returned in order of the direction. One of ["BACKWARD", "FORWARD"]'
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Retrieves PostgreSQL logs based on the given parameters.'
+        @directory = 'dbaas-postgres'
+        @required_options = [:cluster_id]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        def delta_to_date(delta)
+          return nil if delta.nil?
+
+          unit = delta[-1]
+          unless ['h', 'm'].include? unit
+            ui.error('Time delta may only be specified in hours(h) or minutes(m)!')
+            exit(1)
+          end
+
+          minute_count = Integer(delta[0..-2])
+          minute_count *= 60 if unit == 'h'
+
+          (Time.now - minute_count * 60).iso8601
+        end
+
+        logs = IonoscloudDbaasPostgres::LogsApi.new(api_client_dbaas).cluster_logs_get(
+          config[:cluster_id],
+          {
+            limit: (config[:limit] != nil ? Integer(config[:limit]) : nil),
+            start: config[:start].nil? ? delta_to_date(config[:since]) : config[:start],
+            _end: config[:end].nil? ? delta_to_date(config[:until]) : config[:end],
+            direction: config[:direction],
+          },
+        )
+
+        logs.instances.each do |instance|
+          puts "Instance Name: #{instance.name}"
+          print "\n"
+          puts instance.messages.map { |message| message.message }
+          puts "\n"
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_dbaas_postgres_version_list.rb

@@ -0,0 +1,49 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudDbaasPostgresVersionList < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud dbaas postgres version list'
+
+      option :cluster_id,
+              short: '-C CLUSTER_ID',
+              long: '--cluster-id CLUSTER_ID',
+              description: 'ID of the cluster'
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'If cluster_id is provided, retrieves a list of all PostgreSQL versions '\
+        'available for a cluster including the current version, '\
+        'otherwise retrieves a list of all available PostgreSQL versions.'
+        @directory = 'dbaas-postgres'
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        version_list = [
+          ui.color('Version', :bold),
+        ]
+
+        clusters_api = IonoscloudDbaasPostgres::ClustersApi.new(api_client_dbaas)
+
+        if config[:cluster_id]
+          versions = clusters_api.cluster_postgres_versions_get(config[:cluster_id])
+        else
+          versions = clusters_api.postgres_versions_get()
+        end
+
+        versions.data.each do |version|
+          version_list << version.name
+        end
+
+        puts ui.list(version_list, :uneven_columns_across, 1)
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_firewall_create.rb

@@ -74,13 +74,12 @@ class Chef
               long: '--type TYPE',
               description: 'The type of firewall rule. If is not specified, it will take the default value INGRESS'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
         'Creates a new firewall rule on an existing NIC.'
-        @required_options = [:datacenter_id, :server_id, :nic_id, :ionoscloud_username, :ionoscloud_password]
+        @directory = 'compute-engine'
+        @required_options = [:datacenter_id, :server_id, :nic_id]
       end
 
       def run
@@ -100,7 +99,7 @@ class Chef
           port_range_end: config[:port_range_end],
           icmp_type: config[:icmp_type],
           icmp_code: config[:icmp_code],
-          type: config[:type]
+          type: config[:type],
         }
 
         firewallrules_api = Ionoscloud::FirewallRulesApi.new(api_client)

data/lib/chef/knife/ionoscloud_firewall_delete.rb

@@ -22,13 +22,12 @@ class Chef
               long: '--nic-id NIC_ID',
               description: 'ID of the NIC'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
         'Deletes a firewall rule from an existing NIC.'
-        @required_options = [:datacenter_id, :server_id, :nic_id, :ionoscloud_username, :ionoscloud_password]
+        @directory = 'compute-engine'
+        @required_options = [:datacenter_id, :server_id, :nic_id]
       end
 
       def run
@@ -54,7 +53,7 @@ class Chef
 
           begin
             confirm('Do you really want to delete this firewall rule')
-          rescue SystemExit => exc
+          rescue SystemExit
             next
           end
 

data/lib/chef/knife/ionoscloud_firewall_get.rb

@@ -27,13 +27,12 @@ class Chef
               long: '--firewall-id FIREWALL_ID',
               description: 'ID of the Firewall Rule'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
         'Retrieves information about a Ionoscloud Firewall Rule.'
-        @required_options = [:firewall_id, :datacenter_id, :server_id, :nic_id, :ionoscloud_username, :ionoscloud_password]
+        @directory = 'compute-engine'
+        @required_options = [:firewall_id, :datacenter_id, :server_id, :nic_id]
       end
 
       def run

data/lib/chef/knife/ionoscloud_firewall_list.rb

@@ -22,13 +22,12 @@ class Chef
               long: '--nic-id NIC_ID',
               description: 'ID of the NIC'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
         'Lists all available firewall rules assigned to a NIC.'
-        @required_options = [:datacenter_id, :server_id, :nic_id, :ionoscloud_username, :ionoscloud_password]
+        @directory = 'compute-engine'
+        @required_options = [:datacenter_id, :server_id, :nic_id]
       end
 
       def run
@@ -53,7 +52,7 @@ class Chef
         firewallrules_api = Ionoscloud::FirewallRulesApi.new(api_client)
 
         firewallrules_api.datacenters_servers_nics_firewallrules_get(
-          config[:datacenter_id], config[:server_id], config[:nic_id], { depth: 1 }
+          config[:datacenter_id], config[:server_id], config[:nic_id], { depth: 1 },
         ).items.each do |firewall|
           firewall_list << firewall.id
           firewall_list << firewall.properties.name

data/lib/chef/knife/ionoscloud_firewall_update.rb

@@ -75,13 +75,12 @@ class Chef
               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]
+        @directory = 'compute-engine'
+        @required_options = [:datacenter_id]
         @updatable_fields = [
           :name, :protocol, :source_mac, :source_ip, :target_ip,
           :port_range_start, :port_range_end, :icmp_type, :icmp_code,

data/lib/chef/knife/ionoscloud_flowlog_create.rb

@@ -56,13 +56,12 @@ class Chef
               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]
+        @directory = 'compute-engine'
+        @required_options = [:datacenter_id, :type]
       end
 
       def run

data/lib/chef/knife/ionoscloud_flowlog_delete.rb

@@ -37,13 +37,12 @@ class Chef
               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]
+        @directory = 'compute-engine'
+        @required_options = [:datacenter_id, :type]
       end
 
       def run
@@ -51,8 +50,6 @@ class Chef
         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)
@@ -90,7 +87,7 @@ class Chef
 
           begin
             confirm('Do you really want to delete this Flow Log')
-          rescue SystemExit => exc
+          rescue SystemExit
             next
           end
 

data/lib/chef/knife/ionoscloud_flowlog_get.rb

@@ -42,13 +42,12 @@ class Chef
               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]
+        @directory = 'compute-engine'
+        @required_options = [:flowlog_id, :datacenter_id, :type]
       end
 
       def run

data/lib/chef/knife/ionoscloud_flowlog_list.rb

@@ -37,13 +37,12 @@ class Chef
               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]
+        @directory = 'compute-engine'
+        @required_options = [:datacenter_id, :type]
       end
 
       def run
@@ -65,27 +64,25 @@ class Chef
           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 }
+            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 }
+            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 }
+            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

data/lib/chef/knife/ionoscloud_flowlog_update.rb

@@ -61,13 +61,12 @@ class Chef
               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]
+        @directory = 'compute-engine'
+        @required_options = [:flowlog_id, :datacenter_id, :type]
         @updatable_fields = [:name, :action, :direction, :bucket]
       end
 

data/lib/chef/knife/ionoscloud_group_create.rb

@@ -66,13 +66,12 @@ class Chef
               long: '--manage-certificates',
               description: 'Privilege for a group to access and manage certificates.'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
         'Use this operation to create a new group and set group privileges.'
-        @required_options = [:name, :ionoscloud_username, :ionoscloud_password]
+        @directory = 'user'
+        @required_options = [:name]
       end
 
       def run

data/lib/chef/knife/ionoscloud_group_delete.rb

@@ -7,15 +7,13 @@ class Chef
 
       banner 'knife ionoscloud group delete GROUP_ID [GROUP_ID]'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
         'Use this operation to delete a single group. Resources that are '\
         'assigned to the group are NOT deleted, but are no longer accessible '\
         'to the group members unless the member is a Contract Owner, Admin, or Resource Owner.'
-        @required_options = [:ionoscloud_username, :ionoscloud_password]
+        @directory = 'user'
       end
 
       def run
@@ -39,7 +37,7 @@ class Chef
 
           begin
             confirm('Do you really want to delete this Group')
-          rescue SystemExit => exc
+          rescue SystemExit
             next
           end
 

data/lib/chef/knife/ionoscloud_group_get.rb

@@ -12,14 +12,13 @@ class Chef
               long: '--group-id GROUP_ID',
               description: 'ID of the group.'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
         'Retrieves detailed information about a specific group. This will also '\
         'retrieve a list of users who are members of the group.'
-        @required_options = [:group_id, :ionoscloud_username, :ionoscloud_password]
+        @directory = 'user'
+        @required_options = [:group_id]
       end
 
       def run

data/lib/chef/knife/ionoscloud_group_list.rb

@@ -12,13 +12,11 @@ class Chef
               long: '--user-id USER_ID',
               description: 'ID of the user.'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
         'This retrieves a full list of all groups.'
-        @required_options = [:ionoscloud_username, :ionoscloud_password]
+        @directory = 'user'
       end
 
       def run