knife-ionoscloud 6.0.0.alpha.1 → 6.1.0

data/lib/chef/knife/ionoscloud_composite_server_create.rb

@@ -25,8 +25,7 @@ class Chef
       option :cpu_family,
               short: '-f CPU_FAMILY',
               long: '--cpu-family CPU_FAMILY',
-              description: 'The family of processor cores (INTEL_XEON or AMD_OPTERON)',
-              default: 'INTEL_SKYLAKE'
+              description: 'The family of processor cores (INTEL_XEON or AMD_OPTERON)'
 
       option :ram,
               short: '-r RAM',
@@ -36,8 +35,7 @@ class Chef
       option :availability_zone,
               short: '-a AVAILABILITY_ZONE',
               long: '--availability-zone AVAILABILITY_ZONE',
-              description: 'The availability zone of the server',
-              default: 'AUTO'
+              description: 'The availability zone of the server'
 
       option :volume_name,
               long: '--volume-name NAME',
@@ -114,7 +112,6 @@ class Chef
               short: '-h',
               long: '--dhcp',
               boolean: true | false,
-              default: true,
               description: 'Set to false if you wish to disable DHCP'
 
       option :lan,
@@ -125,15 +122,13 @@ class Chef
       option :firewall_type,
               long: '--firewall-type FIREWALL_TYPE',
               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',
-              default: 'INGRESS'
-
-      attr_reader :description, :required_options
+              'default value INGRESS'
 
       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,
         ]
@@ -141,10 +136,11 @@ class Chef
 
       def run
         $stdout.sync = true
+        handle_extra_config
         validate_required_params(@required_options, config)
 
-        config[:ssh_keys] = config[:ssh_keys].split(',') if config[:ssh_keys]
-        config[:ips] = config[:ips].split(',') if config[:ips]
+        config[:ssh_keys] = config[:ssh_keys].split(',') if config[:ssh_keys] && config[:ssh_keys].instance_of?(String)
+        config[:ips] = config[:ips].split(',') if config[:ips] && config[:ips].instance_of?(String)
 
         print ui.color('Creating composite server...', :magenta).to_s
 

data/lib/chef/knife/ionoscloud_contract_list.rb

@@ -7,17 +7,17 @@ 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
 
       def run
         $stdout.sync = true
+        handle_extra_config
         validate_required_params(@required_options, config)
 
         contracts = Ionoscloud::ContractResourcesApi.new(api_client).contracts_get()

data/lib/chef/knife/ionoscloud_cube_server_create.rb

@@ -24,14 +24,12 @@ class Chef
       option :cpu_family,
               short: '-f CPU_FAMILY',
               long: '--cpu-family CPU_FAMILY',
-              description: 'The family of processor cores (INTEL_XEON or AMD_OPTERON)',
-              default: 'INTEL_SKYLAKE'
+              description: 'The family of processor cores (INTEL_XEON or AMD_OPTERON)'
 
       option :availability_zone,
               short: '-a AVAILABILITY_ZONE',
               long: '--availability-zone AVAILABILITY_ZONE',
-              description: 'The availability zone of the server',
-              default: 'AUTO'
+              description: 'The availability zone of the server'
 
       option :volume_name,
               long: '--volume-name NAME',
@@ -93,7 +91,6 @@ class Chef
               short: '-h',
               long: '--dhcp',
               boolean: true | false,
-              default: true,
               description: 'Set to false if you wish to disable DHCP'
 
       option :lan,
@@ -105,15 +102,13 @@ class Chef
               short: '-t FIREWALL_TYPE',
               long: '--firewall-type FIREWALL_TYPE',
               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',
-              default: 'INGRESS'
-
-      attr_reader :description, :required_options
+              'default value INGRESS'
 
       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,
         ]
@@ -121,10 +116,11 @@ class Chef
 
       def run
         $stdout.sync = true
+        handle_extra_config
         validate_required_params(@required_options, config)
 
-        config[:ssh_keys] = config[:ssh_keys].split(',') if config[:ssh_keys]
-        config[:ips] = config[:ips].split(',') if config[:ips]
+        config[:ssh_keys] = config[:ssh_keys].split(',') if config[:ssh_keys] && config[:ssh_keys].instance_of?(String)
+        config[:ips] = config[:ips].split(',') if config[:ips] && config[:ips].instance_of?(String)
 
         print ui.color('Creating cube server...', :magenta).to_s
 

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,34 +30,33 @@ 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
 
       def run
         $stdout.sync = true
+        handle_extra_config
         validate_required_params(@required_options, config)
 
         print "#{ui.color('Creating data center...', :magenta)}"
 
         datacenter_api = Ionoscloud::DataCentersApi.new(api_client)
 
-        datacenter, _, headers  = datacenter_api.datacenters_post_with_http_info({
-          properties: {
-            name: config[:name],
-            description: config[:description],
-            location: config[:location],
-          }.compact,
-        })
+        datacenter, _, headers  = datacenter_api.datacenters_post_with_http_info(
+          Ionoscloud::Datacenter.new(
+            properties: Ionoscloud::DatacenterProperties.new(
+              name: config[:name],
+              description: config[:description],
+              location: config[:location],
+            ),
+          ),
+        )
 
         dot = ui.color('.', :magenta)
         api_client.wait_for { print dot; is_done? get_request_id headers }
 
-        puts "\n"
-        puts "#{ui.color('ID', :cyan)}: #{datacenter.id}"
-        puts "#{ui.color('Name', :cyan)}: #{datacenter.properties.name}"
-        puts "#{ui.color('Description', :cyan)}: #{datacenter.properties.description}"
-        puts "#{ui.color('Location', :cyan)}: #{datacenter.properties.location}"
-        puts 'done'
+        print_datacenter(datacenter)
       end
     end
   end

data/lib/chef/knife/ionoscloud_datacenter_delete.rb

@@ -7,19 +7,19 @@ 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
 
       def run
         $stdout.sync = true
+        handle_extra_config
         validate_required_params(@required_options, config)
 
         datacenter_api = Ionoscloud::DataCentersApi.new(api_client)
@@ -33,12 +33,7 @@ class Chef
             next
           end
 
-          msg_pair('ID', datacenter.id)
-          msg_pair('Name', datacenter.properties.name)
-          msg_pair('Description', datacenter.properties.description)
-          msg_pair('Location', datacenter.properties.location)
-          msg_pair('Version', datacenter.properties.version)
-
+          print_datacenter(datacenter)
           puts "\n"
 
           begin

data/lib/chef/knife/ionoscloud_datacenter_get.rb

@@ -0,0 +1,32 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudDatacenterGet < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud datacenter get (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'ID of the data center'
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Retrieves information about a Ionoscloud Datacenter.'
+        @directory = 'compute-engine'
+        @required_options = [:datacenter_id, :ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        print_datacenter(Ionoscloud::DataCentersApi.new(api_client).datacenters_find_by_id(config[:datacenter_id]))
+      end
+    end
+  end
+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,11 +16,13 @@ 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
 
       def run
         $stdout.sync = true
+        handle_extra_config
         validate_required_params(@required_options, config)
 
         datacenter_list = [

data/lib/chef/knife/ionoscloud_datacenter_update.rb

@@ -0,0 +1,66 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudDatacenterUpdate < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud datacenter update (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'ID of the data center'
+
+      option :name,
+              short: '-n NAME',
+              long: '--name NAME',
+              description: 'Name of the data center'
+
+      option :description,
+              long: '--description DESCRIPTION',
+              description: 'Description of the data center'
+
+      option :sec_auth_protection,
+              long: '--sec-auth-protection SEC_AUTH_PROTECTION',
+              description: 'Boolean value representing if the data center requires extra protection e.g. two factor protection'
+
+      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
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        datacenter_api = Ionoscloud::DataCentersApi.new(api_client)
+
+        if @updatable_fields.map { |el| config[el] }.any?
+          print "#{ui.color('Updating data center...', :magenta)}"
+
+          datacenter, _, 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)
+          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_datacenter(datacenter_api.datacenters_find_by_id(config[:datacenter_id]))
+      end
+    end
+  end
+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