swarm_cluster_cli_ope 0.1.6 → 0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4d080e1fbcc49d24e180f7cae13bf99415e85b7ae7a443c175a8251486fd75f5
-  data.tar.gz: 6b4b0b8ffaf462a4f7ae9e7601276b40cf722860ecd3bfb1270a5734bbb6211d
+  metadata.gz: 473cc11423d57b9b40b361184587b1acdda0d14751b12266740eb98e1f1c7caa
+  data.tar.gz: 542e14fb88a4d40c34209853678e80fc0d2bddc90745aa9bd6eaee666e7fcf03
 SHA512:
-  metadata.gz: fce5856e48f7d73ff31aac4c26fb2d7c0c235f0c36ab8a6fda65e79b7696f48f35faff221d5e97de4bfd8183d704c76ce11b3534b311fcf6697580c88cfeba0d
-  data.tar.gz: 90c49135edaabb0d3e4f9abcb63880df81279159198429e803abcb96ac606a8ba908d4392375c52cda82ada9bcf95805d920b3e8a3d066525923daed3885c702
+  metadata.gz: 90fe0e391b0aa2eb12f1564153905db9fd294aa2817094da62dc1a7da7c3c663f7f94f99996d5f3c1e7818f1d8d214d2c1286fdefbe9eedfb932c3abdf224586
+  data.tar.gz: 24e26ab924509fbc0df1d03a67c59ec5d62d544a8cc0709f757012c2dcb6fd8915a049ad82ccec49316f19b4cdb65c1bac9f4c62e3a1c4231f5de7c316bbcbc1

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    swarm_cluster_cli_ope (0.1.6)
+    swarm_cluster_cli_ope (0.2)
       activesupport
       open4
       thor (~> 1.0)

data/README.md

@@ -36,6 +36,9 @@ 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 (.swarm_cluster_project)
@@ -98,11 +101,14 @@ nel file di configurazione creato nella home aggiungere la chiave "dev_mode":1 p
 
 ### 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
@@ -40,7 +43,9 @@ module SwarmClusterCliOpe
     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
-          stop_ssh_container.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
+
+        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,46 +154,73 @@ 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: true, type: :string, desc: "path della cartella dove sincronizzare il comando"
@@ -195,7 +232,7 @@ 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: true, type: :string, desc: "path della cartella dove sincronizzare il comando"
@@ -206,46 +243,54 @@ module SwarmClusterCliOpe
       end
     end
 
+    desc "stack_pull", "Si occupa di scaricare,utilizzando le configurazioni presenti, i dati dallo stack remoto"
+    long_desc <<-LONGDESC
+      le configurazioni sono contenute nell'array: sync_configs. \n
+      ogni configurazione è composta da: \n
+      { \n
+        service:"" \n
+        how:"" \n
+        configs:{ }\n
+      }\n
+      - service è il nome del servizio\n
+      - how è il come sincronizzare, definendo la tipologia:\n
+          - pg      -> DB\n TODO
+          - mysql   -> DB\n TODO
+          - sqlite3 -> DB\n 
+          - rsync   -> RSYNC\n
+      - configs:  è un hash con le configurazioni per ogni tipo di sincronizzazione\n
+    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 stack_pull
+      cfgs.env(options[:environment]) do |cfgs|
+        cfgs.sync_configurations.each do |sync|
+          sync.pull
+        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/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.6"
+  VERSION = "0.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: swarm_cluster_cli_ope
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: '0.2'
 platform: ruby
 authors:
 - Marino Bonetti
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-12 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