knife-ionoscloud 5.1.2 → 6.0.0.alpha.1

data/lib/chef/knife/ionoscloud_nodepool_update.rb

@@ -1,124 +0,0 @@
-require_relative 'ionoscloud_base'
-
-class Chef
-  class Knife
-    class IonoscloudNodepoolUpdate < Knife
-      include Knife::IonoscloudBase
-
-      banner 'knife ionoscloud nodepool update (options)'
-
-      option :cluster_id,
-              short: '-C CLUSTER_ID',
-              long: '--cluster-id CLUSTER_ID',
-              description: 'ID of the Kubernetes cluster'
-
-      option :nodepool_id,
-              short: '-P NODEPOOL_ID',
-              long: '--nodepool-id NODEPOOL_ID',
-              description: 'ID of the Kubernetes nodepool'
-
-      option :k8s_version,
-              short: '-v VERSION',
-              long: '--version VERSION',
-              description: 'The version for the Kubernetes cluster.'
-
-      option :maintenance_day,
-              long: '--maintenance-day MAINTENANCE_DAY',
-              description: 'Day Of the week when to perform the maintenance.'
-
-      option :maintenance_time,
-              short: '-t MAINTENANCE_TIME',
-              long: '--maintenance-time MAINTENANCE_TIME',
-              description: 'Time Of the day when to perform the maintenance.'
-
-      option :node_count,
-              short: '-c NODE_COUNT',
-              long: '--node-count NODE_COUNT',
-              description: 'The number of worker nodes that the node pool should contain. Min 2, Max: Determined by the resource availability.'
-
-      option :min_node_count,
-              long: '--min-node-count MIN_NODE_COUNT',
-              description: 'The minimum number of worker nodes that the managed node group can scale in'
-
-      option :max_node_count,
-              long: '--max-node-count MAX_NODE_COUNT',
-              description: 'The maximum number of worker nodes that the managed node pool can scale-out.'
-
-      option :lans,
-              long: '--lans LAN_ID [LAN_ID]',
-              description: 'An array of additional private LANs attached to worker nodes'
-
-      option :public_ips,
-              long: '--ips PUBLIC_IP [PUBLIC_IP]',
-              description: 'Optional array of reserved public IP addresses to be used by the nodes. '\
-              'IPs must be from same location as the data center used for the node pool. The array '\
-              'must contain one extra IP than maximum number of nodes could be. (nodeCount+1 if fixed '\
-              'node amount or maxNodeCount+1 if auto scaling is used) The extra provided IP Will be used during rebuilding of nodes.'
-
-      option :labels,
-              long: '--labels LABEL [LABEL]',
-              description: 'map of labels attached to node pool'
-
-      option :annotations,
-              long: '--annotations ANNOTATION [ANNOTATION]',
-              description: 'map of annotations attached to node pool'
-
-      attr_reader :description, :required_options
-
-      def initialize(args = [])
-        super(args)
-        @description =
-        'Updates information about a Ionoscloud K8s Nodepool.'
-        @required_options = [:cluster_id, :nodepool_id, :ionoscloud_username, :ionoscloud_password]
-        @updatable_fields = [
-          :k8s_version, :node_count, :public_ips, :lans, :maintenance_day, :maintenance_time,
-          :min_node_count, :max_node_count, :labels, :annotations,
-        ]
-      end
-
-      def run
-        $stdout.sync = true
-        handle_extra_config
-        validate_required_params(@required_options, config)
-
-        config[:public_ips] = config[:public_ips].split(',') if config[:public_ips] && config[:public_ips].instance_of?(String)
-        config[:lans] = config[:lans].split(',') if config[:lans] && config[:lans].instance_of?(String)
-        config[:labels] = JSON[config[:labels]] if config[:labels] && config[:labels].instance_of?(String)
-        config[:annotations] = JSON[config[:annotations]] if config[:annotations] && config[:annotations].instance_of?(String)
-
-        kubernetes_api = Ionoscloud::KubernetesApi.new(api_client)
-
-        if @updatable_fields.map { |el| config[el] }.any?
-          print "#{ui.color('Updating K8s Nodepool...', :magenta)}"
-
-          nodepool = kubernetes_api.k8s_nodepools_find_by_id(config[:cluster_id], config[:nodepool_id])
-
-          new_nodepool = Ionoscloud::KubernetesNodePoolForPut.new(
-            properties: Ionoscloud::KubernetesNodePoolPropertiesForPut.new(
-              k8s_version: config.key?(:k8s_version) ? config[:k8s_version] : nodepool.properties.k8s_version,
-              node_count: config.key?(:node_count) ? config[:node_count] : nodepool.properties.node_count,
-              public_ips: config.key?(:public_ips) ? config[:public_ips] : nodepool.properties.public_ips,
-              labels: config.key?(:labels) ? config[:labels] : nodepool.properties.labels,
-              annotations: config.key?(:annotations) ? config[:annotations] : nodepool.properties.annotations,
-              lans: config.key?(:lans) ? config[:lans].map! { |lan| { id: Integer(lan) } } : nodepool.properties.lans,
-              maintenance_window: Ionoscloud::KubernetesMaintenanceWindow.new(
-                day_of_the_week: config.key?(:maintenance_day) ? config[:maintenance_day] : nodepool.properties.maintenance_window.day_of_the_week,
-                time: config.key?(:maintenance_time) ? config[:maintenance_time] : nodepool.properties.maintenance_window.time,
-              ),
-              auto_scaling: Ionoscloud::KubernetesAutoScaling.new(
-                min_node_count: config.key?(:min_node_count) ? config[:min_node_count] : nodepool.properties.auto_scaling.min_node_count,
-                max_node_count: config.key?(:max_node_count) ? config[:max_node_count] : nodepool.properties.auto_scaling.max_node_count,
-              ),
-            ),
-          )
-
-          kubernetes_api.k8s_nodepools_put(config[:cluster_id], config[:nodepool_id], new_nodepool)
-        else
-          ui.warn("Nothing to update, please set one of the attributes #{@updatable_fields}.")
-        end
-
-        print_k8s_nodepool(kubernetes_api.k8s_nodepools_find_by_id(config[:cluster_id], config[:nodepool_id]))
-      end
-    end
-  end
-end

data/lib/chef/knife/ionoscloud_pcc_get.rb

@@ -1,33 +0,0 @@
-require_relative 'ionoscloud_base'
-
-class Chef
-  class Knife
-    class IonoscloudPccGet < Knife
-      include Knife::IonoscloudBase
-
-      banner 'knife ionoscloud pcc get (options)'
-
-      option :pcc_id,
-              short: '-P PRIVATE_CROSS_CONNECT_ID',
-              long: '--pcc-id PRIVATE_CROSS_CONNECT_ID',
-              description: 'ID of the Private Cross Connect'
-
-      attr_reader :description, :required_options
-
-      def initialize(args = [])
-        super(args)
-        @description =
-        'Retrieves information about a Ionoscloud Private Cross Connect.'
-        @required_options = [:pcc_id, :ionoscloud_username, :ionoscloud_password]
-      end
-
-      def run
-        $stdout.sync = true
-        handle_extra_config
-        validate_required_params(@required_options, config)
-
-        print_pcc(Ionoscloud::PrivateCrossConnectApi.new(api_client).pccs_find_by_id(config[:pcc_id]))
-      end
-    end
-  end
-end

data/lib/chef/knife/ionoscloud_pcc_update.rb

@@ -1,63 +0,0 @@
-require_relative 'ionoscloud_base'
-
-class Chef
-  class Knife
-    class IonoscloudPccUpdate < Knife
-      include Knife::IonoscloudBase
-
-      banner 'knife ionoscloud pcc update (options)'
-
-      option :pcc_id,
-              short: '-P PRIVATE_CROSS_CONNECT_ID',
-              long: '--pcc-id PRIVATE_CROSS_CONNECT_ID',
-              description: 'ID of the Private Cross Connect'
-
-      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'
-
-      attr_reader :description, :required_options
-
-      def initialize(args = [])
-        super(args)
-        @description =
-        'Updates information about a Ionoscloud Private Cross Connect. In order to add LANs to the Private Cross Connect one should'\
-        'update the LAN and change the pcc property using the ```text\knife ionscloud lan update\n``` command.'
-        @required_options = [:pcc_id, :ionoscloud_username, :ionoscloud_password]
-        @updatable_fields = [:name, :description]
-      end
-
-      def run
-        $stdout.sync = true
-        handle_extra_config
-        validate_required_params(@required_options, config)
-
-        pcc_api = Ionoscloud::PrivateCrossConnectApi.new(api_client)
-
-        if @updatable_fields.map { |el| config[el] }.any?
-          print "#{ui.color('Updating Private Cross Connect...', :magenta)}"
-
-          _, _, headers  = pcc_api.pccs_patch_with_http_info(
-            config[:pcc_id],
-            Ionoscloud::PrivateCrossConnectProperties.new(
-              name: config[:name],
-              description: config[:description],
-            )
-          )
-
-          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_pcc(pcc_api.pccs_find_by_id(config[:pcc_id]))
-      end
-    end
-  end
-end

data/lib/chef/knife/ionoscloud_request_get.rb

@@ -1,40 +0,0 @@
-require_relative 'ionoscloud_base'
-
-class Chef
-  class Knife
-    class IonoscloudRequestGet < Knife
-      include Knife::IonoscloudBase
-
-      banner 'knife ionoscloud request get (options)'
-
-      option :request_id,
-              short: '-R REQUEST_ID',
-              long: '--request-id REQUEST_ID',
-              description: 'The ID of the Request.'
-
-      attr_reader :description, :required_options
-
-      def initialize(args = [])
-        super(args)
-        @description =
-        'Retrieves the properties of a specific request based on the supplied request id.'
-        @required_options = [:request_id, :ionoscloud_username, :ionoscloud_password]
-      end
-
-      def run
-        $stdout.sync = true
-        handle_extra_config
-        validate_required_params(@required_options, config)
-
-        request = Ionoscloud::RequestApi.new(api_client).requests_find_by_id(config[:request_id], depth: 1)
-        puts "#{ui.color('ID', :cyan)}: #{request.id}"
-        puts "#{ui.color('Status', :cyan)}: #{request.metadata.request_status.metadata.status}"
-        puts "#{ui.color('Method', :cyan)}: #{request.properties.method}"
-        puts "#{ui.color('URL', :cyan)}: #{request.properties.url}"
-        puts "#{ui.color('Targets', :cyan)}: #{request.metadata.request_status.metadata.targets.map { |target| [target.target.id, target.target.type] }.to_s}"
-        puts "#{ui.color('Body', :cyan)}: #{request.properties.body}"
-        puts "#{ui.color('Headers', :cyan)}: #{request.properties.headers}"
-      end
-    end
-  end
-end

data/lib/chef/knife/ionoscloud_s3key_get.rb

@@ -1,38 +0,0 @@
-require_relative 'ionoscloud_base'
-
-class Chef
-  class Knife
-    class IonoscloudS3keyGet < Knife
-      include Knife::IonoscloudBase
-
-      banner 'knife ionoscloud s3key get (options)'
-
-      option :user_id,
-              short: '-u USER_ID',
-              long: '--user USER_ID',
-              description: 'The ID of the user'
-
-      option :s3_key_id,
-              short: '-S S3KEY_ID',
-              long: '--s3-key S3KEY_ID',
-              description: 'The ID of the S3 Key.'
-
-      attr_reader :description, :required_options
-
-      def initialize(args = [])
-        super(args)
-        @description =
-        'Retrieves the properties of an S3 Key.'
-        @required_options = [:user_id, :s3_key_id, :ionoscloud_username, :ionoscloud_password]
-      end
-
-      def run
-        $stdout.sync = true
-        handle_extra_config
-        validate_required_params(@required_options, config)
-
-        print_s3key(Ionoscloud::UserManagementApi.new(api_client).um_users_s3keys_find_by_key_id(config[:user_id], config[:s3_key_id]))
-      end
-    end
-  end
-end

data/lib/chef/knife/ionoscloud_server_update.rb

@@ -1,97 +0,0 @@
-require_relative 'ionoscloud_base'
-
-class Chef
-  class Knife
-    class IonoscloudServerUpdate < Knife
-      include Knife::IonoscloudBase
-
-      banner 'knife ionoscloud server update (options)'
-
-      option :datacenter_id,
-              short: '-D DATACENTER_ID',
-              long: '--datacenter-id DATACENTER_ID',
-              description: 'ID of the data center'
-
-      option :server_id,
-              short: '-S SERVER_ID',
-              long: '--server-id SERVER_ID',
-              description: 'The ID of the server to which the NIC is assigned'
-
-      option :name,
-              short: '-n NAME',
-              long: '--name NAME',
-              description: 'Name of the server'
-
-      option :cores,
-              short: '-C CORES',
-              long: '--cores CORES',
-              description: 'The number of processor cores'
-
-      option :cpu_family,
-              short: '-f CPU_FAMILY',
-              long: '--cpu-family CPU_FAMILY',
-              description: 'The family of the CPU (INTEL_XEON or AMD_OPTERON)'
-
-      option :ram,
-              short: '-r RAM',
-              long: '--ram RAM',
-              description: 'The amount of RAM in MB'
-
-      option :availability_zone,
-              short: '-a AVAILABILITY_ZONE',
-              long: '--availability-zone AVAILABILITY_ZONE',
-              description: 'The availability zone of the server'
-
-      option :boot_volume,
-              long: '--boot-volume VOLUME_ID',
-              description: 'Reference to a volume used for booting'
-
-      option :boot_cdrom,
-              long: '--boot-cdrom CDROM_ID',
-              description: 'Reference to a CD-ROM used for booting'
-
-      attr_reader :description, :required_options
-
-      def initialize(args = [])
-        super(args)
-        @description =
-        'Updates information about a Ionoscloud Server.'
-        @required_options = [:datacenter_id, :server_id, :ionoscloud_username, :ionoscloud_password]
-        @updatable_fields = [:name, :cores, :cpu_family, :ram, :availability_zone, :boot_volume, :boot_cdrom]
-      end
-
-      def run
-        $stdout.sync = true
-        handle_extra_config
-        validate_required_params(@required_options, config)
-
-        server_api = Ionoscloud::ServerApi.new(api_client)
-
-        if @updatable_fields.map { |el| config[el] }.any?
-          print "#{ui.color('Updating Server...', :magenta)}"
-
-          _, _, headers  = server_api.datacenters_servers_patch_with_http_info(
-            config[:datacenter_id],
-            config[:server_id],
-            Ionoscloud::ServerProperties.new(
-              name: config[:name],
-              cores: config[:cores],
-              cpu_family: config[:cpu_family],
-              ram: config[:ram],
-              availability_zone: config[:availability_zone],
-              boot_cdrom: config.key?(:boot_cdrom) ? { id: config[:boot_cdrom] } : nil,
-              boot_volume: config.key?(:boot_volume) ? { id: config[:boot_volume] } : 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_server(server_api.datacenters_servers_find_by_id(config[:datacenter_id], config[:server_id]))
-      end
-    end
-  end
-end

data/lib/chef/knife/ionoscloud_share_get.rb

@@ -1,38 +0,0 @@
-require_relative 'ionoscloud_base'
-
-class Chef
-  class Knife
-    class IonoscloudShareGet < Knife
-      include Knife::IonoscloudBase
-
-      banner 'knife ionoscloud share get (options)'
-
-      option :group_id,
-              short: '-G GROUP_ID',
-              long: '--group-id GROUP_ID',
-              description: 'ID of the group.'
-
-      option :resource_id,
-              short: '-R RESOURCE_ID',
-              long: '--resource-id RESOURCE_ID',
-              description: 'The ID of the resource.'
-
-      attr_reader :description, :required_options
-
-      def initialize(args = [])
-        super(args)
-        @description =
-        'Retrieves the attributes of a given Group Share.'
-        @required_options = [:group_id, :resource_id, :ionoscloud_username, :ionoscloud_password]
-      end
-
-      def run
-        $stdout.sync = true
-        handle_extra_config
-        validate_required_params(@required_options, config)
-
-        print_share(Ionoscloud::UserManagementApi.new(api_client).um_groups_shares_find_by_resource_id(config[:group_id], config[:resource_id]))
-      end
-    end
-  end
-end

data/lib/chef/knife/ionoscloud_share_update.rb

@@ -1,70 +0,0 @@
-require_relative 'ionoscloud_base'
-
-class Chef
-  class Knife
-    class IonoscloudShareUpdate < Knife
-      include Knife::IonoscloudBase
-
-      banner 'knife ionoscloud share update (options)'
-
-      option :group_id,
-              short: '-G GROUP_ID',
-              long: '--group-id GROUP_ID',
-              description: 'ID of the group.'
-
-      option :resource_id,
-              short: '-R RESOURCE_ID',
-              long: '--resource-id RESOURCE_ID',
-              description: 'The ID of the resource.'
-
-      option :edit_privilege,
-              long: '--edit EDIT_PRIVILEGE',
-              description: 'The group has permission to edit privileges on this resource.'
-
-      option :share_privilege,
-              short: '-s SHARE_PRIVILEGE',
-              long: '--share SHARE_PRIVILEGE',
-              description: 'The group has permission to share this resource.'
-
-      attr_reader :description, :required_options
-
-      def initialize(args = [])
-        super(args)
-        @description =
-        'Updates information about a Ionoscloud Group Share.'
-        @required_options = [:group_id, :resource_id, :ionoscloud_username, :ionoscloud_password]
-        @updatable_fields = [:edit_privilege, :share_privilege]
-      end
-
-      def run
-        $stdout.sync = true
-        handle_extra_config
-        validate_required_params(@required_options, config)
-
-        user_management_api = Ionoscloud::UserManagementApi.new(api_client)
-
-        if @updatable_fields.map { |el| config[el] }.any?
-          print "#{ui.color('Updating Group Share...', :magenta)}"
-
-          share = user_management_api.um_groups_shares_find_by_resource_id(config[:group_id], config[:resource_id])
-
-          new_share = Ionoscloud::GroupShare.new(
-            properties: Ionoscloud::GroupShareProperties.new(
-              edit_privilege: (config.key?(:edit_privilege) ? config[:edit_privilege].to_s.downcase == 'true' : share.properties.edit_privilege),
-              share_privilege: (config.key?(:share_privilege) ? config[:share_privilege].to_s.downcase == 'true' : share.properties.share_privilege),
-            ),
-          )
-
-          _, _, headers = user_management_api.um_groups_shares_put_with_http_info(config[:group_id], config[:resource_id], new_share)
-
-          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_share(user_management_api.um_groups_shares_find_by_resource_id(config[:group_id], config[:resource_id]))
-      end
-    end
-  end
-end

data/lib/chef/knife/ionoscloud_snapshot_get.rb

@@ -1,32 +0,0 @@
-require_relative 'ionoscloud_base'
-
-class Chef
-  class Knife
-    class IonoscloudSnapshotGet < Knife
-      include Knife::IonoscloudBase
-
-      banner 'knife ionoscloud snapshot get (options)'
-
-      option :snapshot_id,
-              short: '-S SNAPSHOT_ID',
-              long: '--snapshot-id SNAPSHOT_ID',
-              description: 'ID of the group.'
-
-      attr_reader :description, :required_options
-
-      def initialize(args = [])
-        super(args)
-        @description =
-        'Retrieves the attributes of a given Snapshot.'
-        @required_options = [:snapshot_id, :ionoscloud_username, :ionoscloud_password]
-      end
-
-      def run
-        $stdout.sync = true
-        handle_extra_config
-        validate_required_params(@required_options, config)
-        print_snapshot(Ionoscloud::SnapshotApi.new(api_client).snapshots_find_by_id(config[:snapshot_id]))
-      end
-    end
-  end
-end

data/lib/chef/knife/ionoscloud_snapshot_update.rb

@@ -1,126 +0,0 @@
-require_relative 'ionoscloud_base'
-
-class Chef
-  class Knife
-    class IonoscloudSnapshotUpdate < Knife
-      include Knife::IonoscloudBase
-
-      banner 'knife ionoscloud snapshot update (options)'
-
-      option :snapshot_id,
-              short: '-S SNAPSHOT_ID',
-              long: '--snapshot-id SNAPSHOT_ID',
-              description: 'ID of the Snapshot.'
-
-      option :name,
-              short: '-n NAME',
-              long: '--name NAME',
-              description: 'Name of the server'
-
-      option :description,
-              long: '--description DESCRIPTION',
-              description: 'The number of processor cores'
-
-      option :sec_auth_protection,
-              long: '--sec-auth-protection SEC_AUTH_PROTECTION',
-              description: 'Boolean value representing if the snapshot requires extra protection e.g. two factor protection'
-
-      option :licence_type,
-              short: '-l LICENCE',
-              long: '--licence-type LICENCE',
-              description: 'The licence type of the snapshot (LINUX, WINDOWS, UNKNOWN, OTHER)'
-
-      option :cpu_hot_plug,
-              long: '--cpu-hot-plug CPU_HOT_PLUG',
-              description: 'The licence type of the snapshot (LINUX, WINDOWS, UNKNOWN, OTHER)'
-
-      option :cpu_hot_unplug,
-              long: '--cpu-hot-unplug CPU_HOT_UNPLUG',
-              description: 'The licence type of the snapshot (LINUX, WINDOWS, UNKNOWN, OTHER)'
-
-      option :ram_hot_plug,
-              long: '--ram-hot-plug RAM_HOT_PLUG',
-              description: 'The licence type of the snapshot (LINUX, WINDOWS, UNKNOWN, OTHER)'
-
-      option :ram_hot_unplug,
-              long: '--ram-hot-unplug RAM_HOT_UNPLUG',
-              description: 'The licence type of the snapshot (LINUX, WINDOWS, UNKNOWN, OTHER)'
-
-      option :nic_hot_plug,
-              long: '--nic-hot-plug NIC_HOT_PLUG',
-              description: 'The licence type of the snapshot (LINUX, WINDOWS, UNKNOWN, OTHER)'
-
-      option :nic_hot_unplug,
-              long: '--nic-hot-unplug NIC_HOT_UNPLUG',
-              description: 'The licence type of the snapshot (LINUX, WINDOWS, UNKNOWN, OTHER)'
-
-      option :disc_virtio_hot_plug,
-              long: '--disc-virtio-hot_plug DISC_VIRTIO_HOT_PLUG',
-              description: 'The licence type of the snapshot (LINUX, WINDOWS, UNKNOWN, OTHER)'
-
-      option :disc_virtio_hot_unplug,
-              long: '--disc-virtio-hot_unplug DISC_VIRTIO_HOT_UNPLUG',
-              description: 'The licence type of the snapshot (LINUX, WINDOWS, UNKNOWN, OTHER)'
-
-      option :disc_scsi_hot_plug,
-              long: '--disc-scsi-hot-plug DISC_SCSI_HOT_PLUG',
-              description: 'The licence type of the snapshot (LINUX, WINDOWS, UNKNOWN, OTHER)'
-
-      option :disc_scsi_hot_unplug,
-              long: '--disc-scsi-hot-unplug DISC_SCSI_HOT_UNPLUG',
-              description: 'The licence type of the snapshot (LINUX, WINDOWS, UNKNOWN, OTHER)'
-
-      attr_reader :description, :required_options
-
-      def initialize(args = [])
-        super(args)
-        @description =
-        'Updates information about a Ionoscloud Snapshot.'
-        @required_options = [:snapshot_id, :ionoscloud_username, :ionoscloud_password]
-        @updatable_fields = [
-          :name, :description, :sec_auth_protection, :licence_type, :cpu_hot_plug, :cpu_hot_unplug, :ram_hot_plug, :ram_hot_unplug,
-          :nic_hot_plug, :nic_hot_unplug, :disc_virtio_hot_plug, :disc_virtio_hot_unplug, :disc_scsi_hot_plug, :disc_scsi_hot_unplug,
-        ]
-      end
-
-      def run
-        $stdout.sync = true
-        handle_extra_config
-        validate_required_params(@required_options, config)
-
-        server_api = Ionoscloud::SnapshotApi.new(api_client)
-
-        if @updatable_fields.map { |el| config[el] }.any?
-          print "#{ui.color('Updating Snapshot...', :magenta)}"
-
-          _, _, headers  = server_api.snapshots_patch_with_http_info(
-            config[:snapshot_id],
-            Ionoscloud::SnapshotProperties.new(
-              name: config[:name],
-              description: config[:description],
-              sec_auth_protection: (config.key?(:sec_auth_protection) ? config[:sec_auth_protection].to_s.downcase == 'true' : nil),
-              licence_type: config[:licence_type],
-              cpu_hot_plug: (config.key?(:cpu_hot_plug) ? config[:cpu_hot_plug].to_s.downcase == 'true' : nil),
-              cpu_hot_unplug: (config.key?(:cpu_hot_unplug) ? config[:cpu_hot_unplug].to_s.downcase == 'true' : nil),
-              ram_hot_plug: (config.key?(:ram_hot_plug) ? config[:ram_hot_plug].to_s.downcase == 'true' : nil),
-              ram_hot_unplug: (config.key?(:ram_hot_unplug) ? config[:ram_hot_unplug].to_s.downcase == 'true' : nil),
-              nic_hot_plug: (config.key?(:nic_hot_plug) ? config[:nic_hot_plug].to_s.downcase == 'true' : nil),
-              nic_hot_unplug: (config.key?(:nic_hot_unplug) ? config[:nic_hot_unplug].to_s.downcase == 'true' : nil),
-              disc_virtio_hot_plug: (config.key?(:disc_virtio_hot_plug) ? config[:disc_virtio_hot_plug].to_s.downcase == 'true' : nil),
-              disc_virtio_hot_unplug: (config.key?(:disc_virtio_hot_unplug) ? config[:disc_virtio_hot_unplug].to_s.downcase == 'true' : nil),
-              disc_scsi_hot_plug: (config.key?(:disc_scsi_hot_plug) ? config[:disc_scsi_hot_plug].to_s.downcase == 'true' : nil),
-              disc_scsi_hot_unplug: (config.key?(:disc_scsi_hot_unplug) ? config[:disc_scsi_hot_unplug].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_snapshot(server_api.snapshots_find_by_id(config[:snapshot_id]))
-      end
-    end
-  end
-end