knife-ionoscloud 6.0.0.alpha.1 → 6.1.0

data/lib/chef/knife/ionoscloud_dbaas_postgres_cluster_get.rb

@@ -0,0 +1,34 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudDbaasPostgresClusterGet < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud dbaas postgres cluster get (options)'
+
+      option :cluster_id,
+              short: '-C CLUSTER_ID',
+              long: '--cluster-id CLUSTER_ID',
+              description: 'ID of the cluster'
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'You can retrieve a PostgreSQL cluster by using its ID. This value can be
+        found in the response body when a PostgreSQL cluster is created or when
+        you GET a list of PostgreSQL clusters.'
+        @directory = 'dbaas-postgres'
+        @required_options = [:cluster_id, :ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        print_cluster(IonoscloudDbaasPostgres::ClustersApi.new(api_client_dbaas).clusters_find_by_id(config[:cluster_id]))
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_dbaas_postgres_cluster_list.rb

@@ -0,0 +1,53 @@
+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'
+        @required_options = [:ionoscloud_username, :ionoscloud_password]
+      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('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.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, 9)
+      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, :ionoscloud_username, :ionoscloud_password]
+      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,102 @@
+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, :ionoscloud_username, :ionoscloud_password]
+        @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]) ? IonoscloudDbaas::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
+
+          cluster, _, headers  = clusters_api.clusters_patch_with_http_info(config[:cluster_id], cluster_request)
+
+          dot = ui.color('.', :magenta)
+        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,59 @@
+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.'
+
+      option :end,
+              long: '--end END',
+              description: 'The end time for the query in RFC3339 format.'
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Retrieves PostgreSQL logs based on the given parameters.'
+        @directory = 'dbaas-postgres'
+        @required_options = [:cluster_id, :ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        logs = IonoscloudDbaasPostgres::LogsApi.new(api_client_dbaas).cluster_logs_get(
+          config[:cluster_id],
+          {
+            limit: (config[:limit] != nil ? Integer(config[:limit]) : nil),
+            start: config[:start],
+            end: config[:end],
+          },
+        )
+
+        logs.instances.each { |instance|
+          puts "Instance Name: #{instance.name}"
+          print "\n"
+          puts instance.messages.map { |message| message.message }
+          puts "\n"
+        }
+      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'
+        @required_options = [:ionoscloud_username, :ionoscloud_password]
+      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

@@ -30,7 +30,6 @@ class Chef
       option :protocol,
               short: '-P PROTOCOL',
               long: '--protocol PROTOCOL',
-              default: 'TCP',
               description: 'The protocol of the firewall rule (TCP, UDP, ICMP, ANY)'
 
       option :source_mac,
@@ -73,20 +72,19 @@ class Chef
       option :type,
               short: '--t TYPE',
               long: '--type TYPE',
-              description: 'The type of firewall rule. If is not specified, it will take the default value INGRESS',
-              default: 'INGRESS'
-
-      attr_reader :description, :required_options
+              description: 'The type of firewall rule. If is not specified, it will take the default value INGRESS'
 
       def initialize(args = [])
         super(args)
         @description =
         'Creates a new firewall rule on an existing 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 "#{ui.color('Creating firewall...', :magenta)}"
@@ -116,26 +114,14 @@ class Chef
         dot = ui.color('.', :magenta)
         api_client.wait_for { print dot; is_done? get_request_id headers }
 
-        firewall = firewallrules_api.datacenters_servers_nics_firewallrules_find_by_id(
-          config[:datacenter_id],
-          config[:server_id],
-          config[:nic_id],
-          firewall.id,
+        print_firewall_rule(
+          firewallrules_api.datacenters_servers_nics_firewallrules_find_by_id(
+            config[:datacenter_id],
+            config[:server_id],
+            config[:nic_id],
+            firewall.id,
+          ),
         )
-
-        puts "\n"
-        puts "#{ui.color('ID', :cyan)}: #{firewall.id}"
-        puts "#{ui.color('Name', :cyan)}: #{firewall.properties.name}"
-        puts "#{ui.color('Protocol', :cyan)}: #{firewall.properties.protocol}"
-        puts "#{ui.color('Source MAC', :cyan)}: #{firewall.properties.source_mac}"
-        puts "#{ui.color('Source IP', :cyan)}: #{firewall.properties.source_ip}"
-        puts "#{ui.color('Target IP', :cyan)}: #{firewall.properties.target_ip}"
-        puts "#{ui.color('Port Range Start', :cyan)}: #{firewall.properties.port_range_start}"
-        puts "#{ui.color('Port Range End', :cyan)}: #{firewall.properties.port_range_end}"
-        puts "#{ui.color('ICMP Type', :cyan)}: #{firewall.properties.icmp_type}"
-        puts "#{ui.color('ICMP Code', :cyan)}: #{firewall.properties.icmp_code}"
-        puts "#{ui.color('Type', :cyan)}: #{firewall.properties.type}"
-        puts 'done'
       end
     end
   end

data/lib/chef/knife/ionoscloud_firewall_delete.rb

@@ -22,17 +22,17 @@ 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.'
+        @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)
 
         firewallrules_api = Ionoscloud::FirewallRulesApi.new(api_client)
@@ -48,17 +48,8 @@ class Chef
             next
           end
 
-          msg_pair('ID', firewall.id)
-          msg_pair('Name', firewall.properties.name)
-          msg_pair('Protocol', firewall.properties.protocol)
-          msg_pair('Source MAC', firewall.properties.source_mac)
-          msg_pair('Source IP', firewall.properties.source_ip)
-          msg_pair('Target IP', firewall.properties.target_ip)
-          msg_pair('Port Range Start', firewall.properties.port_range_start)
-          msg_pair('Port Range End', firewall.properties.port_range_end)
-          msg_pair('ICMP Type', firewall.properties.icmp_type)
-          msg_pair('ICMP Code', firewall.properties.icmp_code)
-          msg_pair('Type', firewall.properties.type)
+          print_firewall_rule(firewall)
+          puts "\n"
 
           begin
             confirm('Do you really want to delete this firewall rule')

data/lib/chef/knife/ionoscloud_firewall_get.rb

@@ -0,0 +1,51 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudFirewallGet < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud firewall get (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'
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Retrieves information about a Ionoscloud Firewall Rule.'
+        @directory = 'compute-engine'
+        @required_options = [:firewall_id, :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_firewall_rule(
+          Ionoscloud::FirewallRulesApi.new(api_client).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_firewall_list.rb

@@ -22,17 +22,17 @@ 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.'
+        @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)
 
         firewall_list = [

data/lib/chef/knife/ionoscloud_firewall_update.rb

@@ -0,0 +1,131 @@
+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',
+              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'
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Updates information about a Ionoscloud Firewall Rule.'
+        @directory = 'compute-engine'
+        @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