knife-ionoscloud 6.1.2 → 6.2.0

data/lib/chef/knife/ionoscloud_targetgroup_target_remove.rb

@@ -0,0 +1,66 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudTargetgroupTargetRemove < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud targetgroup target remove (options)'
+
+      option :target_group_id,
+              short: '-T TARGET_GROUP_ID',
+              long: '--target-group-id TARGET_GROUP_ID',
+              description: 'ID of the Target Group'
+
+      option :ip,
+              long: '--ip IP',
+              description: 'IP of a balanced target VM'
+
+      option :port,
+              short: '-p PORT',
+              long: '--port PORT',
+              description: 'Port of the balanced target service. (range: 1 to 65535)'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Removes a Target from a Target Group if it exists.'
+        @directory = 'application-loadbalancer'
+        @required_options = [:target_group_id, :ip, :port]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        target_groups_api = Ionoscloud::TargetGroupsApi.new(api_client)
+
+        target_group = target_groups_api.targetgroups_find_by_target_group_id(config[:target_group_id])
+
+        existing_target = target_group.properties.targets.find do |target|
+          target.ip == config[:ip] && target.port == Integer(config[:port])
+        end
+
+        if existing_target
+          target_group.properties.targets = target_group.properties.targets.reject do |target|
+            target.ip == config[:ip] && target.port == Integer(config[:port])
+          end
+
+          _, _, headers = target_groups_api.targetgroups_patch_with_http_info(config[:target_group_id], target_group.properties)
+          print "#{ui.color('Removing the Target from the Target Group...', :magenta)}"
+          dot = ui.color('.', :magenta)
+          api_client.wait_for { print dot; is_done? get_request_id headers }
+
+          target_group = target_groups_api.targetgroups_find_by_target_group_id(config[:target_group_id])
+        else
+          ui.warn("Specified target does not exist (#{config[:ip]}:#{config[:port]}).")
+        end
+
+        print_target_group(target_group)
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_targetgroup_update.rb

@@ -0,0 +1,151 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudTargetgroupUpdate < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud targetgroup update (options)'
+
+      option :target_group_id,
+              short: '-T TARGET_GROUP_ID',
+              long: '--target-group-id TARGET_GROUP_ID',
+              description: 'ID of the Target Group'
+
+      option :name,
+              short: '-n NAME',
+              long: '--name NAME',
+              description: 'Name of the server'
+
+      option :algorithm,
+              short: '-a ALGORITHM',
+              long: '--algorithm ALGORITHM',
+              description: 'Algorithm for the balancing. One of ["ROUND_ROBIN", "LEAST_CONNECTION", "RANDOM", "SOURCE_IP"]'
+
+      option :protocol,
+              short: '-p PROTOCOL',
+              long: '--protocol PROTOCOL',
+              description: 'Protocol of the balancing. One of ["HTTP"]'
+
+      option :check_timeout,
+              long: '--check-timeout CHECK_TIMEOUT',
+              description: 'It specifies the time (in milliseconds) for a target VM in this pool to answer the check. If '\
+              'a target VM has CheckInterval set and CheckTimeout is set too, then the smaller value of the two is used '\
+              'after the TCP connection is established.'
+
+      option :check_interval,
+              long: '--check-interval check_interval',
+              description: 'It specifies the maximum time (in milliseconds) to wait for a connection attempt to a target '\
+              'VM to succeed. If unset, the default of 5 seconds will be used.'
+
+      option :retries,
+              short: '-r RETRIES',
+              long: '--retries RETRIES',
+              description: 'Retries specifies the number of retries to perform on a target VM after a connection failure. '\
+              'If unset, the default value of 3 will be used. (valid range: [0, 65535])'
+
+      option :path,
+              long: '--path PATH',
+              description: 'The path for the HTTP health check; default: /.'
+
+      option :method,
+              short: '-m METHOD',
+              long: '--method METHOD',
+              description: 'The method for the HTTP health check.'
+
+      option :match_type,
+              long: '--match-type MATCH_TYPE',
+              description: 'The method for the HTTP health check. One of ["STATUS_CODE", "RESPONSE_BODY"].'
+
+      option :response,
+              long: '--response RESPONSE',
+              description: 'The response returned by the request.'
+
+      option :regex,
+              long: '--regex REGEX',
+              description: 'The regex used.'
+
+      option :negate,
+              long: '--negate',
+              description: 'Whether to negate or not.'
+
+      option :targets,
+              long: '--targets',
+              description: 'Array of TargetGroup targets.'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Updates information about a Ionoscloud Application LoadBalancer.'
+        @directory = 'application-loadbalancer'
+        @required_options = [:target_group_id]
+        @updatable_fields = [
+          :name, :algorithm, :protocol, :check_timeout, :connect_timeout, :target_timeout,
+          :retries, :path, :method, :match_type, :response, :regex, :negate, :targets,
+        ]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        target_groups_api = Ionoscloud::TargetGroupsApi.new(api_client)
+
+        if @updatable_fields.map { |el| config[el] }.any?
+          print "#{ui.color('Updating Target Group...', :magenta)}"
+
+          unless config[:targets].nil?
+            config[:targets] = JSON[config[:targets]] if config[:targets].instance_of?(String)
+
+            config[:targets].map! do |target|
+              Ionoscloud::TargetGroupTarget.new(
+                ip: target['ip'],
+                port: Integer(target['port']),
+                weight: Integer(target['weight']),
+                health_check_enabled: target['health_check_enabled'],
+                maintenance_enabled: target['maintenance_enabled'],
+              )
+            end
+          end
+
+          send_http_health_check = config[:path] || config[:method] || config[:match_type] || config[:response] || config[:regex] || config[:negate]
+
+          target_group_properties = {
+            name: config[:name],
+            algorithm: config[:algorithm],
+            protocol: config[:protocol],
+            targets: config[:targets],
+            health_check: Ionoscloud::TargetGroupHealthCheck.new(
+              check_timeout: config[:check_timeout],
+              check_interval: config[:check_interval],
+              retries: config[:retries],
+            ),
+            http_health_check: send_http_health_check ? Ionoscloud::TargetGroupHttpHealthCheck.new(
+              path: config[:path],
+              method: config[:method],
+              match_type: config[:match_type],
+              response: config[:response],
+              regex: config[:regex],
+              negate: config[:negate],
+            ) : nil,
+          }
+
+          _, _, headers  = target_groups_api.targetgroups_patch_with_http_info(
+            config[:target_group_id],
+            Ionoscloud::TargetGroupProperties.new(**target_group_properties.compact),
+          )
+
+          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_target_group(Ionoscloud::TargetGroupsApi.new(api_client).targetgroups_find_by_target_group_id(config[:target_group_id]))
+      end
+    end
+  end
+end

data/lib/knife-ionoscloud/version.rb

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

data/spec/chef/knife/ionoscloud_applicationloadbalancer_create_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+require 'ionoscloud_applicationloadbalancer_create'
+
+Chef::Knife::IonoscloudApplicationloadbalancerCreate.load_deps
+
+describe Chef::Knife::IonoscloudApplicationloadbalancerCreate do
+  before :each do
+    subject { Chef::Knife::IonoscloudApplicationloadbalancerCreate.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_post with the expected arguments and output based on what it receives' do
+      application_loadbalancer = application_loadbalancer_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        datacenter_id: 'datacenter_id',
+        name: application_loadbalancer.properties.name,
+        ips: application_loadbalancer.properties.ips.join(','),
+        listener_lan: application_loadbalancer.properties.listener_lan,
+        target_lan: application_loadbalancer.properties.target_lan,
+        lb_private_ips: application_loadbalancer.properties.lb_private_ips.join(','),
+      }.each do |key, value|
+        subject.config[key] = value
+      end
+
+      expect(subject).to receive(:puts).with("ID: #{application_loadbalancer.id}")
+      expect(subject).to receive(:puts).with("Name: #{application_loadbalancer.properties.name}")
+      expect(subject).to receive(:puts).with("Listener LAN: #{application_loadbalancer.properties.listener_lan}")
+      expect(subject).to receive(:puts).with("IPS: #{application_loadbalancer.properties.ips}")
+      expect(subject).to receive(:puts).with("Target LAN: #{application_loadbalancer.properties.target_lan}")
+      expect(subject).to receive(:puts).with("Lb Private IPS: #{application_loadbalancer.properties.lb_private_ips}")
+
+      mock_wait_for(subject)
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'POST',
+            path: "/datacenters/#{subject_config[:datacenter_id]}/applicationloadbalancers",
+            operation: :'ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_post',
+            return_type: 'ApplicationLoadBalancer',
+            body: { properties: application_loadbalancer.properties.to_hash },
+            result: application_loadbalancer,
+          },
+          {
+            method: 'GET',
+            path: "/datacenters/#{subject_config[:datacenter_id]}/applicationloadbalancers/#{application_loadbalancer.id}",
+            operation: :'ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_find_by_application_load_balancer_id',
+            return_type: 'ApplicationLoadBalancer',
+            result: application_loadbalancer,
+          },
+        ],
+      )
+
+      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)
+
+      if required_options.length > 0
+        arrays_without_one_element(required_options).each do |test_case|
+          subject.config[:ionoscloud_token] = 'token'
+          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
+end

data/spec/chef/knife/ionoscloud_applicationloadbalancer_delete_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+require 'ionoscloud_applicationloadbalancer_delete'
+
+Chef::Knife::IonoscloudApplicationloadbalancerDelete.load_deps
+
+describe Chef::Knife::IonoscloudApplicationloadbalancerDelete do
+  before :each do
+    subject { Chef::Knife::IonoscloudApplicationloadbalancerDelete.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_delete when the ID is valid' do
+      application_loadbalancer = application_loadbalancer_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        datacenter_id: 'datacenter_id',
+        yes: true,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+      subject.name_args = [application_loadbalancer.id]
+
+      expect(subject).to receive(:puts).with("ID: #{application_loadbalancer.id}")
+      expect(subject).to receive(:puts).with("Name: #{application_loadbalancer.properties.name}")
+      expect(subject).to receive(:puts).with("Listener LAN: #{application_loadbalancer.properties.listener_lan}")
+      expect(subject).to receive(:puts).with("IPS: #{application_loadbalancer.properties.ips}")
+      expect(subject).to receive(:puts).with("Target LAN: #{application_loadbalancer.properties.target_lan}")
+      expect(subject).to receive(:puts).with("Lb Private IPS: #{application_loadbalancer.properties.lb_private_ips}")
+      expect(subject).to receive(:puts).with("Rules: #{subject.get_application_loadbalancer_extended_properties(application_loadbalancer)}")
+
+      expect(subject.ui).to receive(:warn).with("Deleted Application Load balancer #{application_loadbalancer.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: "/datacenters/#{subject_config[:datacenter_id]}/applicationloadbalancers/#{application_loadbalancer.id}",
+            operation: :'ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_find_by_application_load_balancer_id',
+            return_type: 'ApplicationLoadBalancer',
+            result: application_loadbalancer,
+          },
+          {
+            method: 'DELETE',
+            path: "/datacenters/#{subject_config[:datacenter_id]}/applicationloadbalancers/#{application_loadbalancer.id}",
+            operation: :'ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_delete',
+          },
+        ],
+      )
+
+      expect { subject.run }.not_to raise_error(Exception)
+    end
+
+    it 'should not call ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_delete when the ID is not valid' do
+      application_loadbalancer_id = 'invalid_id'
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        datacenter_id: 'datacenter_id',
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+      subject.name_args = [application_loadbalancer_id]
+
+      expect(subject.ui).to receive(:error).with("Application Load balancer ID #{application_loadbalancer_id} not found. Skipping.")
+
+      expect(subject.api_client).not_to receive(:wait_for)
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: "/datacenters/#{subject_config[:datacenter_id]}/applicationloadbalancers/#{application_loadbalancer_id}",
+            operation: :'ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_find_by_application_load_balancer_id',
+            return_type: 'ApplicationLoadBalancer',
+            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)
+
+      if required_options.length > 0
+        arrays_without_one_element(required_options).each do |test_case|
+          subject.config[:ionoscloud_token] = 'token'
+          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
+end

data/spec/chef/knife/ionoscloud_applicationloadbalancer_get_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+require 'ionoscloud_applicationloadbalancer_get'
+
+Chef::Knife::IonoscloudApplicationloadbalancerGet.load_deps
+
+describe Chef::Knife::IonoscloudApplicationloadbalancerGet do
+  before :each do
+    subject { Chef::Knife::IonoscloudApplicationloadbalancerGet.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call LoadBalancersApi.datacenters_applicationloadbalancers_get' do
+      application_load_balancer = application_loadbalancer_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        datacenter_id: 'datacenter_id',
+        application_loadbalancer_id: application_load_balancer.id,
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      expect(subject).to receive(:puts).with("ID: #{application_load_balancer.id}")
+      expect(subject).to receive(:puts).with("Name: #{application_load_balancer.properties.name}")
+      expect(subject).to receive(:puts).with("Listener LAN: #{application_load_balancer.properties.listener_lan}")
+      expect(subject).to receive(:puts).with("IPS: #{application_load_balancer.properties.ips}")
+      expect(subject).to receive(:puts).with("Target LAN: #{application_load_balancer.properties.target_lan}")
+      expect(subject).to receive(:puts).with("Lb Private IPS: #{application_load_balancer.properties.lb_private_ips}")
+      expect(subject).to receive(:puts).with("Rules: #{subject.get_application_loadbalancer_extended_properties(application_load_balancer)}")
+
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: "/datacenters/#{subject_config[:datacenter_id]}/applicationloadbalancers/#{subject_config[:application_loadbalancer_id]}",
+            operation: :'ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_find_by_application_load_balancer_id',
+            return_type: 'ApplicationLoadBalancer',
+            result: application_load_balancer,
+          },
+        ],
+      )
+
+      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)
+
+      if required_options.length > 0
+        arrays_without_one_element(required_options).each do |test_case|
+          subject.config[:ionoscloud_token] = 'token'
+          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
+end

data/spec/chef/knife/ionoscloud_applicationloadbalancer_list_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+require 'ionoscloud_applicationloadbalancer_list'
+
+Chef::Knife::IonoscloudApplicationloadbalancerList.load_deps
+
+describe Chef::Knife::IonoscloudApplicationloadbalancerList do
+  before :each do
+    subject { Chef::Knife::IonoscloudApplicationloadbalancerList.new }
+
+    allow(subject).to receive(:puts)
+    allow(subject).to receive(:print)
+  end
+
+  describe '#run' do
+    it 'should call ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_get' do
+      application_loadbalancers = application_loadbalancers_mock
+      subject_config = {
+        ionoscloud_username: 'email',
+        ionoscloud_password: 'password',
+        datacenter_id: 'datacenter_id',
+      }
+
+      subject_config.each { |key, value| subject.config[key] = value }
+
+      application_loadbalancer_list = [
+        subject.ui.color('ID', :bold),
+        subject.ui.color('Name', :bold),
+        subject.ui.color('Listener LAN', :bold),
+        subject.ui.color('Target LAN', :bold),
+        subject.ui.color('Rules', :bold),
+        subject.ui.color('IPS', :bold),
+        subject.ui.color('Private IPS', :bold),
+        application_loadbalancers.items.first.id,
+        application_loadbalancers.items.first.properties.name,
+        application_loadbalancers.items.first.properties.listener_lan,
+        application_loadbalancers.items.first.properties.target_lan,
+        application_loadbalancers.items.first.entities.forwardingrules.items.length,
+        application_loadbalancers.items.first.properties.ips,
+        application_loadbalancers.items.first.properties.lb_private_ips,
+        application_loadbalancers.items[1].id,
+        application_loadbalancers.items[1].properties.name,
+        application_loadbalancers.items[1].properties.listener_lan,
+        application_loadbalancers.items[1].properties.target_lan,
+        application_loadbalancers.items[1].entities.forwardingrules.items.length,
+        application_loadbalancers.items[1].properties.ips,
+        application_loadbalancers.items[1].properties.lb_private_ips,
+      ]
+
+      expect(subject.ui).to receive(:list).with(application_loadbalancer_list, :uneven_columns_across, 7)
+
+      mock_call_api(
+        subject,
+        [
+          {
+            method: 'GET',
+            path: "/datacenters/#{subject_config[:datacenter_id]}/applicationloadbalancers",
+            operation: :'ApplicationLoadBalancersApi.datacenters_applicationloadbalancers_get',
+            return_type: 'ApplicationLoadBalancers',
+            result: application_loadbalancers,
+          },
+        ],
+      )
+
+      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)
+
+      if required_options.length > 0
+        arrays_without_one_element(required_options).each do |test_case|
+          subject.config[:ionoscloud_token] = 'token'
+          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
+end