knife-ionoscloud 5.0.0.beta.1

data/lib/chef/knife/ionoscloud_volume_delete.rb

@@ -0,0 +1,67 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudVolumeDelete < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud volume delete SERVER_ID [SERVER_ID] (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'Name of the data center'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Deletes the specified volume. This will result in the volume being '\
+        'removed from your virtual data center. Please use this with caution!'
+        @required_options = [:datacenter_id, :ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        validate_required_params(@required_options, config)
+
+        volume_api = Ionoscloud::VolumeApi.new(api_client)
+
+        @name_args.each do |volume_id|
+          begin
+            volume = volume_api.datacenters_volumes_find_by_id(
+              config[:datacenter_id],
+              volume_id,
+            )
+          rescue Ionoscloud::ApiError => err
+            raise err unless err.code == 404
+            ui.error("Volume ID #{volume_id} not found. Skipping.")
+            next
+          end
+
+          msg_pair('ID', volume.id)
+          msg_pair('Name', volume.properties.name)
+          msg_pair('Size', volume.properties.size)
+          msg_pair('Bus', volume.properties.bus)
+          msg_pair('Image', volume.properties.image)
+          msg_pair('Type', volume.properties.type)
+          msg_pair('Licence Type', volume.properties.licence_type)
+          msg_pair('Zone', volume.properties.availability_zone)
+
+          begin
+            confirm('Do you really want to delete this volume')
+          rescue SystemExit => exc
+            next
+          end
+
+          _, _, headers = volume_api.datacenters_volumes_delete_with_http_info(
+            config[:datacenter_id],
+            volume_id,
+          )
+          ui.warn("Deleted Volume #{volume.id}. Request ID: #{get_request_id headers}")
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_volume_detach.rb

@@ -0,0 +1,77 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudVolumeDetach < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud volume detach VOLUME_ID [VOLUME_ID] (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'The ID of the data center'
+
+      option :server_id,
+              short: '-S SERVER_ID',
+              long: '--server-id SERVER_ID',
+              description: 'The ID of the server'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        "This will detach the volume from the server. Depending on the volume "\
+        "HotUnplug settings, this may result in the server being rebooted.\n\n"\
+        "This will NOT delete the volume from your virtual data center. You will "\
+        "need to make a separate request to delete a volume."
+        @required_options = [:datacenter_id, :server_id, :ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        validate_required_params(@required_options, config)
+
+        server_api = Ionoscloud::ServerApi.new(api_client)
+
+        @name_args.each do |volume_id|
+          begin
+            volume = server_api.datacenters_servers_volumes_find_by_id(
+              config[:datacenter_id],
+              config[:server_id],
+              volume_id,
+            )
+          rescue Ionoscloud::ApiError => err
+            raise err unless err.code == 404
+            ui.error("Volume ID #{volume_id} not found. Skipping.")
+            next
+          end
+
+          msg_pair('ID', volume.id)
+          msg_pair('Name', volume.properties.name)
+          msg_pair('Size', volume.properties.size)
+          msg_pair('Bus', volume.properties.bus)
+          msg_pair('Image', volume.properties.image)
+          msg_pair('Type', volume.properties.type)
+          msg_pair('Licence Type', volume.properties.licence_type)
+          msg_pair('Zone', volume.properties.availability_zone)
+
+          begin
+            confirm('Do you really want to detach this volume')
+          rescue SystemExit => exc
+            next
+          end
+
+          _, _, headers = server_api.datacenters_servers_volumes_delete_with_http_info(
+            config[:datacenter_id],
+            config[:server_id],
+            volume.id,
+          )
+
+          ui.msg("Detaching Volume #{volume_id} from server. Request ID: #{get_request_id headers}")
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_volume_list.rb

@@ -0,0 +1,70 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudVolumeList < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud volume list (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'The ID of the virtul data center containing the volume'
+
+      option :server_id,
+              short: '-S SERVER_ID',
+              long: '--server-id SERVER_ID',
+              description: 'The ID of the server'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'List all available volumes under a data center. '\
+        'You can also list all volumes attached to a specific server.'
+        @required_options = [:datacenter_id, :ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        validate_required_params(@required_options, config)
+
+        volume_list = [
+          ui.color('ID', :bold),
+          ui.color('Name', :bold),
+          ui.color('Size', :bold),
+          ui.color('Bus', :bold),
+          ui.color('Image', :bold),
+          ui.color('Type', :bold),
+          ui.color('Zone', :bold),
+          ui.color('Device Number', :bold)
+        ]
+
+        opts = { depth: 1 }
+
+        if config[:server_id]
+          server_api = Ionoscloud::ServerApi.new(api_client)
+          volumes = server_api.datacenters_servers_volumes_get(config[:datacenter_id], config[:server_id], opts)
+        else
+          volume_api = Ionoscloud::VolumeApi.new(api_client)
+          volumes = volume_api.datacenters_volumes_get(config[:datacenter_id], opts)
+        end
+
+        volumes.items.each do |volume|
+          volume_list << volume.id
+          volume_list << volume.properties.name
+          volume_list << volume.properties.size.to_s
+          volume_list << volume.properties.bus
+          volume_list << volume.properties.image
+          volume_list << volume.properties.type
+          volume_list << volume.properties.availability_zone
+          volume_list << volume.properties.device_number.to_s
+        end
+
+        puts ui.list(volume_list, :uneven_columns_across, 8)
+      end
+    end
+  end
+end

data/lib/knife-ionoscloud/version.rb

@@ -0,0 +1,6 @@
+module Knife
+  module Ionoscloud
+    VERSION = '5.0.0.beta.1'
+    MAJOR, MINOR, TINY = VERSION.split('.')
+  end
+end

data/spec/chef/knife/ionoscloud_backupunit_create_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+require 'ionoscloud_backupunit_create'
+
+Chef::Knife::IonoscloudBackupunitCreate.load_deps
+
+describe Chef::Knife::IonoscloudBackupunitCreate do
+  before :each do
+    subject { Chef::Knife::IonoscloudBackupunitCreate.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call BackupUnitApi.backupunits_post with the expected arguments and output based on what it receives' do
+      backupunit = backupunit_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        name: backupunit.properties.name,
+        password: backupunit.properties.password,
+        email: backupunit.properties.email,
+      }.each { |key, value| subject.config[key] = value }
+
+      expect(subject).to receive(:puts).with("ID: #{backupunit.id}")
+      expect(subject).to receive(:puts).with("Name: #{backupunit.properties.name}")
+      expect(subject).to receive(:puts).with("Email: #{backupunit.properties.email}")
+
+      mock_wait_for(subject)
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'POST',
+            path: '/backupunits',
+            operation: :'BackupUnitApi.backupunits_post',
+            return_type: 'BackupUnit',
+            body: { properties: backupunit.properties.to_hash },
+            result: backupunit,
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should not make any call if any required option is missing' do
+      required_options = subject.instance_variable_get(:@required_options)
+
+      arrays_without_one_element(required_options).each do |test_case|
+
+        test_case[:array].each { |value| subject.config[value] = 'test' }
+
+        expect(subject).to receive(:puts).with("Missing required parameters #{test_case[:removed]}")
+        expect(subject.api_client).not_to receive(:call_api)
+
+        expect { subject.run }.to raise_error(SystemExit) do |error|
+          expect(error.status).to eq(1)
+        end
+
+        required_options.each { |value| subject.config[value] = nil }
+      end
+    end
+  end
+end

data/spec/chef/knife/ionoscloud_backupunit_delete_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+require 'ionoscloud_backupunit_delete'
+
+Chef::Knife::IonoscloudBackupunitDelete.load_deps
+
+describe Chef::Knife::IonoscloudBackupunitDelete do
+  before :each do
+    subject { Chef::Knife::IonoscloudBackupunitDelete.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call BackupUnitApi.backupunits_delete when the ID is valid' do
+      backupunit = backupunit_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        yes: true,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+      subject.name_args = [backupunit.id]
+
+      expect(subject).to receive(:puts).with("ID: #{backupunit.id}")
+      expect(subject).to receive(:puts).with("Name: #{backupunit.properties.name}")
+      expect(subject).to receive(:puts).with("Email: #{backupunit.properties.email}")
+      expect(subject.ui).to receive(:warn).with("Deleted Backup unit #{backupunit.id}. Request ID: ")
+
+      expect(subject.api_client).not_to receive(:wait_for)
+      expect(subject).to receive(:get_request_id).once
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: "/backupunits/#{backupunit.id}",
+            operation: :'BackupUnitApi.backupunits_find_by_id',
+            return_type: 'BackupUnit',
+            result: backupunit,
+          },
+          {
+            method: 'DELETE',
+            path: "/backupunits/#{backupunit.id}",
+            operation: :'BackupUnitApi.backupunits_delete',
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should not call BackupUnitApi.backupunits_delete when the ID is not valid' do
+      backup_unit = 'invalid_id'
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+      subject.name_args = [backup_unit]
+
+      expect(subject.ui).to receive(:error).with("Backup unit ID #{backup_unit} not found. Skipping.")
+
+      expect(subject.api_client).not_to receive(:wait_for)
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: "/backupunits/#{backup_unit}",
+            operation: :'BackupUnitApi.backupunits_find_by_id',
+            return_type: 'BackupUnit',
+            exception: Ionoscloud::ApiError.new(code: 404),
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should not make any call if any required option is missing' do
+      required_options = subject.instance_variable_get(:@required_options)
+
+      arrays_without_one_element(required_options).each do |test_case|
+
+        test_case[:array].each { |value| subject.config[value] = 'test' }
+
+        expect(subject).to receive(:puts).with("Missing required parameters #{test_case[:removed]}")
+        expect(subject.api_client).not_to receive(:call_api)
+
+        expect { subject.run }.to raise_error(SystemExit) do |error|
+          expect(error.status).to eq(1)
+        end
+
+        required_options.each { |value| subject.config[value] = nil }
+      end
+    end
+  end
+end

data/spec/chef/knife/ionoscloud_backupunit_list_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+require 'ionoscloud_backupunit_list'
+
+Chef::Knife::IonoscloudBackupunitList.load_deps
+
+describe Chef::Knife::IonoscloudBackupunitList do
+  before :each do
+    subject { Chef::Knife::IonoscloudBackupunitList.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call KubernetesApi.k8s_get' do
+      backupunits = backupunits_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      backupunit_list = [
+        subject.ui.color('ID', :bold),
+        subject.ui.color('Name', :bold),
+        subject.ui.color('Email', :bold),
+        backupunits.items.first.id,
+        backupunits.items.first.properties.name,
+        backupunits.items.first.properties.email,
+        backupunits.items[1].id,
+        backupunits.items[1].properties.name,
+        backupunits.items[1].properties.email,
+      ]
+
+      expect(subject.ui).to receive(:list).with(backupunit_list, :uneven_columns_across, 3)
+
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: '/backupunits',
+            operation: :'BackupUnitApi.backupunits_get',
+            return_type: 'BackupUnits',
+            result: backupunits,
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should not make any call if any required option is missing' do
+      required_options = subject.instance_variable_get(:@required_options)
+
+      arrays_without_one_element(required_options).each do |test_case|
+
+        test_case[:array].each { |value| subject.config[value] = 'test' }
+
+        expect(subject).to receive(:puts).with("Missing required parameters #{test_case[:removed]}")
+        expect(subject.api_client).not_to receive(:call_api)
+
+        expect { subject.run }.to raise_error(SystemExit) do |error|
+          expect(error.status).to eq(1)
+        end
+
+        required_options.each { |value| subject.config[value] = nil }
+      end
+    end
+  end
+end