knife-ionoscloud 5.0.0.beta.1

data/lib/chef/knife/ionoscloud_ipblock_create.rb

@@ -0,0 +1,63 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudIpblockCreate < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud ipblock create (options)'
+
+      option :location,
+              short: '-l LOCATION',
+              long: '--location LOCATION',
+              description: 'Location of the IP block (us/las, us/ewr, de/fra, de/fkb)'
+
+      option :size,
+              short: '-S INT',
+              long: '--size INT',
+              description: 'The number of IP addresses to reserve'
+
+      option :name,
+              short: '-n NAME',
+              long: '--name NAME',
+              description: 'Name of the IP block'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Reserves an IP block at a specified location that can be used by resources '\
+        'within any VDCs provisioned in that same location. An IP block consists of '\
+        'one or more static IP addresses. The IP block size (number of IP addresses) '\
+        'and location are required to reserve an IP block.'
+        @required_options = [:size, :location, :ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        validate_required_params(@required_options, config)
+
+        print "#{ui.color('Allocating IP block...', :magenta)}"
+
+        params = {
+          location: config[:location],
+          size: config[:size],
+          name: config[:name],
+        }.compact
+
+        ipblock, _, headers = Ionoscloud::IPBlocksApi.new(api_client).ipblocks_post_with_http_info({ properties: params.compact })
+
+        dot = ui.color('.', :magenta)
+        api_client.wait_for { print dot; is_done? get_request_id headers }
+
+        puts "\n"
+        puts "#{ui.color('ID', :cyan)}: #{ipblock.id}"
+        puts "#{ui.color('Name', :cyan)}: #{ipblock.properties.name}"
+        puts "#{ui.color('Location', :cyan)}: #{ipblock.properties.location}"
+        puts "#{ui.color('IP Addresses', :cyan)}: #{ipblock.properties.ips.to_s}"
+        puts 'done'
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_ipblock_delete.rb

@@ -0,0 +1,50 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudIpblockDelete < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud ipblock delete IPBLOCK_ID [IPBLOCK_ID]'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Releases a currently assigned IP block.'
+        @required_options = [:ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        validate_required_params(@required_options, config)
+
+        ipblock_api = Ionoscloud::IPBlocksApi.new(api_client)
+        @name_args.each do |ipblock_id|
+          begin
+            ipblock = ipblock_api.ipblocks_find_by_id(ipblock_id)
+          rescue Ionoscloud::ApiError => err
+            raise err unless err.code == 404
+            ui.error("IP block ID #{ipblock_id} not found. Skipping.")
+            next
+          end
+
+          msg_pair('ID', ipblock.id)
+          msg_pair('Name', ipblock.properties.name)
+          msg_pair('Location', ipblock.properties.location)
+          msg_pair('IP Addresses', ipblock.properties.ips)
+
+          begin
+            confirm('Do you really want to delete this IP block')
+          rescue SystemExit => exc
+            next
+          end
+
+          _, _, headers = ipblock_api.ipblocks_delete_with_http_info(ipblock_id)
+          ui.warn("Released IP block #{ipblock.id}. Request ID: #{get_request_id headers}")
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_ipblock_list.rb

@@ -0,0 +1,42 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudIpblockList < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud ipblock list'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Lists all available IP blocks.'
+        @required_options = [:ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        validate_required_params(@required_options, config)
+
+        ipblock_list = [
+          ui.color('ID', :bold),
+          ui.color('Name', :bold),
+          ui.color('Location', :bold),
+          ui.color('IP Addresses', :bold),
+        ]
+        ipblock_api = Ionoscloud::IPBlocksApi.new(api_client)
+
+        ipblock_api.ipblocks_get({ depth: 1 }).items.each do |ipblock|
+          ipblock_list << ipblock.id
+          ipblock_list << ipblock.properties.name
+          ipblock_list << ipblock.properties.location
+          ipblock_list << ipblock.properties.ips.join(', ')
+        end
+
+        puts ui.list(ipblock_list, :uneven_columns_across, 4)
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_ipfailover_add.rb

@@ -0,0 +1,76 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudIpfailoverAdd < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud ipfailover add (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'Name of the data center'
+
+      option :lan_id,
+              short: '-l LAN_ID',
+              long: '--lan-id LAN_ID',
+              description: 'Lan ID'
+
+      option :ip,
+              short: '-i IP',
+              long: '--ip IP',
+              description: 'IP to be added to IP failover group'
+
+      option :nic_id,
+              short: '-n NIC_ID',
+              long: '--nic-id NIC_ID',
+              description: 'NIC to be added to IP failover group'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        "Successfully setting up an IP Failover group requires three steps:\n"\
+        "* Add a reserved IP address to a NIC that will become the IP Failover master.\n"\
+        "* Use PATCH or PUT to enable ipFailover by providing the relevant ip and nicUuid values.\n"\
+        "* Add the same reserved IP address to any other NICs that are a member of the same LAN. Those NICs will become IP Failover members.\n"
+        @required_options = [:datacenter_id, :lan_id, :ip, :nic_id, :ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        validate_required_params(@required_options, config)
+
+        lan_api = Ionoscloud::LanApi.new(api_client)
+
+        lan = lan_api.datacenters_lans_find_by_id(config[:datacenter_id], config[:lan_id])
+
+        failover_ips = lan.properties.ip_failover || []
+        failover_ips.push({
+          ip: config[:ip],
+          nicUuid: config[:nic_id],
+        })
+
+        changes = Ionoscloud::LanProperties.new({ ip_failover: failover_ips })
+
+        _, _, headers = lan_api.datacenters_lans_patch_with_http_info(config[:datacenter_id], config[:lan_id], changes)
+
+        dot = ui.color('.', :magenta)
+        api_client.wait_for { print dot; is_done? get_request_id headers }
+
+        lan = lan_api.datacenters_lans_find_by_id(config[:datacenter_id], config[:lan_id])
+
+        ip_failovers = lan.properties.ip_failover.map { |el| el.to_hash }
+
+        puts "\n"
+        puts "#{ui.color('ID', :cyan)}: #{lan.id}"
+        puts "#{ui.color('Name', :cyan)}: #{lan.properties.name}"
+        puts "#{ui.color('Public', :cyan)}: #{lan.properties.public}"
+        puts "#{ui.color('IP Failover', :cyan)}: #{ip_failovers}"
+        puts 'done'
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_ipfailover_remove.rb

@@ -0,0 +1,76 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudIpfailoverRemove < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud ipfailover remove (options)'
+
+      option :datacenter_id,
+              short: '-D DATACENTER_ID',
+              long: '--datacenter-id DATACENTER_ID',
+              description: 'Name of the data center'
+
+      option :lan_id,
+              short: '-l LAN_ID',
+              long: '--lan-id LAN_ID',
+              description: 'Lan ID'
+
+      option :ip,
+              short: '-i IP',
+              long: '--ip IP',
+              description: 'IP to be removed from the IP failover group'
+
+      option :nic_id,
+              short: '-n NIC_ID',
+              long: '--nic-id NIC_ID',
+              description: 'NIC to be removed from the IP failover group'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Remove IP Failover from LAN'
+        @required_options = [:datacenter_id, :lan_id, :ip, :nic_id, :ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        validate_required_params(@required_options, config)
+
+        lan_api = Ionoscloud::LanApi.new(api_client)
+
+        lan = lan_api.datacenters_lans_find_by_id(config[:datacenter_id], config[:lan_id])
+
+        initial_length = lan.properties.ip_failover.length
+
+        changes = Ionoscloud::LanProperties.new(
+          { ip_failover: lan.properties.ip_failover.select { |el| el.nic_uuid != config[:nic_id] || el.ip != config[:ip] } },
+        )
+        new_length = changes.ip_failover.length
+
+        if new_length < initial_length
+          _, _, headers = lan_api.datacenters_lans_patch_with_http_info(
+            config[:datacenter_id], config[:lan_id], changes,
+          )
+
+          dot = ui.color('.', :magenta)
+          api_client.wait_for { print dot; is_done? get_request_id headers }
+
+          lan = lan_api.datacenters_lans_find_by_id(config[:datacenter_id], config[:lan_id])
+        end
+
+        ip_failovers = lan.properties.ip_failover.map { |el| el.to_hash }
+
+        puts "\n"
+        puts "#{ui.color('ID', :cyan)}: #{lan.id}"
+        puts "#{ui.color('Name', :cyan)}: #{lan.properties.name}"
+        puts "#{ui.color('Public', :cyan)}: #{lan.properties.public}"
+        puts "#{ui.color('IP Failover', :cyan)}: #{ip_failovers}"
+        puts 'done'
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_k8s_create.rb

@@ -0,0 +1,79 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudK8sCreate < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud k8s create (options)'
+
+      option :name,
+              short: '-n NAME',
+              long: '--name NAME',
+              description: 'Name of the server'
+
+      option :version,
+              short: '-v VERSION',
+              long: '--version VERSION',
+              description: 'The version for the Kubernetes cluster.'
+
+      option :maintenance_day,
+              short: '-d 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.'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Creates a new Managed Kubernetes cluster.'
+        @required_options = [:name, :ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        validate_required_params(@required_options, config)
+
+        print "#{ui.color('Creating K8s Cluster...', :magenta)}"
+
+        kubernetes_api = Ionoscloud::KubernetesApi.new(api_client)
+
+        cluster_properties = {
+          name: config[:name],
+          k8sVersion: config[:version],
+        }.compact
+
+        if config[:maintenance_day] && config[:maintenance_time]
+          cluster_properties[:maintenanceWindow] = {
+            dayOfTheWeek: config[:maintenance_day],
+            time: config[:maintenance_time],
+          }
+        end
+
+        cluster, _, headers = kubernetes_api.k8s_post_with_http_info({ properties: cluster_properties })
+
+        dot = ui.color('.', :magenta)
+        api_client.wait_for { print dot; is_done? get_request_id headers }
+
+        cluster = kubernetes_api.k8s_find_by_cluster_id(cluster.id)
+
+        maintenance_window = "#{cluster.properties.maintenance_window.day_of_the_week}, #{cluster.properties.maintenance_window.time}"
+
+        puts "\n"
+        puts "#{ui.color('ID', :cyan)}: #{cluster.id}"
+        puts "#{ui.color('Name', :cyan)}: #{cluster.properties.name}"
+        puts "#{ui.color('k8s Version', :cyan)}: #{cluster.properties.k8s_version}"
+        puts "#{ui.color('Maintenance Window', :cyan)}: #{maintenance_window}"
+        puts "#{ui.color('State', :cyan)}: #{cluster.metadata.state}"
+
+        puts 'done'
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_k8s_delete.rb

@@ -0,0 +1,67 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudK8sDelete < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud k8s delete CLUSTER_ID [CLUSTER_ID]'
+
+      attr_reader :description, :required_options
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'Deletes a Kubernetes cluster. The cluster cannot contain any node pools when deleting.'
+        @required_options = [:ionoscloud_username, :ionoscloud_password]
+      end
+
+      def run
+        $stdout.sync = true
+        validate_required_params(@required_options, config)
+
+        kubernetes_api = Ionoscloud::KubernetesApi.new(api_client)
+
+        @name_args.each do |cluster_id|
+          begin
+            cluster = kubernetes_api.k8s_find_by_cluster_id(cluster_id, { depth: 2 })
+          rescue Ionoscloud::ApiError => err
+            raise err unless err.code == 404
+            ui.error("K8s Cluster ID #{cluster_id} not found. Skipping.")
+            next
+          end
+
+          if cluster.metadata.state != 'ACTIVE'
+            ui.error("K8s Cluster ID #{cluster_id} is not active. Skipping.")
+            next
+          end
+
+          if cluster.entities.nodepools.items.length > 0
+            ui.error("K8s Cluster ID #{cluster_id} has existing Nodepools. Skipping.")
+            next
+          end
+
+          msg_pair('ID', cluster.id)
+          msg_pair('Name', cluster.properties.name)
+          msg_pair('Version', cluster.properties.k8s_version)
+          msg_pair(
+            'Maintenance Window',
+            "#{cluster.properties.maintenance_window.day_of_the_week}, #{cluster.properties.maintenance_window.time}",
+          )
+          msg_pair('State', cluster.metadata.state)
+
+          puts "\n"
+
+          begin
+            confirm('Do you really want to delete this K8s Cluster')
+          rescue SystemExit => exc
+            next
+          end
+
+          _, _, headers = kubernetes_api.k8s_delete_with_http_info(cluster.id)
+          ui.warn("Deleted K8s Cluster #{cluster.id}. Request ID: #{get_request_id headers}")
+        end
+      end
+    end
+  end
+end