knife-ionoscloud 6.0.0 → 6.1.0

data/lib/chef/knife/ionoscloud_base.rb

@@ -11,13 +11,20 @@ class Chef
       def initialize(args = [])
         super(args)
         @description = ''
+        @directory = ''
         @required_options = []
       end
 
+      attr_reader :description, :required_options, :directory
+
       def self.included(includer)
         includer.class_eval do
           deps do
+            warn_level = $VERBOSE
+            $VERBOSE = nil
             require 'ionoscloud'
+            require 'ionoscloud-dbaas-postgres'
+            $VERBOSE = warn_level
           end
 
           option :ionoscloud_username,
@@ -105,6 +112,27 @@ class Chef
         @api_client
       end
 
+      def api_client_dbaas
+        return @api_client_dbaas if @api_client_dbaas
+
+        api_config_dbaas = IonoscloudDbaasPostgres::Configuration.new()
+
+        api_config_dbaas.username = config[:ionoscloud_username]
+        api_config_dbaas.password = config[:ionoscloud_password]
+
+        api_config_dbaas.debugging = config[:ionoscloud_debug] || false
+
+        @api_client_dbaas = IonoscloudDbaasPostgres::ApiClient.new(api_config_dbaas)
+
+        @api_client_dbaas.user_agent =  [
+          'knife/v' + MODULE_VERSION,
+          @api_client_dbaas.default_headers['User-Agent'],
+          'chef/' + Chef::VERSION,
+        ].join('_')
+
+        @api_client_dbaas
+      end
+
       def get_request_id(headers)
         begin
           headers['Location'].scan(%r{/requests/(\b[0-9a-f]{8}\b-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-\b[0-9a-f]{12}\b)}).last.first
@@ -423,6 +451,35 @@ class Chef
         end}"
         puts "#{ui.color('Flowlogs', :cyan)}: #{natgateway.entities.flowlogs.items.map { |flowlog| flowlog.id }}"
       end
+
+      def print_cluster(cluster)
+        connections = cluster.properties.connections.map { |connection| connection.to_hash }
+        
+        print "\n"
+        puts "#{ui.color('ID', :cyan)}: #{cluster.id}"
+        puts "#{ui.color('Display Name', :cyan)}: #{cluster.properties.display_name}"
+        puts "#{ui.color('Postgres Version', :cyan)}: #{cluster.properties.postgres_version}"
+        puts "#{ui.color('Location', :cyan)}: #{cluster.properties.location}"
+        puts "#{ui.color('Instances', :cyan)}: #{cluster.properties.instances}"
+        puts "#{ui.color('RAM Size', :cyan)}: #{cluster.properties.ram}"
+        puts "#{ui.color('Cores', :cyan)}: #{cluster.properties.cores}"
+        puts "#{ui.color('Storage Size', :cyan)}: #{cluster.properties.storage_size}"
+        puts "#{ui.color('Storage Type', :cyan)}: #{cluster.properties.storage_type}"
+        puts "#{ui.color('Connections', :cyan)}: #{connections}"
+        puts "#{ui.color('Maintenance Window', :cyan)}: #{cluster.properties.maintenance_window.to_hash}"
+        puts "#{ui.color('Synchronization Mode', :cyan)}: #{cluster.properties.synchronization_mode}"
+        puts "#{ui.color('Lifecycle Status', :cyan)}: #{cluster.metadata.state}"
+      end
+
+      def print_cluster_backup(backup)
+        print "\n"
+        puts "#{ui.color('ID', :cyan)}: #{backup.id}"
+        puts "#{ui.color('Cluster ID', :cyan)}: #{backup.properties.cluster_id}"
+        puts "#{ui.color('Version', :cyan)}: #{backup.properties.version}"
+        puts "#{ui.color('Is Active', :cyan)}: #{backup.properties.is_active}"
+        puts "#{ui.color('Earliest Recovery Target Time', :cyan)}: #{backup.properties.earliest_recovery_target_time}"
+        puts "#{ui.color('Created Date', :cyan)}: #{backup.metadata.created_date}"
+      end
     end
   end
 end

data/lib/chef/knife/ionoscloud_composite_server_create.rb

@@ -124,12 +124,11 @@ class Chef
               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'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
         'This creates a new composite server with an attached volume and NIC in a specified virtual data center.'
+        @directory = 'compute-engine'
         @required_options = [
           :datacenter_id, :name, :cores, :ram, :size, :type, :dhcp, :lan, :ionoscloud_username, :ionoscloud_password,
         ]

data/lib/chef/knife/ionoscloud_contract_list.rb

@@ -7,12 +7,11 @@ class Chef
 
       banner 'knife ionoscloud contract list'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
         'Lists information about available contract resources.'
+        @directory = 'user'
         @required_options = [:ionoscloud_username, :ionoscloud_password]
       end
 

data/lib/chef/knife/ionoscloud_cube_server_create.rb

@@ -104,12 +104,11 @@ class Chef
               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'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
         'This creates a new cube server with an attached volume and NIC in a specified virtual data center.'
+        @directory = 'compute-engine'
         @required_options = [
           :datacenter_id, :name, :template, :ionoscloud_username, :ionoscloud_password,
         ]

data/lib/chef/knife/ionoscloud_datacenter_create.rb

@@ -22,8 +22,6 @@ class Chef
               long: '--location LOCATION',
               description: 'Location of the data center'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
@@ -32,6 +30,7 @@ class Chef
         "A list of locations can be obtained with location command.\n\n\t"\
         "```text\nknife ionoscloud location list\n```\n\n"\
         "Make a note of the desired location ID and now the data center can be created.\n"
+        @directory = 'compute-engine'
         @required_options = [:location, :ionoscloud_username, :ionoscloud_password]
       end
 

data/lib/chef/knife/ionoscloud_datacenter_delete.rb

@@ -7,14 +7,13 @@ class Chef
 
       banner 'knife ionoscloud datacenter delete DATACENTER_ID [DATACENTER_ID]'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
         'You will want to exercise a bit of caution here. Removing a data center will destroy '\
         'all objects contained within that data center -- servers, volumes, snapshots, and so on. '\
         'The objects -- once removed -- will be unrecoverable.'
+        @directory = 'compute-engine'
         @required_options = [:ionoscloud_username, :ionoscloud_password]
       end
 

data/lib/chef/knife/ionoscloud_datacenter_get.rb

@@ -12,12 +12,11 @@ class Chef
               long: '--datacenter-id DATACENTER_ID',
               description: 'ID of the data center'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
         'Retrieves information about a Ionoscloud Datacenter.'
+        @directory = 'compute-engine'
         @required_options = [:datacenter_id, :ionoscloud_username, :ionoscloud_password]
       end
 

data/lib/chef/knife/ionoscloud_datacenter_list.rb

@@ -7,8 +7,6 @@ class Chef
 
       banner 'knife ionoscloud datacenter list'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
@@ -18,6 +16,7 @@ class Chef
         'networking, and other resources. The goal is to give you the same '\
         'experience as you would have if you were running your own physical '\
         'data center. A list of available data centers can be obtained with the following command.'
+        @directory = 'compute-engine'
         @required_options = [:ionoscloud_username, :ionoscloud_password]
       end
 

data/lib/chef/knife/ionoscloud_datacenter_update.rb

@@ -25,12 +25,11 @@ class Chef
               long: '--sec-auth-protection SEC_AUTH_PROTECTION',
               description: 'Boolean value representing if the data center requires extra protection e.g. two factor protection'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
         'Updates information about a Ionoscloud Datacenter.'
+        @directory = 'compute-engine'
         @required_options = [:datacenter_id, :ionoscloud_username, :ionoscloud_password]
         @updatable_fields = [:name, :description, :sec_auth_protection]
       end

data/lib/chef/knife/ionoscloud_dbaas_postgres_backup_get.rb

@@ -0,0 +1,33 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudDbaasPostgresBackupGet < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud dbaas postgres cluster get (options)'
+
+      option :backup_id,
+              short: '-B BACKUP_ID',
+              long: '--backup-id BACKUP_ID',
+              description: 'ID of the cluster backup'
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Retrieve a PostgreSQL cluster backup by using its ID. This value can be
+        found when you GET a list of PostgreSQL cluster backups.'
+        @directory = 'dbaas-postgres'
+        @required_options = [:backup_id, :ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        print_cluster_backup(IonoscloudDbaasPostgres::BackupsApi.new(api_client_dbaas).clusters_backups_find_by_id(config[:backup_id]))
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_dbaas_postgres_backup_list.rb

@@ -0,0 +1,59 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudDbaasPostgresBackupList < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud dbaas postgres backup list (options)'
+
+      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 backups of the given PostgreSQL cluster,
+        otherwise retrieves a list of all PostgreSQL cluster backups.'
+        @directory = 'dbaas-postgres'
+        @required_options = [:ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        backup_list = [
+          ui.color('ID', :bold),
+          ui.color('Type', :bold),
+          ui.color('Cluster ID', :bold),
+          ui.color('Is Active', :bold),
+          ui.color('Earliest Recovery Target Time', :bold),
+          ui.color('Created Date', :bold),
+        ]
+
+        backups_api = IonoscloudDbaasPostgres::BackupsApi.new(api_client_dbaas)
+
+        if config[:cluster_id]
+          backups = backups_api.cluster_backups_get(config[:cluster_id])
+        else
+          backups = backups_api.clusters_backups_get()
+        end
+
+        backups.items.each do |backup|
+          backup_list << backup.id
+          backup_list << backup.type
+          backup_list << backup.properties.cluster_id
+          backup_list << backup.properties.is_active
+          backup_list << backup.properties.earliest_recovery_target_time
+          backup_list << backup.metadata.created_date
+        end
+
+        puts ui.list(backup_list, :uneven_columns_across, 6)
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_dbaas_postgres_cluster_create.rb

@@ -0,0 +1,158 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudDbaasPostgresClusterCreate < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud dbaas postgres cluster create (options)'
+
+      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).'
+
+      option :cores,
+              short: '-C CORES',
+              long: '--cores CORES',
+              description: 'The number of CPU cores per instance.'
+
+      option :ram,
+              short: '-r RAM',
+              long: '--ram RAM',
+              description: 'The amount of memory per instance(should be a multiple of 1024).'
+
+      option :storage_size,
+              long: '--size STORAGE_SIZE',
+              description: 'The amount of storage per instance.'
+
+      option :storage_type,
+              long: '--type STORAGE_TYPE',
+              description: 'The storage type used in your cluster.'
+
+      option :connections,
+              long: '--connections CONNECTIONS',
+              description: 'Array of VDCs to connect to your cluster.'
+
+      option :location,
+              short: '-l LOCATION',
+              long: '--location LOCATION',
+              description: 'The physical location where the cluster will be created. This will
+                            be where all of your instances live. Property cannot be modified
+                            after datacenter creation (disallowed in update requests)'
+
+      option :display_name,
+              short: '-n DISPLAY_NAME',
+              long: '--name DISPLAY_NAME',
+              description: 'The friendly name of your cluster.'
+
+      option :from_backup,
+              short: '-b FROM_BACKUP',
+              long: '--from-backup FROM_BACKUP',
+              description: 'Deprecated: backup is always enabled. Enables automatic backups 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  :synchronization_mode,
+               short: '-s SYNCHRONIZATION_MODE',
+               long: '--synchronization-mode SYNCHRONIZATION_MODE',
+               description: 'Represents different modes of replication'
+
+      option :username,
+              long: '--db-user DB_USERNAME',
+              description: 'The username for the initial postgres user.
+                            Some system usernames are restricted (e.g. "postgres", "admin", "standby")'
+
+      option :password,
+              long: '--db-password DB_PASSWORD',
+              description: 'The username for the initial postgres user.'
+
+      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 =
+        'Creates a new PostgreSQL cluster.
+        If the `fromBackup` field is populated, the new cluster will be created
+        based on the given backup.'
+        @directory = 'dbaas-postgres'
+        @required_options = [
+          :postgres_version, :instances, :cores, :ram, :storage_size, :storage_type,
+          :connections, :location, :display_name, :synchronization_mode, :username, :password, :ionoscloud_username, :ionoscloud_password,
+        ]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        print "#{ui.color('Creating cluster...', :magenta)}"
+
+        config[:connections] = JSON[config[:connections]] if config[:connections] && config[:connections].instance_of?(String)
+
+        config[:connections] = config[:connections].map do
+          |connection|
+          IonoscloudDbaasPostgres::Connection.new(
+            datacenter_id: connection['datacenter_id'],
+            lan_id: String(connection['lan_id']),
+            cidr: connection['cidr'],
+          )
+        end if config[:connections]
+
+        clusters_api = IonoscloudDbaasPostgres::ClustersApi.new(api_client_dbaas)
+
+        cluster_properties = IonoscloudDbaasPostgres::CreateClusterProperties.new(
+          postgres_version: config[:postgres_version],
+          instances: Integer(config[:instances]),
+          cores: Integer(config[:cores]),
+          ram: Integer(config[:ram]),
+          storage_size: Integer(config[:storage_size]),
+          storage_type: config[:storage_type],
+          connections: config[:connections],
+          location: config[:location],
+          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,
+          credentials: IonoscloudDbaasPostgres::DBUser.new(
+            username: config[:username],
+            password: config[:password],
+          ),
+          synchronization_mode: config[:synchronization_mode],
+          from_backup: IonoscloudDbaasPostgres::CreateRestoreRequest.new(
+            backup_id: config[:backup_id],
+            recovery_target_time: config[:recovery_target_time],
+          ),
+        )
+
+        cluster_request = IonoscloudDbaasPostgres::CreateClusterRequest.new()
+        cluster_request.properties = cluster_properties
+
+        cluster, _, headers  = clusters_api.clusters_post_with_http_info(cluster_request)
+
+        print_cluster(cluster)
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_dbaas_postgres_cluster_delete.rb

@@ -0,0 +1,49 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudDbaasPostgresClusterDelete < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud dbaas postgres cluster delete CLUSTER_ID [CLUSTER_ID]'
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Delete a PostgreSQL cluster.'
+        @directory = 'dbaas-postgres'
+        @required_options = [:ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        clusters_api = IonoscloudDbaasPostgres::ClustersApi.new(api_client_dbaas)
+
+        @name_args.each do |cluster_id|
+          begin
+            cluster = clusters_api.clusters_find_by_id(cluster_id)
+          rescue IonoscloudDbaasPostgres::ApiError => err
+            raise err unless err.code == 404
+            ui.error("Cluster ID #{cluster_id} not found. Skipping.")
+            next
+          end
+
+          print_cluster(cluster)
+          puts "\n"
+
+          begin
+            confirm('Do you really want to delete this cluster')
+          rescue SystemExit => exc
+            next
+          end
+
+          _, _, headers = clusters_api.clusters_delete_with_http_info(cluster_id)
+          ui.warn("Deleted Cluster #{cluster.id}.")
+        end
+      end
+    end
+  end
+end

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