knife-ionoscloud 6.0.0 → 6.1.2

data/lib/chef/knife/ionoscloud_base.rb

@@ -11,13 +11,20 @@ class Chef
       def initialize(args = [])
         super(args)
         @description = ''
+        @directory = ''
         @required_options = []
       end
 
+      attr_reader :description, :required_options, :directory
+
       def self.included(includer)
         includer.class_eval do
           deps do
+            warn_level = $VERBOSE
+            $VERBOSE = nil
             require 'ionoscloud'
+            require 'ionoscloud-dbaas-postgres'
+            $VERBOSE = warn_level
           end
 
           option :ionoscloud_username,
@@ -30,6 +37,10 @@ class Chef
                   long: '--password PASSWORD',
                   description: 'Your Ionoscloud password'
 
+          option :ionoscloud_token,
+                  long: '--token PASSWORD',
+                  description: 'Your Ionoscloud access token'
+
           option :ionoscloud_url,
                   long: '--url URL',
                   description: 'The Ionoscloud API URL'
@@ -48,6 +59,11 @@ class Chef
       end
 
       def validate_required_params(required_params, params)
+        if !params[:ionoscloud_token] && !(params[:ionoscloud_username] && params[:ionoscloud_password])
+          puts 'Either ionoscloud_token or ionoscloud_username and ionoscloud_password must be provided to access the Ionoscloud API.'
+          exit(1)
+        end
+
         missing_params = required_params.select do |param|
           params[param].nil?
         end
@@ -80,8 +96,12 @@ class Chef
 
         api_config = Ionoscloud::Configuration.new()
 
-        api_config.username = config[:ionoscloud_username]
-        api_config.password = config[:ionoscloud_password]
+        if config[:ionoscloud_token]
+          api_config.token = config[:ionoscloud_token]
+        else
+          api_config.username = config[:ionoscloud_username]
+          api_config.password = config[:ionoscloud_password]
+        end
 
         if config[:ionoscloud_url]
           uri = URI.parse(config[:ionoscloud_url])
@@ -105,6 +125,31 @@ class Chef
         @api_client
       end
 
+      def api_client_dbaas
+        return @api_client_dbaas if @api_client_dbaas
+
+        api_config_dbaas = IonoscloudDbaasPostgres::Configuration.new()
+
+        if config[:ionoscloud_token]
+          api_config_dbaas.token = config[:ionoscloud_token]
+        else
+          api_config_dbaas.username = config[:ionoscloud_username]
+          api_config_dbaas.password = config[:ionoscloud_password]
+        end
+
+        api_config_dbaas.debugging = config[:ionoscloud_debug] || false
+
+        @api_client_dbaas = IonoscloudDbaasPostgres::ApiClient.new(api_config_dbaas)
+
+        @api_client_dbaas.user_agent =  [
+          'knife/v' + MODULE_VERSION,
+          @api_client_dbaas.default_headers['User-Agent'],
+          'chef/' + Chef::VERSION,
+        ].join('_')
+
+        @api_client_dbaas
+      end
+
       def get_request_id(headers)
         begin
           headers['Location'].scan(%r{/requests/(\b[0-9a-f]{8}\b-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-\b[0-9a-f]{12}\b)}).last.first
@@ -423,6 +468,36 @@ class Chef
         end}"
         puts "#{ui.color('Flowlogs', :cyan)}: #{natgateway.entities.flowlogs.items.map { |flowlog| flowlog.id }}"
       end
+
+      def print_cluster(cluster)
+        connections = cluster.properties.connections.map { |connection| connection.to_hash }
+        
+        print "\n"
+        puts "#{ui.color('ID', :cyan)}: #{cluster.id}"
+        puts "#{ui.color('Display Name', :cyan)}: #{cluster.properties.display_name}"
+        puts "#{ui.color('Postgres Version', :cyan)}: #{cluster.properties.postgres_version}"
+        puts "#{ui.color('Location', :cyan)}: #{cluster.properties.location}"
+        puts "#{ui.color('Backup location', :cyan)}: #{cluster.properties.backup_location}"
+        puts "#{ui.color('Instances', :cyan)}: #{cluster.properties.instances}"
+        puts "#{ui.color('RAM Size', :cyan)}: #{cluster.properties.ram}"
+        puts "#{ui.color('Cores', :cyan)}: #{cluster.properties.cores}"
+        puts "#{ui.color('Storage Size', :cyan)}: #{cluster.properties.storage_size}"
+        puts "#{ui.color('Storage Type', :cyan)}: #{cluster.properties.storage_type}"
+        puts "#{ui.color('Connections', :cyan)}: #{connections}"
+        puts "#{ui.color('Maintenance Window', :cyan)}: #{cluster.properties.maintenance_window.to_hash}"
+        puts "#{ui.color('Synchronization Mode', :cyan)}: #{cluster.properties.synchronization_mode}"
+        puts "#{ui.color('Lifecycle Status', :cyan)}: #{cluster.metadata.state}"
+      end
+
+      def print_cluster_backup(backup)
+        print "\n"
+        puts "#{ui.color('ID', :cyan)}: #{backup.id}"
+        puts "#{ui.color('Cluster ID', :cyan)}: #{backup.properties.cluster_id}"
+        puts "#{ui.color('Version', :cyan)}: #{backup.properties.version}"
+        puts "#{ui.color('Is Active', :cyan)}: #{backup.properties.is_active}"
+        puts "#{ui.color('Earliest Recovery Target Time', :cyan)}: #{backup.properties.earliest_recovery_target_time}"
+        puts "#{ui.color('Created Date', :cyan)}: #{backup.metadata.created_date}"
+      end
     end
   end
 end

data/lib/chef/knife/ionoscloud_composite_server_create.rb

@@ -124,14 +124,13 @@ class Chef
               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'
 
-      attr_reader :description, :required_options
-
       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,
+          :datacenter_id, :name, :cores, :ram, :size, :type, :dhcp, :lan,
         ]
       end
 
@@ -159,7 +158,7 @@ class Chef
             availability_zone: config[:volume_availability_zone],
             backupunit_id: config[:backupunit_id],
             user_data: config[:user_data],
-          }.compact)
+          }.compact),
         )
 
         nic = Ionoscloud::Nic.new(
@@ -169,7 +168,7 @@ class Chef
             dhcp: config[:dhcp],
             lan: config[:lan],
             firewall_type: config[:firewall_type],
-          }.compact)
+          }.compact),
         )
 
         server = Ionoscloud::Server.new(

data/lib/chef/knife/ionoscloud_contract_list.rb

@@ -7,13 +7,11 @@ class Chef
 
       banner 'knife ionoscloud contract list'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
         'Lists information about available contract resources.'
-        @required_options = [:ionoscloud_username, :ionoscloud_password]
+        @directory = 'user'
       end
 
       def run
@@ -23,8 +21,7 @@ class Chef
 
         contracts = Ionoscloud::ContractResourcesApi.new(api_client).contracts_get()
 
-        contracts.items.each do
-          |contract|
+        contracts.items.each do |contract|
           puts "#{ui.color('Contract Type', :cyan)}: #{contract.type}"
           puts "#{ui.color('Contract Owner', :cyan)}: #{contract.properties.owner}"
           puts "#{ui.color('Contract Number', :cyan)}: #{contract.properties.contract_number}"

data/lib/chef/knife/ionoscloud_cube_server_create.rb

@@ -104,14 +104,13 @@ class Chef
               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'
 
-      attr_reader :description, :required_options
-
       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,
+          :datacenter_id, :name, :template,
         ]
       end
 
@@ -136,7 +135,7 @@ class Chef
             licence_type: config[:licence_type],
             backupunit_id: config[:backupunit_id],
             user_data: config[:user_data],
-          }.compact)
+          }.compact),
         )]
 
         nics = []
@@ -150,8 +149,8 @@ class Chef
                 dhcp: config[:dhcp],
                 lan: config[:lan],
                 firewall_type: config[:firewall_type],
-              }.compact)
-            )
+              }.compact),
+            ),
           ]
         end
 

data/lib/chef/knife/ionoscloud_datacenter_create.rb

@@ -22,17 +22,16 @@ class Chef
               long: '--location LOCATION',
               description: 'Location of the data center'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
-        "Unless you are planning to manage an existing Ionoscloud environment, "\
-        "the first step will typically involve choosing the location for a new virtual data center"\
+        'Unless you are planning to manage an existing Ionoscloud environment, '\
+        'the first step will typically involve choosing the location for a new virtual data center'\
         "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"
-        @required_options = [:location, :ionoscloud_username, :ionoscloud_password]
+        @directory = 'compute-engine'
+        @required_options = [:location]
       end
 
       def run

data/lib/chef/knife/ionoscloud_datacenter_delete.rb

@@ -7,15 +7,13 @@ 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.'
-        @required_options = [:ionoscloud_username, :ionoscloud_password]
+        @directory = 'compute-engine'
       end
 
       def run
@@ -39,7 +37,7 @@ class Chef
 
           begin
             confirm('Do you really want to delete this data center')
-          rescue SystemExit => exc
+          rescue SystemExit
             next
           end
 

data/lib/chef/knife/ionoscloud_datacenter_get.rb

@@ -12,13 +12,12 @@ class Chef
               long: '--datacenter-id DATACENTER_ID',
               description: 'ID of the data center'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
         'Retrieves information about a Ionoscloud Datacenter.'
-        @required_options = [:datacenter_id, :ionoscloud_username, :ionoscloud_password]
+        @directory = 'compute-engine'
+        @required_options = [:datacenter_id]
       end
 
       def run

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,7 +16,7 @@ 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.'
-        @required_options = [:ionoscloud_username, :ionoscloud_password]
+        @directory = 'compute-engine'
       end
 
       def run

data/lib/chef/knife/ionoscloud_datacenter_update.rb

@@ -25,13 +25,12 @@ class Chef
               long: '--sec-auth-protection SEC_AUTH_PROTECTION',
               description: 'Boolean value representing if the data center requires extra protection e.g. two factor protection'
 
-      attr_reader :description, :required_options
-
       def initialize(args = [])
         super(args)
         @description =
         'Updates information about a Ionoscloud Datacenter.'
-        @required_options = [:datacenter_id, :ionoscloud_username, :ionoscloud_password]
+        @directory = 'compute-engine'
+        @required_options = [:datacenter_id]
         @updatable_fields = [:name, :description, :sec_auth_protection]
       end
 
@@ -45,13 +44,13 @@ class Chef
         if @updatable_fields.map { |el| config[el] }.any?
           print "#{ui.color('Updating data center...', :magenta)}"
 
-          datacenter, _, headers  = datacenter_api.datacenters_patch_with_http_info(
+          _, _, 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)

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]
+      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,58 @@
+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'
+      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,162 @@
+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 :backup_location,
+              long: '--backup-location BACKUP_LOCATION',
+              description: 'The S3 location where the backups will be stored.'
+
+      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. One of [ASYNCHRONOUS, SYNCHRONOUS, STRICTLY_SYNCHRONOUS]'
+
+      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,
+        ]
+      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],
+          backup_location: config[:backup_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, _, _  = 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,48 @@
+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'
+      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
+            next
+          end
+
+          clusters_api.clusters_delete_with_http_info(cluster_id)
+          ui.warn("Deleted Cluster #{cluster.id}.")
+        end
+      end
+    end
+  end
+end

data/lib/chef/knife/ionoscloud_dbaas_postgres_cluster_get.rb

@@ -0,0 +1,34 @@
+require_relative 'ionoscloud_base'
+
+class Chef
+  class Knife
+    class IonoscloudDbaasPostgresClusterGet < Knife
+      include Knife::IonoscloudBase
+
+      banner 'knife ionoscloud dbaas postgres cluster get (options)'
+
+      option :cluster_id,
+              short: '-C CLUSTER_ID',
+              long: '--cluster-id CLUSTER_ID',
+              description: 'ID of the cluster'
+
+      def initialize(args = [])
+        super(args)
+        @description =
+        'You can retrieve a PostgreSQL cluster by using its ID. This value can be '\
+        'found in the response body when a PostgreSQL cluster is created or when '\
+        'you GET a list of PostgreSQL clusters.'
+        @directory = 'dbaas-postgres'
+        @required_options = [:cluster_id]
+      end
+
+      def run
+        $stdout.sync = true
+        handle_extra_config
+        validate_required_params(@required_options, config)
+
+        print_cluster(IonoscloudDbaasPostgres::ClustersApi.new(api_client_dbaas).clusters_find_by_id(config[:cluster_id]))
+      end
+    end
+  end
+end