swarm_cluster_cli_ope 0.5.0.pre.2 → 0.5.1

data/lib/swarm_cluster_cli_ope/configuration.rb

@@ -8,17 +8,8 @@ module SwarmClusterCliOpe
   # Classe per la gestione delle configurazioni, unisce le configurazioni di base alle configurazioni di progetto;
   # le quali sono salvate nel file di configurazione del progetto .swarm_cluster_project sottoforma di json
   # che vengono mergiate sulle configurazioni base
-  class Configuration
-    include Singleton
-    include LoggerConcern
+  class Configuration < BaseConfiguration
 
-    #@return [String] nome dello stack con cui lavoriamo
-    attr_accessor :stack_name
-
-    #@return [String] in che enviroment siamo, altrimenti siamo nel default
-    attr_accessor :environment
-
-    NoBaseConfigurations = Class.new(Error)
 
     ##
     # Lista di nodi su cui lavorare
@@ -28,19 +19,6 @@ module SwarmClusterCliOpe
       @_managers = self.nodes.select { |n| read_managers_cache_list.include?(n.name) }.collect { |c| Manager.new(name: c.name.to_s, connection_uri: c.connection_uri) }
     end
 
-    ##
-    # Serve per entrare nell'env corretto.
-    # passando l'env, tutto quello eseguito nello yield sarà gestito in quell'env.
-    # Verrà controllato quindi che esista il relativo file di configurazion
-    def env(enviroment = nil)
-      unless enviroment.nil?
-        @environment = enviroment.to_s.to_sym
-      end
-      logger.info { "ENV: #{@environment ? @environment : "BASE"}" }
-      yield self
-      @environment = nil
-    end
-
     ##
     # Esegue un refresh della lista dei manager, ciclando su tutti i nodi, e scrivendo in /tmp un file temporaneo con
     # con la lista dei nomi dei managers
@@ -80,77 +58,14 @@ module SwarmClusterCliOpe
       self
     end
 
-    # @return [String,NilClass] nome dello stack del progetto se configurato
-    def stack_name
-      return nil unless self.class.exist_base?
-      @stack_name ||= Hash.new do |hash, key|
-        hash[key] = merged_configurations[:stack_name] if merged_configurations.key?(:stack_name)
-      end
-      @stack_name[environment]
-    end
-
-    ##
-    # Imposta il nome dello stack
-    def stack_name=(objs)
-      stack_name #lo richiamo per fargli generare la variabile di classe
-      @stack_name[environment] = objs
-    end
-
-    ##
-    # Livello di logging
-    # @return [Integer]
-    def logger_level
-      merged_configurations[:log_level].to_s || "0"
-    rescue SwarmClusterCliOpe::Configuration::NoBaseConfigurations
-      # quando andiamo in errore durante l'installazione per avere le informazioni per il logger.
-      # Usiamo lo standard
-      "0"
-    end
-
-    ##
-    # Siamo in sviluppo?
-    # @return [TrueClass, FalseClass]
-    def development_mode?
-      return false unless self.class.exist_base?
-      merged_configurations.key?(:dev_mode)
-    end
-
-    ##
-    # Controlla se esiste il file di configurazione base, nella home dell'utente
-    def self.exist_base?
-      File.exist?(base_cfg_path)
-    end
-
-
     ##
     # Salva le configurazioni base in HOME
     def save_base_cfgs
-      FileUtils.mkdir_p(File.dirname(self.class.base_cfg_path))
-      File.open(self.class.base_cfg_path, "wb") do |f|
-        f.write({
-                  version: SwarmClusterCliOpe::VERSION,
-                  connections_maps: nodes.collect { |k| [k.name, k.connection_uri] }.to_h
-                }.to_json)
+      super do |obj|
+        obj.merge({connections_maps: nodes.collect { |k| [k.name, k.connection_uri] }.to_h})
       end
     end
 
-    ##
-    # Si occupa del salvataggio delle configurazioni di progetto, se abbiamo lo stack_name
-    def save_project_cfgs
-      if stack_name
-        File.open(File.join(FileUtils.pwd, self.class.cfgs_project_file_name(with_env: @environment)), "wb") do |f|
-          f.write({
-                    stack_name: stack_name,
-                    version: VERSION
-                  }.to_json)
-        end
-      end
-    end
-
-    # @return [String] path to base home configurations
-    def self.base_cfg_path
-      File.join(ENV['HOME'], '.swarm_cluster', 'config.json')
-    end
 
     # @return [SwarmClusterCliOpe::Node]
     # @param [String] node nome del nodo
@@ -164,50 +79,20 @@ module SwarmClusterCliOpe
       nodes.find { |c| c.id == node_id }
     end
 
-    ##
-    # Indica il nome del progetto locale compose, quella parte di nome che viene attaccata in fronte
-    # ad ogni nome di servizio locale, e che come default è il nome della cartella in cui risiede
-    # il docker-compose.yml file
-    # @return [String]
-    def local_compose_project_name
-      File.basename(FileUtils.pwd).downcase
-    end
 
-    ##
-    # Elenco di tutte le configurazioni di sincronizzazione
-    # @return [Array]
-    def sync_configurations
-      cfgs = merged_configurations[:sync_configs]
-      return [] if cfgs.nil? or !cfgs.is_a?(Array)
-      cfgs.collect do |c|
+    private
 
-        case c[:how]
-        when 'sqlite3'
-          SyncConfigs::Sqlite3.new(self, c)
-        when 'rsync'
-          SyncConfigs::Rsync.new(self, c)
-        when 'mysql'
-          SyncConfigs::Mysql.new(self, c)
-        when 'pg'
-          SyncConfigs::PostGres.new(self, c)
-        else
-          logger.error { "CONFIGURAIONE NON PREVISTA: #{c[:how]}" }
-          nil
-        end
 
-      end.compact
-    end
+    def evaluate_correct_command_usage(configuration)
 
-    private
+      if configuration[:connections_maps].keys.include?(:context)
+        puts "ATTENZIONE, I COMANDI DEVONO ESSERE LANCIATI DAL SUB COMANDO K8S"
+        exit
+      end
 
-    ##
-    # nome del file in cui salvare le configurazioni di progetto
-    # @return [String]
-    # @param [nil|String] with_env nome dell'env da cercare
-    def self.cfgs_project_file_name(with_env: nil)
-      ".swarm_cluster_project#{with_env ? ".#{with_env}" : ""}"
     end
 
+
     ##
     # Path al file dove salviamo la cache dei managers, ha un TTL legato all'orario (anno-mese-giorno-ora)
     # quindi ogni ora si autoripulisce e con un md5 delle configurazioni di base
@@ -218,67 +103,6 @@ module SwarmClusterCliOpe
       File.join("/tmp", file_name)
     end
 
-    ##
-    # Legge le configurazioni base
-    #
-    # @return [Hash]
-    def self.read_base
-      raise NoBaseConfigurations unless exist_base?
-      JSON.parse(File.read(self.base_cfg_path)).deep_symbolize_keys
-    end
-
-    public
-
-    ## Cerca le configurazioni di progetto e le mergia se sono presenti
-    # @return [Hash]
-    def merged_configurations
-      return @_merged_configurations[@environment] if @_merged_configurations
-
-      @_merged_configurations = Hash.new do |hash, key|
-        folder = FileUtils.pwd
-        default_file = looped_file(folder, self.class.cfgs_project_file_name)
-        enviroment_file = looped_file(folder, self.class.cfgs_project_file_name(with_env: key))
-
-        project_cfgs = {}
-        unless default_file.nil?
-          project_cfgs = JSON.parse(File.read(default_file)).deep_symbolize_keys
-        end
-
-        unless enviroment_file.nil?
-          project_cfgs.merge!(JSON.parse(File.read(enviroment_file)).deep_symbolize_keys)
-        end
-
-        hash[key] = self.class.read_base.merge(project_cfgs)
-      end
-
-      configuration_version = @_merged_configurations[@environment][:version]
-      if Gem::Version.new(configuration_version) > Gem::Version.new(VERSION)
-        puts "WARNING: Versione del file di configurazione [#{configuration_version}] più aggiornata della gemma [#{VERSION}], eseguire upgrade
-              gem update swarm_cluster_cli_ope"
-        exit
-      end
-
-      @_merged_configurations[@environment]
-
-    end
-
-    private
-
-    def looped_file(start_folder, file)
-      project_file = nil
-      loop do
-
-        if File.exist?(File.join(start_folder, file))
-          project_file = File.join(start_folder, file)
-        end
-
-        break unless project_file.nil?
-        break if start_folder == '/'
-        start_folder = File.expand_path("..", start_folder)
-      end
-
-      project_file
-    end
 
   end
 end

data/lib/swarm_cluster_cli_ope/configuration_concern.rb

@@ -1,8 +1,16 @@
+require 'active_support/concern'
+
 module SwarmClusterCliOpe
   module ConfigurationConcern
+    extend ActiveSupport::Concern
+
+    included do
+
+      # @return [SwarmClusterCliOpe::Configuration]
+      def cfgs
+        SwarmClusterCliOpe.current_configuration ||= self.class.cfgs
+      end
 
-    def self.included(klass)
-      klass.extend(ClassMethods)
     end
 
     module ClassMethods
@@ -13,12 +21,5 @@ module SwarmClusterCliOpe
         Configuration.instance
       end
     end
-
-
-    # @return [SwarmClusterCliOpe::Configuration]
-    def cfgs
-      self.class.cfgs
-    end
-
   end
 end

data/lib/swarm_cluster_cli_ope/k8s.rb

@@ -1,110 +1,86 @@
-require 'kubeclient'
 module SwarmClusterCliOpe
   class K8s < Thor
     include LoggerConcern
     include ConfigurationConcern
+    include ThorConfigurationConcern
     include Thor::Actions
+    include StackSyncConcern
 
     def self.exit_on_failure?
       true
     end
 
+    def self.cfgs
+      SwarmClusterCliOpe::Kubernetes::Configuration.instance
+    end
 
-    desc "rsync <src> <dst>", "esegue un rsync dalla cartella (viene sincronizzato il contenuto)"
-
-
-    def rsync(src, dst)
-      if yes? "Attenzione, i dati locali o remoti verranno sovrascritti/cancellati?[y,yes]"
-
-        reg_exp = /(?<pod_name>.*)\:(?<path>.*)/
-        if File.exist?(src)
-          # il src é la cartella, quindi la destizione è il pod
-          direction = :upload
-          local_path = src
-          podname = dst.match(reg_exp)[:pod_name]
-          podpath = dst.match(reg_exp)[:path]
+    desc "install", "Creazione della configurazione base della gemma"
+
+    def install
+      #contolliamo se presente la configurazione base nella home
+      if Configuration.exist_base?
+        say "Configurazione già presente"
+      else
+        #se non presente allora chiediamo le varie configurazioni
+        if yes? "Sei nel contesto corretto di kubectl?"
+          #scriviamo le varie configurazioni
+          cfg = cfgs
+          cfg.save_base_cfgs
         else
-          direction = :download
-          podname = src.match(reg_exp)[:pod_name]
-          podpath = src.match(reg_exp)[:path]
-          local_path = dst
+          say "Cambia prima contesto, sarà quello usato per l'installazione"
         end
+      end
 
-        puts "#{src} #{direction} #{dst}"
-
-        cfgs.env(options[:environment]) do |cfgs|
-          config = Kubeclient::Config.read(ENV['KUBECONFIG'] || "#{Dir.home}/.kube/config")
-
-          context = config.context # attuale contesto
-
-          puts "Stiamo utilizzando il contesto: #{context.api_endpoint}"
-
-          base_cmd = ["kubectl", "-n #{cfgs.stack_name}"]
-
-          cmd = ShellCommandExecution.new([*base_cmd, "exec #{podname}", "--", 'bash -c "apt update && apt install -yq rsync psmisc"'])
-          if cmd.execute.failed?
-            puts "Problemi nell'installazione di rsync nel pod"
-          else
-            cmd = ShellCommandExecution.new([*base_cmd, "cp", File.expand_path("../k8s_rsync/rsyncd.conf", __FILE__), "#{podname}:/tmp/."])
-            copy_1 = cmd.execute.failed?
-            cmd = ShellCommandExecution.new([*base_cmd, "cp", File.expand_path("../k8s_rsync/rsyncd.secrets", __FILE__), "#{podname}:/tmp/."])
-            copy_2 = cmd.execute.failed?
-            cmd = ShellCommandExecution.new([*base_cmd, "exec #{podname}", "--", 'bash -c "chmod 600 /tmp/rsyncd.secrets  && chown root /tmp/*"'])
-            chmod = cmd.execute.failed?
-            if copy_1 or copy_2 or chmod
-              puts "problema nella copia dei file di configurazione nel pod"
-            else
-
-
-              cmd = ShellCommandExecution.new([*base_cmd, "exec -i #{podname}", "--", 'bash -c "rsync --daemon --config=/tmp/rsyncd.conf  --verbose --log-file=/tmp/rsync.log"'])
-              if cmd.execute.failed?
-                puts "Rsync non startato"
-              else
-                local_port = rand(30000..40000)
-
-                p = IO.popen([*base_cmd, "port-forward #{podname} #{local_port}:873"].join(" "))
-                pid = p.pid
-                puts "PID in execuzione port forward:#{pid}"
-
-                sleep 1
-
-                # lanciamo il comando quindi per far rsync
-                rsync_command = [
-                  "rsync -az --no-o --no-g",
-                  "--delete",
-                  "--password-file=#{ File.expand_path("../k8s_rsync/password", __FILE__)}"
-                ]
-
-                if direction == :upload
-                  rsync_command << local_path
-                  rsync_command << "rsync://root@0.0.0.0:#{local_port}/archives#{podpath}"
-                else
-                  rsync_command << "rsync://root@0.0.0.0:#{local_port}/archives#{podpath}"
-                  rsync_command << local_path
-                end
-
+    end
 
-                cmd = ShellCommandExecution.new(rsync_command)
-                cmd.execute
 
-                sleep 1
-                Process.kill("INT", pid)
+    desc "rsync <src> <dst>", "esegue un rsync dalla cartella (viene sincronizzato il contenuto)"
+    long_desc "Viene utilizzato rsync standard. La root del pod diviene il context di rsync, quindi
+                possiamo fare rsync con qualsiasi path del filesystem del pod.
+                Il modo con cui scrivere la path sorgente e quello di destinazione è tale a quello di rsync, quindi:
+                - voglio copiare il contenuto della cartella /ciao con il contenuto onlin del pod nella cartella
+                  /home/pippo, dovrò scrivere   /ciao/. podname:/home/pippo "
+    option :stack_name, required: false, type: :string, aliases: ["--namespace", "-n"]
 
+    def rsync(src, dst)
+      reg_exp = /(?<pod_name>.*)\:(?<path>.*)/
+      if File.exist?(src)
+        # il src é la cartella, quindi la destizione è il pod
+        direction = :up
+        local_path = src
+        podname = dst.match(reg_exp)[:pod_name]
+        podpath = dst.match(reg_exp)[:path]
+      else
+        direction = :down
+        podname = src.match(reg_exp)[:pod_name]
+        podpath = src.match(reg_exp)[:path]
+        local_path = dst
+      end
 
-                puts "Eseguo pulizia"
-                cmd = ShellCommandExecution.new([*base_cmd, "exec -i #{podname}", "--", 'bash -c "killall rsync"'])
-                cmd.execute
-                cmd = ShellCommandExecution.new([*base_cmd, "exec -i #{podname}", "--", 'bash -c "rm -fr /tmp/rsyncd*"'])
-                cmd.execute
+      puts "#{src} #{direction} #{dst}"
 
-              end
+      cfgs.env(options[:environment]) do |cfgs|
 
-            end
+        cfgs.stack_name = options[:stack_name] || cfgs.stack_name
 
-          end
+        sync = Kubernetes::SyncConfigs::Rsync.new(cfgs, {
+          service: Kubernetes::Pod.find_by_name(podname),
+          how: 'rsync',
+          configs: {
+            local: local_path,
+            remote: podpath
+          }
+        })
 
+        if direction == :down
+          sync.pull
+        end
+        if direction == :up
+          sync.push
         end
 
+      
+
 
       end
     end

data/lib/swarm_cluster_cli_ope/kubernetes/configuration.rb

@@ -0,0 +1,75 @@
+module SwarmClusterCliOpe
+  module Kubernetes
+    class Configuration < BaseConfiguration
+
+      def shell
+        @_shell = Thor::Shell::Basic.new
+      end
+
+      delegate :yes?,to: :shell
+
+      ##
+      # In kubernetes abbiamo il context, il context può essere ricevuto o dalla configurazione oppure dal current_context
+      # di kubelet
+      # @return [String]
+      def context
+
+        context = merged_configurations.dig(:connections_maps,:context) || nil
+
+        if context.nil?
+          cmd = ShellCommandExecution.new(['kubectl config current-context'])
+          context = cmd.execute.raw_result[:stdout]
+          unless yes? "Attenzione, non era presente il contesto nelle configurazioni, usiamo quello attualmente in uso: #{context}, proseguiamo lo stesso?[y,yes]"
+            exit
+          end
+
+        end
+        context
+      end
+
+      ##
+      # Salva le configurazioni base in HOME
+      def save_base_cfgs
+        super do |obj|
+          obj.merge({connections_maps: {context: context}})
+        end
+      end
+
+      ##
+      # In k8s utilizziamo namespace come identificativo per avere le idee più chiare a cosi ci riferiamo
+      alias_method :namespace, :stack_name
+
+
+      ##
+      # Funzione per la restituzione della classe di sincro corretta
+      def get_syncro(name)
+        case name
+        when 'sqlite3'
+          SyncConfigs::Sqlite3
+        when 'rsync'
+          SyncConfigs::Rsync
+        when 'mysql'
+          SyncConfigs::Mysql
+        when 'pg'
+          SyncConfigs::PostGres
+        else
+          logger.error { "CONFIGURAIONE NON PREVISTA: #{name}" }
+          nil
+        end
+      end
+
+      private
+
+      def evaluate_correct_command_usage(configuration)
+
+        unless configuration[:connections_maps].keys.include?(:context)
+          puts "ATTENZIONE, I COMANDI NON DEVONO ESSERE LANCIATI DAL SUB COMANDO K8S"
+          exit
+        end
+
+      end
+
+
+    end
+  end
+end