knife-ionoscloud 6.0.0.beta.2 → 6.1.1

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
 
@@ -23,8 +22,7 @@ class Chef
 
         contracts = Ionoscloud::ContractResourcesApi.new(api_client).contracts_get()
 
-        contracts.items.each do
-          |contract|
+        contracts.items.each do |contract|
           puts "#{ui.color('Contract Type', :cyan)}: #{contract.type}"
           puts "#{ui.color('Contract Owner', :cyan)}: #{contract.properties.owner}"
           puts "#{ui.color('Contract Number', :cyan)}: #{contract.properties.contract_number}"

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,
         ]
@@ -136,7 +135,7 @@ class Chef
             licence_type: config[:licence_type],
             backupunit_id: config[:backupunit_id],
             user_data: config[:user_data],
-          }.compact)
+          }.compact),
         )]
 
         nics = []
@@ -150,8 +149,8 @@ class Chef
                 dhcp: config[:dhcp],
                 lan: config[:lan],
                 firewall_type: config[:firewall_type],
-              }.compact)
-            )
+              }.compact),
+            ),
           ]
         end
 

data/lib/chef/knife/ionoscloud_datacenter_create.rb

@@ -22,16 +22,15 @@ class Chef
               long: '--location LOCATION',
               description: 'Location of the data center'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
-        "Unless you are planning to manage an existing Ionoscloud environment, "\
-        "the first step will typically involve choosing the location for a new virtual data center"\
+        'Unless you are planning to manage an existing Ionoscloud environment, '\
+        'the first step will typically involve choosing the location for a new virtual data center'\
         "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
 
@@ -39,7 +38,7 @@ class Chef
 
           begin
             confirm('Do you really want to delete this data center')
-          rescue SystemExit => exc
+          rescue SystemExit
             next
           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
@@ -45,13 +44,13 @@ class Chef
         if @updatable_fields.map { |el| config[el] }.any?
           print "#{ui.color('Updating data center...', :magenta)}"
 
-          datacenter, _, headers  = datacenter_api.datacenters_patch_with_http_info(
+          _, _, headers  = datacenter_api.datacenters_patch_with_http_info(
             config[:datacenter_id],
             Ionoscloud::DatacenterProperties.new(
               name: config[:name],
               description: config[:description],
               sec_auth_protection: (config.key?(:sec_auth_protection) ? config[:sec_auth_protection].to_s.downcase == 'true' : nil),
-            )
+            ),
           )
 
           dot = ui.color('.', :magenta)

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,162 @@
+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 :backup_location,
+              long: '--backup-location BACKUP_LOCATION',
+              description: 'The S3 location where the backups will be stored.'
+
+      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. One of [ASYNCHRONOUS, SYNCHRONOUS, STRICTLY_SYNCHRONOUS]'
+
+      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],
+          backup_location: config[:backup_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, _, _  = 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
+            next
+          end
+
+          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,55 @@
+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('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, :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