swarm_cluster_cli_ope 0.1.4 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b94cc1986544ce1c00945bf883df5c9e4003509e2a55eabd8dfcb30eece8f9a
-  data.tar.gz: 2bc401e45d21d81433fa837f8e647e847b395f0f1c725f98685931d25c76ac53
+  metadata.gz: e7a0c1998bd04fc1f315b316b47d094352f24d07ca19cd0da18254a59bd4cd68
+  data.tar.gz: ef6f7962bf661d9839ace5820485896db7c4066194632d865c54e5b667c05957
 SHA512:
-  metadata.gz: df6e5910223f8aaf1b8dac1d7d8ef253e5f87e3fa51fb0240efb9c6f50ab9f586373ad2fc569bb3306603b8ca680bf7543557cf33bba08d5193566f0ba9f2479
-  data.tar.gz: dd52d60b709b2b5f196f80825f6857940c35cfe76bde1bc964d45b77df876cd683a94261fa34ce83bdd3dc2949af28ca25903e80bedfed367979592c10395955
+  metadata.gz: 514cca4b32bf7fa10adc40a0579a5db538a0601733ea78a0bb9514ff6b6cf006cf7bd2d6d744b508048d9a351fd79c2a5fd290b18a28c7b2fc376d19f9eed47c
+  data.tar.gz: f174ac4bff4447acb66218ca7d20319caf47b8cd7e67d6a52a0974cfa940eaa5888f6a649e2ccf4b4b7283840c75c1b3ebcd03d17ebe4ef0b082119087782668

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    swarm_cluster_cli_ope (0.1.4)
+    swarm_cluster_cli_ope (0.2.2)
       activesupport
       open4
       thor (~> 1.0)
@@ -10,12 +10,12 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.0.2.2)
+    activesupport (6.0.3)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)
       tzinfo (~> 1.1)
-      zeitwerk (~> 2.2)
+      zeitwerk (~> 2.2, >= 2.2.2)
     concurrent-ruby (1.1.6)
     i18n (1.8.2)
       concurrent-ruby (~> 1.0)

data/README.md

@@ -22,7 +22,7 @@ Or install it yourself as:
 
 Una volta installato lanciare il comando 
 
-```swarm_cluster_cli_ope install``` che si occuperà di configurare le varie impostazioni dell'ambiente
+```swarm_cli_ope install``` che si occuperà di configurare le varie impostazioni dell'ambiente
 
 FILE di configurazione base:
 ```json
@@ -36,9 +36,12 @@ FILE di configurazione base:
 3 DEBUG
 
 
+### ENV differenti
+Tutti i comandi possono essere accompagnati con -e, per scopparli nel relativo ENVIRONMENT
+
 ### Configuratione di un progetto
 Si occupa di generare nel progetto il file di configurazione in cui impostare impostazioni specifiche di progetto
-quali stack_name
+quali stack_name (.swarm_cluster_project)
 ```shell script
 swarm_cli_ope configure_project STACK_NAME
 ```
@@ -82,10 +85,6 @@ swarm_cli_ope services --stack-name=NOME_STACK
 ```shell script
 swarm_cli_ope cp --stack-name=NOME_STACK PATH_FILE_LOCALE NOME_SERVIZIO:DESTINAZIONE_NEL_CONTAINER
 ```
-ES:
-```shell script
-swarm_cli_ope cp --stack-name=webapps-examinerapp-staging ./test_folder/test_1/cartella_bindata/test jeapp:/tmp/.
-```
 
 ### Rsync da/a container a/da locale
 
@@ -96,23 +95,20 @@ Utilizzare `rsync_binded_from` per scaricare e `rsync_binded_to` per caricare
 swarm_cli_ope rsync_binded_from --stack-name=STACK_NAME --service_name NOME_SERVIZIO_SENZA_STACK --binded-container-folders CARTELLA_CONTAINER --local-folder CARTELLA_DESTINAZIONE
 ```
 
-ES:
-```shell script
-swarm_cli_ope rsync_binded_from --stack-name=web-site-ranchilbosco-production --service_name wordpress --binded-container-folders /var/www/html/wp-content/uploads --destination ./uploads
-```
-
-
 ## Development
 
 nel file di configurazione creato nella home aggiungere la chiave "dev_mode":1 per collegarsi localmente
 
 ### Abbiamo due tasks swarm di simulazione
 ```shell script
-docker stack deploy -c test_folder/test_1/docker_compose.yml test1
+docker stack deploy -c test_folder/test_1/docker-compose.yml test1
+docker stack deploy -c test_folder/test_1/docker-compose.yml test1_staging
 docker stack deploy -c test_folder/test_2/docker_compose.yml test2
 ```
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version 
+number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git 
+commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
 
 
 ## License

data/lib/swarm_cluster_cli_ope/cli.rb

@@ -11,6 +11,9 @@ module SwarmClusterCliOpe
       true
     end
 
+    class_option :environment, required: false, type: :string, aliases: [:e],
+                 desc: "Esegue tutte le operazioni nell'env scelto, il file di configurazione dovrà avere il nome: #{Configuration.cfgs_project_file_name}.ENV"
+
     desc "install", "Creazione della configurazione base della gemma"
 
     def install
@@ -37,10 +40,12 @@ module SwarmClusterCliOpe
 
     end
 
-    desc "config", "Visualizza le configurazioni mergiate (HOME + Project)"
+    desc "config", "Visualizza le configurazioni mergiate (HOME + Project configuration[#{Configuration.cfgs_project_file_name}])"
 
     def config
-      puts JSON.pretty_generate(cfgs.class.merged_configurations)
+      cfgs.env(options[:environment]) do
+        puts JSON.pretty_generate(cfgs.merged_configurations)
+      end
     end
 
 
@@ -54,88 +59,93 @@ module SwarmClusterCliOpe
     end
 
     desc "services", "lista dei servizi per uno stack"
-    option :stack_name, required: false, type: :string, default: cfgs.stack_name
+    option :stack_name, required: false, type: :string
 
     def services
-      Models::Service.all(stack_name: options[:stack_name]).each do |s|
-        puts s.name
+      cfgs.env(options[:environment]) do |cfgs|
+        stack_name = options[:stack_name] || cfgs.stack_name
+        Models::Service.all(stack_name: stack_name).each do |s|
+          puts s.name
+        end
       end
     end
 
     desc "mc SERVICE_NAME", "Apre MC tra la cartella attuale e il container (potrebbe dar luogo a degli errori, ma funziona)"
-    option :stack_name, required: false, type: :string, default: cfgs.stack_name
+    option :stack_name, required: false, type: :string
 
     def mc(service_name)
-
-      # Disabilito output della libreria
-      MakeMakefile::Logging.instance_variable_set(:@logfile, File::NULL)
-      unless find_executable 'mc'
-        puts "Non hai installato MC"
-        exit 0
-      end
-
-      begin
-        container = Models::Container.find_by_service_name(service_name, stack_name: options[:stack_name])
-
-        server = container.node.hostname
-
-        # Creo container ssh
-        #     DOCKER_HOST=ssh://swarm_node_1 docker run --rm -d -p 12222:22 \
-        # --volumes-from sistemi-test_swarm_cluster_cli_wordpress.1.zbbz1xxh4vzzccndvs973jnuc \
-        # sickp/alpine-sshd:7.5
-        #
-        cmd = container.docker_command
-        cmd.base_suffix_command = ''
-        shell_operation = cmd.command do |c|
-          c.add("run --rm -d -p 42222:22 --volumes-from #{container.id} sickp/alpine-sshd:7.5")
+      cfgs.env(options[:environment]) do |cfgs|
+        stack_name = options[:stack_name] || cfgs.stack_name
+        # Disabilito output della libreria
+        MakeMakefile::Logging.instance_variable_set(:@logfile, File::NULL)
+        unless find_executable 'mc'
+          puts "Non hai installato MC"
+          exit 0
         end
 
-        puts "Creazione container #{shell_operation.string_command}"
-        id_container = shell_operation.execute.raw_result[:stdout]
-        puts "Container generato con id:#{id_container}"
-
-        # eseguo tunnel verso nodo e container ssh
-        socket_ssh_path = "/tmp/socket_ssh_#{id_container}"
-        # ssh -f -N -T -M -S <path-to-socket> -L 13333:0.0.0.0:42222 <server>
-        cmd_tunnel = ["ssh", "-f -N -T -M", "-S #{socket_ssh_path}", "-L 13333:0.0.0.0:42222", server].join(" ")
-        puts "Apro tunnel"
-        puts cmd_tunnel
-        system(cmd_tunnel)
-
-        # apro MC
-        #     mc . sftp://root:root@0.0.0.0:13333
-        mc_cmd = "mc . sftp://root:root@0.0.0.0:13333"
-        puts "Apro MC"
-        puts mc_cmd
-        system(mc_cmd)
-      ensure
-        if socket_ssh_path
-          # chiudo tunnel
-          # ssh -S <path-to-socket> -O exit <server>
-          close_tunnel_cmd = "ssh -S #{socket_ssh_path} -O exit #{server}"
-          puts "Chiudo tunnel"
-          # say close_tunnel_cmd
-          ShellCommandExecution.new(close_tunnel_cmd).execute
-        end
+        begin
+          container = Models::Container.find_by_service_name(service_name, stack_name: stack_name)
 
-        if id_container
-          # cancello container
-          # docker stop  #{id_container}
-          puts "Spengo container di appoggio"
-          puts "docker stop  #{id_container}"
+          server = container.node.hostname
+
+          # Creo container ssh
+          #     DOCKER_HOST=ssh://swarm_node_1 docker run --rm -d -p 12222:22 \
+          # --volumes-from sistemi-test_swarm_cluster_cli_wordpress.1.zbbz1xxh4vzzccndvs973jnuc \
+          # sickp/alpine-sshd:7.5
+          #
           cmd = container.docker_command
           cmd.base_suffix_command = ''
-          stop_ssh_container = cmd.command do |c|
-            c.add("stop #{id_container}")
+          shell_operation = cmd.command do |c|
+            c.add("run --rm -d -p 42222:22 --volumes-from #{container.id} sickp/alpine-sshd:7.5")
+          end
+
+          puts "Creazione container #{shell_operation.string_command}"
+          id_container = shell_operation.execute.raw_result[:stdout]
+          puts "Container generato con id:#{id_container}"
+
+          # eseguo tunnel verso nodo e container ssh
+          socket_ssh_path = "/tmp/socket_ssh_#{id_container}"
+          # ssh -f -N -T -M -S <path-to-socket> -L 13333:0.0.0.0:42222 <server>
+          cmd_tunnel = ["ssh", "-f -N -T -M", "-S #{socket_ssh_path}", "-L 13333:0.0.0.0:42222", server].join(" ")
+          puts "Apro tunnel"
+          puts cmd_tunnel
+          system(cmd_tunnel)
+
+          # apro MC
+          #     mc . sftp://root:root@0.0.0.0:13333
+          mc_cmd = "mc . sftp://root:root@0.0.0.0:13333"
+          puts "Apro MC"
+          puts mc_cmd
+          system(mc_cmd)
+        ensure
+          if socket_ssh_path
+            # chiudo tunnel
+            # ssh -S <path-to-socket> -O exit <server>
+            close_tunnel_cmd = "ssh -S #{socket_ssh_path} -O exit #{server}"
+            puts "Chiudo tunnel"
+            # say close_tunnel_cmd
+            ShellCommandExecution.new(close_tunnel_cmd).execute
+          end
+
+          if id_container
+            # cancello container
+            # docker stop  #{id_container}
+            puts "Spengo container di appoggio"
+            puts "docker stop  #{id_container}"
+            cmd = container.docker_command
+            cmd.base_suffix_command = ''
+            stop_ssh_container = cmd.command do |c|
+              c.add("stop #{id_container}")
+            end
+            stop_ssh_container.execute
           end
-          stop_ssh_container.execute
-        end
 
+        end
       end
     end
 
     desc "cp SRC DEST", "Copia la sorgente in destinazione"
-    option :stack_name, required: false, type: :string, default: cfgs.stack_name
+    option :stack_name, required: false, type: :string
     long_desc <<-LONGDESC
       SRC e DEST possono essere un servizio, solo uno di essi può essere un servizio (TODO)
       Per identificare che sia un servizio controllo se nella stringa è presete il :
@@ -144,49 +154,76 @@ module SwarmClusterCliOpe
     LONGDESC
 
     def cp(src, dest)
-      #identifico quale dei due è il servizio e quale la path
-      if src.match(/^(.*)\:/)
-        container = Models::Container.find_by_service_name(Regexp.last_match[1], stack_name: options[:stack_name])
-        ris = container.copy_out(src.match(/\:(.*)$/)[1], dest)
-      else
-        container = Models::Container.find_by_service_name(dest.match(/^(.*)\:/)[1], stack_name: options[:stack_name])
-        ris = container.copy_in(src, dest.match(/\:(.*)$/)[1])
+      cfgs.env(options[:environment]) do |cfgs|
+
+        cfgs.stack_name = options[:stack_name] || cfgs.stack_name
+
+        #identifico quale dei due è il servizio e quale la path
+        if src.match(/^(.*)\:/)
+          service_name = Regexp.last_match[1]
+          remote = src.match(/\:(.*)$/)[1]
+          local = dest
+          execute = :pull
+        else
+          service_name = dest.match(/^(.*)\:/)[1]
+          remote = dest.match(/\:(.*)$/)[1]
+          local = src
+          execute = :push
+        end
+
+
+        cmd = SyncConfigs::Copy.new(cfgs, {
+          service: service_name,
+          how: 'copy',
+          configs: {
+            local: local,
+            remote: remote
+          }
+        })
+
+        puts "COMPLETATO" if cmd.send(execute)
+
       end
-      puts "COMPLETATO" if ris
     end
 
 
     desc "configure_project STACK_NAME", "Genera il file di configurazione del progetto contenente il nome dello stack"
 
     def configure_project(stack_name)
-      cfgs.stack_name = stack_name
-      cfgs.save_project_cfgs
+      cfgs.env(options[:environment]) do |c|
+        c.stack_name = stack_name
+        c.save_project_cfgs
+      end
     end
 
+
     desc "service_shell SERVICE_NAME", "apre una shell [default bash] dentro al container"
-    option :stack_name, required: false, type: :string, default: cfgs.stack_name
+    option :stack_name, required: false, type: :string
     option :shell, required: false, type: :string, default: 'bash'
 
     def service_shell(service_name)
-      container = Models::Container.find_by_service_name(service_name, stack_name: options[:stack_name])
+      cfgs.env(options[:environment]) do |cfgs|
+        stack_name = options[:stack_name] || cfgs.stack_name
+        container = Models::Container.find_by_service_name(service_name, stack_name: stack_name)
 
-      cmd = container.docker_command
-      cmd.base_suffix_command = ''
-      shell_operation = cmd.command do |c|
-        c.add("exec -it #{container.id} #{options[:shell]}")
-      end
+        cmd = container.docker_command
+        cmd.base_suffix_command = ''
+        shell_operation = cmd.command do |c|
+          c.add("exec -it #{container.id} #{options[:shell]}")
+        end
 
-      say "Stai entrando della shell in #{options[:shell]} del container #{options[:stack_name]}->#{container.name}[#{container.id}]"
-      system(shell_operation.string_command)
-      say "Shell chiusa"
+        say "Stai entrando della shell in #{options[:shell]} del container #{stack_name}->#{container.name}[#{container.id}]"
+        system(shell_operation.string_command)
+        say "Shell chiusa"
+      end
     end
 
 
     desc "rsync_binded_from", "esegue un rsync dalla cartella bindata (viene sincronizzato il contenuto)"
-    option :stack_name, required: false, type: :string, default: cfgs.stack_name
+    option :stack_name, required: false, type: :string
     option :service_name, required: true, type: :string
     option :binded_container_folders, required: true, type: :string, desc: "path della cartella bindata all'interno del container da sincronizzare"
-    option :local_folder, required: false, type: :string, desc: "path della cartella dove sincronizzare il comando"
+    option :local_folder, required: true, type: :string, desc: "path della cartella dove sincronizzare il comando"
 
     def rsync_binded_from
       if yes? "Attenzione, i dati locali verranno sovrascritti/cancellati?[y,yes]"
@@ -195,10 +232,10 @@ module SwarmClusterCliOpe
     end
 
     desc "rsync_binded_to", "esegue un rsync verso la cartella bindata"
-    option :stack_name, required: false, type: :string, default: cfgs.stack_name
+    option :stack_name, required: false, type: :string
     option :service_name, required: true, type: :string
     option :binded_container_folders, required: true, type: :string, desc: "path della cartella bindata all'interno del container da sincronizzare"
-    option :local_folder, required: false, type: :string, desc: "path della cartella dove sincronizzare il comando"
+    option :local_folder, required: true, type: :string, desc: "path della cartella dove sincronizzare il comando"
 
     def rsync_binded_to
       if yes? "ATTENZIONE, i dati remoti verranno sovrascritti/cancellati da quelli locali?[y,yes]"
@@ -206,46 +243,98 @@ module SwarmClusterCliOpe
       end
     end
 
+    desc "stacksync [DIRECTION:pull|push]", "Si occupa di scaricare|caricare,utilizzando le configurazioni presenti, i dati dallo stack remoto"
+    long_desc <<-LONGDESC.gsub("\n", "\x5")
+      le configurazioni sono contenute nell'array: sync_configs.
+      ogni configurazione è composta da:
+      { 
+       service:"" 
+       how:"" 
+       configs:{ }
+      }
+      - service è il nome del servizio
+      - how è il come sincronizzare, definendo la tipologia:
+      ---- pg      -> DB TODO
+      ---- mysql   -> DB TODO
+      ---- sqlite3 -> DB: viene eseguita una copia del file
+      ---- rsync   -> RSYNC
+      - configs:  è un hash con le configurazioni per ogni tipo di sincronizzazione
+
+      Possibili CFGS per tipologia:
+      rsync:
+      --local:   -> path cartella locale
+      --remote:  -> path cartella remota (contesto del container)
+
+      sqlite3:
+      --local:   -> path al file
+      --remote:  -> path al file remoto (contesto del container)
+
+      EXAMPLE:
+      Esempio di sincronizzazione di un file sqlite3 e una cartella
+      {
+        "stack_name": "test1",
+        "sync_configs": [
+          {
+            "service": "second",
+            "how": "rsync",
+            "configs": {
+              "remote": "/test_bind",
+              "local": "./uploads"
+            }
+          },
+          {
+            "service": "test_sqlite3",
+            "how": "sqlite3",
+            "configs": {
+              "remote": "/cartella_sqlite3/esempio.sqlite3",
+              "local": "./development.sqlite3"
+            }
+          }
+        ]
+      }
+    LONGDESC
 
-    private
-
-    def rsync_binded(direction: :down, options: {})
-
-      # trovo il container del servizio
-      container = Models::Container.find_by_service_name(options[:service_name], stack_name: options[:stack_name])
-
-      if container.nil?
-        say "Container non trovato con #{options[:stack_name]}@##{options[:service_name]}"
-        exit 0
+    def stacksync(direction)
+      direction = case direction
+                  when 'push'
+                    :push
+                  when 'pull'
+                    :pull
+                  else
+                    raise "ONLY [push|pull] action accepted"
+                  end
+      cfgs.env(options[:environment]) do |cfgs|
+        cfgs.sync_configurations.each do |sync|
+          say "----------->>>>>>"
+          say "[ #{sync.class.name} ]"
+          sync.send(direction)
+          say "<<<<<<-----------"
+        end
       end
+    end
 
+    private
 
-      # trovo la cartella bindata e la relativa cartella sul nodo
-      volume = container.mapped_volumes.find { |v| v.destination == options[:binded_container_folders] and v.is_binded? }
-      if volume.nil?
-        say "Non ho trovato il volume bindato con questa destinazione all'interno del container #{options[:binded_container_folders]}"
-        exit 0
-      end
-
-      #costruisco il comando rsync fra cartella del nodo e cartella sul pc
-      cmd = ["rsync", "-zr", "--delete"]
-      if direction == :down
-        cmd << "#{volume.ssh_connection_path}/."
-        # creo la cartella in locale se non esiste
-        FileUtils.mkdir_p(options[:local_folder])
-        cmd << options[:local_folder]
-      end
-      if direction == :up
-        cmd << "#{options[:local_folder]}/."
-        cmd << volume.ssh_connection_path
-      end
+    def rsync_binded(direction: :down, options: {})
+      cfgs.env(options[:environment]) do |cfgs|
+        cfgs.stack_name = options[:stack_name] || cfgs.stack_name
+        sync = SyncConfigs::Rsync.new(cfgs, {
+          service: options[:service_name],
+          how: 'rsync',
+          configs: {
+            local: options[:local_folder],
+            remote: options[:binded_container_folders]
+          }
+        })
+
+        if direction == :down
+          sync.pull
+        end
+        if direction == :up
+          sync.push
+        end
 
-      cmd = ShellCommandExecution.new(cmd)
 
-      say "Comando da eseguire:"
-      say "  #{cmd.string_command}"
-      if yes?("Confermare il comando?[y,yes]")
-        cmd.execute
       end
     end
   end

data/lib/swarm_cluster_cli_ope/configuration.rb

@@ -15,6 +15,9 @@ module SwarmClusterCliOpe
     #@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)
 
     ##
@@ -25,6 +28,19 @@ 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
@@ -48,8 +64,10 @@ module SwarmClusterCliOpe
     #
     # @return [Array<SwarmClusterCliOpe::Node>]
     def nodes
-      return @_nodes if @_nodes
-      @_nodes = self.class.merged_configurations[:connections_maps].collect { |m, c| Node.new(name: m.to_s, connection_uri: c) }
+      @_nodes ||= Hash.new do |hash, key|
+        hash[key] = self.merged_configurations[:connections_maps].collect { |m, c| Node.new(name: m.to_s, connection_uri: c) }
+      end
+      @_nodes[environment]
     end
 
     ##
@@ -58,22 +76,31 @@ module SwarmClusterCliOpe
     # @param [Array<SwarmClusterCliOpe::Node>]
     # @return [Configuration]
     def nodes=(objs)
-      @_nodes = objs
+      nodes[environment] = objs
       self
     end
 
     # @return [String,NilClass] nome dello stack del progetto se configurato
     def stack_name
-      return @stack_name if @stack_name
       return nil unless self.class.exist_base?
-      @stack_name = self.class.merged_configurations[:stack_name] if self.class.merged_configurations.key?(:stack_name)
+      @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
-      self.class.merged_configurations[:log_level].to_s || "0"
+      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
@@ -85,7 +112,7 @@ module SwarmClusterCliOpe
     # @return [TrueClass, FalseClass]
     def development_mode?
       return false unless self.class.exist_base?
-      self.class.merged_configurations.key?(:dev_mode)
+      merged_configurations.key?(:dev_mode)
     end
 
     ##
@@ -110,8 +137,8 @@ module SwarmClusterCliOpe
     ##
     # 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), "wb") do |f|
+      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
                   }.to_json)
@@ -136,13 +163,31 @@ module SwarmClusterCliOpe
       nodes.find { |c| c.id == node_id }
     end
 
+    ##
+    # Elenco di tutte le configurazioni di sincronizzazione
+    def sync_configurations
+      merged_configurations[:sync_configs].collect do |c|
+
+        case c[:how]
+        when 'sqlite3'
+          SyncConfigs::Sqlite3.new(self, c)
+        when 'rsync'
+          SyncConfigs::Rsync.new(self, c)
+        else
+          logger.error { "CONFIGURAIONE NON PREVISTA: #{c[:how]}" }
+        end
+
+      end.compact
+    end
+
     private
 
     ##
     # nome del file in cui salvare le configurazioni di progetto
     # @return [String]
-    def self.cfgs_project_file_name
-      '.swarm_cluster_project'
+    # @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
 
     ##
@@ -150,7 +195,7 @@ module SwarmClusterCliOpe
     # quindi ogni ora si autoripulisce e con un md5 delle configurazioni di base
     # @return [String]
     def swarm_manager_cache_path
-      md5 = Digest::MD5.hexdigest(self.class.merged_configurations.to_json)
+      md5 = Digest::MD5.hexdigest(self.merged_configurations.to_json)
       file_name = Time.now.strftime(".swarm_cluster_cli_manager_cache-%Y%m%d%H-#{md5}")
       File.join("/tmp", file_name)
     end
@@ -164,29 +209,50 @@ module SwarmClusterCliOpe
       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 self.merged_configurations
-      return @_merged_configurations if @_merged_configurations
+    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
+
+      @_merged_configurations[@environment]
+
+    end
+
+    private
+
+    def looped_file(start_folder, file)
       project_file = nil
-      folder = FileUtils.pwd
       loop do
 
-        if File.exist?(File.join(folder, cfgs_project_file_name))
-          project_file = File.join(folder, cfgs_project_file_name)
+        if File.exist?(File.join(start_folder, file))
+          project_file = File.join(start_folder, file)
         end
 
         break unless project_file.nil?
-        break if folder == '/'
-        folder = File.expand_path("..", folder)
-      end
-
-      project_cfgs = {}
-      unless project_file.nil?
-        project_cfgs = JSON.parse(File.read(project_file)).deep_symbolize_keys
+        break if start_folder == '/'
+        start_folder = File.expand_path("..", start_folder)
       end
 
-      @_merged_configurations = read_base.merge(project_cfgs)
+      project_file
     end
 
   end

data/lib/swarm_cluster_cli_ope/node.rb

@@ -50,8 +50,7 @@ module SwarmClusterCliOpe
     # @return [OpenStruct]
     def info
       # path al file di cache
-      # TODO sarebbe da aggiornare ogni tanto, metti che uno non spegne mai il pc
-      path = "/tmp/.swarm_cluster_cli_info_cache_#{name}"
+      path = Time.now.strftime("/tmp/.swarm_cluster_cli_info_cache_#{name}-%Y%m%d%H")
       if File.exist?(path)
         i = JSON.parse(File.read(path), object_class: OpenStruct)
       else

data/lib/swarm_cluster_cli_ope/sync_configs/base.rb

@@ -0,0 +1,35 @@
+module SwarmClusterCliOpe
+  module SyncConfigs
+    class Base < Thor::Shell::Basic
+
+      #@return [String] nome del servizio dello stack
+      attr_accessor :service
+
+      # @param [Hash] configs
+      # @param [Continuation] stack_cfgs
+      def initialize(stack_cfgs, configs)
+        super()
+        @configs = configs
+
+        @service = configs[:service]
+        @stack_cfgs = stack_cfgs
+      end
+
+
+      delegate :stack_name, to: :@stack_cfgs
+
+      ##
+      # Funzione che dobbiamo sovrascrivere per identificare cosa fare quando scarichiamo i dati
+      def pull
+        raise "TO OVERRIDE"
+      end
+
+      ##
+      # Funzione che dobbiamo sovrascrivere per identificare cosa fare quando carichiamo i dati
+      def push
+        raise "TO OVERRIDE"
+      end
+
+    end
+  end
+end

data/lib/swarm_cluster_cli_ope/sync_configs/copy.rb

@@ -0,0 +1,35 @@
+module SwarmClusterCliOpe
+  module SyncConfigs
+    class Copy < Base
+
+      # @return [String]
+      def local_folder
+        @configs[:configs][:local]
+      end
+
+      # @return [String]
+      def remote_folder
+        @configs[:configs][:remote]
+      end
+
+      # @return [TrueClass, FalseClass]
+      def push
+        say "#{local_folder} -->> #{remote_folder}" if container.copy_in(local_folder,remote_folder)
+      end
+
+      # @return [TrueClass, FalseClass]
+      def pull
+        say "#{remote_folder} -->> #{local_folder}" if container.copy_out(remote_folder,local_folder)
+      end
+
+
+      private
+      # @return [SwarmClusterCliOpe::Models::Container]
+      def container
+        Models::Container.find_by_service_name(service, stack_name: stack_name)
+      end
+
+
+    end
+  end
+end

data/lib/swarm_cluster_cli_ope/sync_configs/rsync.rb

@@ -0,0 +1,74 @@
+module SwarmClusterCliOpe
+  module SyncConfigs
+    class Rsync < Base
+
+
+      # @return [String]
+      def local_folder
+        @configs[:configs][:local]
+      end
+
+      # @return [String]
+      def remote_folder
+        @configs[:configs][:remote]
+      end
+
+
+      # @return [SwarmClusterCliOpe::ShellCommandResponse]
+      def push
+        execute(direction: :up)
+      end
+
+      # @return [SwarmClusterCliOpe::ShellCommandResponse]
+      def pull
+        execute(direction: :down)
+      end
+
+
+      private
+      def execute(direction: :down)
+
+        # trovo il container del servizio
+        container = Models::Container.find_by_service_name(service, stack_name: stack_name)
+
+        if container.nil?
+          say "Container non trovato con #{stack_name}@##{service}"
+          exit 0
+        end
+
+
+        # trovo la cartella bindata e la relativa cartella sul nodo
+        volume = container.mapped_volumes.find { |v| v.destination == remote_folder and v.is_binded? }
+        if volume.nil?
+          say "Non ho trovato il volume bindato con questa destinazione all'interno del container #{remote_folder}"
+          exit 0
+        end
+
+        #costruisco il comando rsync fra cartella del nodo e cartella sul pc
+        cmd = ["rsync", "-zr", "--delete"]
+        if direction == :down
+          cmd << "#{volume.ssh_connection_path}/."
+          # creo la cartella in locale se non esiste
+          FileUtils.mkdir_p(local_folder)
+          cmd << local_folder
+        end
+        if direction == :up
+          cmd << "#{local_folder}/."
+          cmd << volume.ssh_connection_path
+        end
+
+        cmd = ShellCommandExecution.new(cmd)
+
+        say "Comando da eseguire:"
+        say "  #{cmd.string_command}"
+        if yes?("Confermare il comando?[y,yes]")
+          cmd.execute
+        end
+
+
+      end
+
+
+    end
+  end
+end

data/lib/swarm_cluster_cli_ope/sync_configs/sqlite3.rb

@@ -0,0 +1,8 @@
+module SwarmClusterCliOpe
+  module SyncConfigs
+    class Sqlite3 < Copy
+
+
+    end
+  end
+end

data/lib/swarm_cluster_cli_ope/version.rb

@@ -1,3 +1,3 @@
 module SwarmClusterCliOpe
-  VERSION = "0.1.4"
+  VERSION = "0.2.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: swarm_cluster_cli_ope
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.2.2
 platform: ruby
 authors:
 - Marino Bonetti
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-05 00:00:00.000000000 Z
+date: 2020-07-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -107,6 +107,10 @@ files:
 - lib/swarm_cluster_cli_ope/node.rb
 - lib/swarm_cluster_cli_ope/shell_command_execution.rb
 - lib/swarm_cluster_cli_ope/shell_command_response.rb
+- lib/swarm_cluster_cli_ope/sync_configs/base.rb
+- lib/swarm_cluster_cli_ope/sync_configs/copy.rb
+- lib/swarm_cluster_cli_ope/sync_configs/rsync.rb
+- lib/swarm_cluster_cli_ope/sync_configs/sqlite3.rb
 - lib/swarm_cluster_cli_ope/version.rb
 - lib/swarm_cluster_cli_ope/worker.rb
 - swarm_cluster_cli_ope.gemspec
@@ -133,7 +137,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.6
+rubygems_version: 3.0.8
 signing_key: 
 specification_version: 4
 summary: WIP Gemma per la gestione del cluster swarm