swarm_cluster_cli_ope 0.1.3 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b8fee145923cdf0f180c7404c176821cfbb09ac431e1a91639f9fecc618fe324
-  data.tar.gz: d97c1c9cbe65e2357e41a41dab273eb6408b2af9df22f8b1fc0ce5fcee9d1f3d
+  metadata.gz: de6a7a1c00385430cb66e44f3fc8c02bac60bc5c930223c9cf56d592205d4963
+  data.tar.gz: 6e400a291bc159ac2e6149f55fe46cbe7dcdeb84b391ee4d7f93c211d19625d2
 SHA512:
-  metadata.gz: 0c3c0e3644a37319ce6661f39359e7de66ea94055a21816550f3c66d8446de25ffe854e80324bc373f68870415e7faf3d882a9b1c095099b589b92b81865c11e
-  data.tar.gz: 8a900ec0601caeb34e6f4a4350767e2850724af3ef6bb97fe2e38f34792c287cff3020194a7df4a6a4b0e95c564032f5228148a6b5c55e1064b65b6d36f0fa56
+  metadata.gz: e680840f5518ac667362afde85caca8f10a86bbb77cc122bd53580284e7ee8c6f365bc0b5b0f158eb494a97431765fd9cf057554c6ed20d3e10ef91779cd1dc3
+  data.tar.gz: 3976388f15a0fe1fd34efe15f2977f3b21d5167c7bbbf3d534c5ab0c10e1b34126110f36e00f186c3cd66b8456929db58585e29a414d6799f1a66b69352e7b31

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    swarm_cluster_cli_ope (0.1.3)
+    swarm_cluster_cli_ope (0.2.1)
       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,62 @@ module SwarmClusterCliOpe
       end
     end
 
+    desc "stacksync DIRECTION", "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 
+      ---- rsync   -> RSYNC
+      - configs:  è un hash con le configurazioni per ogni tipo di sincronizzazione
+    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|
+          sync.send(direction)
+        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,51 @@ 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
+
+        logger.debug { "CONFIGS[#{@environment}]: #{project_cfgs.inspect}" }
+        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
+        container.copy_in(local_folder,remote_folder)
+      end
+
+      # @return [TrueClass, FalseClass]
+      def pull
+        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.3"
+  VERSION = "0.2.1"
 end

data/swarm_cluster_cli_ope.gemspec

@@ -10,15 +10,15 @@ Gem::Specification.new do |spec|
   spec.description = "Gestione di varie operazioni come sincronia con le cartelle bindate dei container (rsync) up o
                         down e possibilità di scaricare/caricare i file direttamente all'interno del cluster, in
                         modo facilitato"
-  spec.homepage = "https://gitlab.archimedianet.it/sistemi/swarm_cluster_cli_ope"
+  spec.homepage = "https://github.com/ArchimediaZerogroup/swarm_cluster_cli_ope"
   spec.license = "MIT"
   spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
 
   spec.metadata["allowed_push_host"] = 'https://rubygems.org/'
 
   spec.metadata["homepage_uri"] = spec.homepage
-  # spec.metadata["source_code_uri"] = "TODO: Put your gem's public repo URL here."
-  # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+  spec.metadata["source_code_uri"] = "https://github.com/ArchimediaZerogroup/swarm_cluster_cli_ope"
+  spec.metadata["changelog_uri"] = "https://github.com/ArchimediaZerogroup/swarm_cluster_cli_ope/blob/master/CHANGELOG.md"
 
   # Specify which files should be added to the gem when it is released.
   # The `git ls-files -z` loads the files in the RubyGem that have been added into git.

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: swarm_cluster_cli_ope
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.2.1
 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,15 +107,21 @@ 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
-homepage: https://gitlab.archimedianet.it/sistemi/swarm_cluster_cli_ope
+homepage: https://github.com/ArchimediaZerogroup/swarm_cluster_cli_ope
 licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org/
-  homepage_uri: https://gitlab.archimedianet.it/sistemi/swarm_cluster_cli_ope
+  homepage_uri: https://github.com/ArchimediaZerogroup/swarm_cluster_cli_ope
+  source_code_uri: https://github.com/ArchimediaZerogroup/swarm_cluster_cli_ope
+  changelog_uri: https://github.com/ArchimediaZerogroup/swarm_cluster_cli_ope/blob/master/CHANGELOG.md
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -131,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