swarm_cluster_cli_ope 0.1.6 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4d080e1fbcc49d24e180f7cae13bf99415e85b7ae7a443c175a8251486fd75f5
-  data.tar.gz: 6b4b0b8ffaf462a4f7ae9e7601276b40cf722860ecd3bfb1270a5734bbb6211d
+  metadata.gz: 3d344913376cd573bd0c65e8b1e13b21c22cea8da6765d5c96962bb8117a345b
+  data.tar.gz: aba83b091bb644491f7f2159c24ed5809d624713439037e368d874a7b702e2bf
 SHA512:
-  metadata.gz: fce5856e48f7d73ff31aac4c26fb2d7c0c235f0c36ab8a6fda65e79b7696f48f35faff221d5e97de4bfd8183d704c76ce11b3534b311fcf6697580c88cfeba0d
-  data.tar.gz: 90c49135edaabb0d3e4f9abcb63880df81279159198429e803abcb96ac606a8ba908d4392375c52cda82ada9bcf95805d920b3e8a3d066525923daed3885c702
+  metadata.gz: 22e815330c638aead770d742b875961892650e73b68abed0b8fd897448d038ebbe4065a417073e9e4ce5039edaa40824eb617a43fa4200974cdb0363505fd83b
+  data.tar.gz: 63c7bff02ab029faf11f533a008f53b813381c0915524a501464ac75e52a24b3b930900af05c08d358945ea5587de1811eb93cdd2752cbe4bd3e22b1f8548962

data/CHANGELOG.md

@@ -1,9 +1,15 @@
 ## Changelog
 
+# 0.3
+- implementazione push pull con il comando **stacksync** di mysql
+
+# 0.2
+- implementazione comando **stacksync** con configurazioni nello stack per eseguire rsync di files e dump di sqlite3
+
 # 0.1.0
 - rsync dei files da/verso cluster su cartella condivisa
 - copia files direttamente in container
 - shell in servizio
 - mc in servizio
 - configurazioni globali
-- configurazioni di progetto
+- configurazioni di progetto

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    swarm_cluster_cli_ope (0.1.6)
+    swarm_cluster_cli_ope (0.3.1)
       activesupport
       open4
       thor (~> 1.0)
@@ -10,23 +10,23 @@ PATH
 GEM
   remote: https://rubygems.org/
   specs:
-    activesupport (6.0.3)
+    activesupport (6.0.3.2)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 0.7, < 2)
       minitest (~> 5.1)
       tzinfo (~> 1.1)
       zeitwerk (~> 2.2, >= 2.2.2)
-    concurrent-ruby (1.1.6)
-    i18n (1.8.2)
+    concurrent-ruby (1.1.7)
+    i18n (1.8.5)
       concurrent-ruby (~> 1.0)
-    minitest (5.14.0)
+    minitest (5.14.2)
     open4 (1.3.4)
     rake (12.3.3)
     thor (1.0.1)
     thread_safe (0.3.6)
     tzinfo (1.2.7)
       thread_safe (~> 0.1)
-    zeitwerk (2.3.0)
+    zeitwerk (2.4.0)
 
 PLATFORMS
   ruby

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)
@@ -92,17 +95,99 @@ 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
 ```
 
+### stacksync
+Si occupa di scaricare|caricare,utilizzando le configurazioni presenti, i dati dallo stack remoto
+
+Le configurazioni sono contenute nell'array: sync_configs.
+
+ogni configurazione è composta da:
+      
+```json 
+    { 
+       service:"" 
+       how:"" 
+       configs:{ }
+      }
+```
+
+- service è il nome del servizio
+- how è il come sincronizzare, definendo la tipologia:
+  - pg      -> DB TODO
+  - mysql   -> DB: dump del db con mysqldump
+  - 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)
+- mysql:
+  - local:  -> hash di configurazioni per il DB locale
+    - service: "db"                         -> nome del servizio nel compose locale, DEFAULT: quello definito sopra 
+    - mysql_password_env: "MYSQL_PASSWORD"  -> variabile ambiente interna al servizio contenente PASSWORD, DEFAULT: MYSQL_PASSWORD 
+    - mysql_user_env: "MYSQL_USER"          -> variabile ambiente interna al servizio contenente USERNAME, DEFAULT: MYSQL_USER 
+    - database_name_env: "MYSQL_DATABASE"       -> variabile ambiente interna al servizio contenente NOME DB, DEFAULT: MYSQL_DATABASE         
+  - remote: -> hash di configurazioni per il DB remoto
+    - service: "db"                         -> nome del servizio nel compose locale, DEFAULT: quello definito sopra 
+    - mysql_password_env: "MYSQL_PASSWORD"  -> variabile ambiente interna al servizio contenente PASSWORD, DEFAULT: MYSQL_PASSWORD
+    - mysql_user_env: "MYSQL_USER"          -> variabile ambiente interna al servizio contenente USERNAME, DEFAULT: MYSQL_USER
+    - database_name_env: "MYSQL_DATABASE"       -> variabile ambiente interna al servizio contenente NOME DB, DEFAULT: MYSQL_DATABASE
+
+#### EXAMPLE:
+Esempio di sincronizzazione di un file sqlite3 e una cartella
+
+```json 
+    {
+    "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"
+        }
+      }
+    ]
+    }
+```
+
+
 ## 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 test_1_stack
+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).
+Per simulare una sincronizzazione fra locale e remoto di un mysql, lanciamo lo stesso stack anche come compose, in modo
+da trovarci sulla stessa macchina con tutte e due le situazioni
+```shell script
+docker-compose up -f test_folder/test_1/docker-compose-local.yml -d
+```
+
+
+
+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,116 @@ 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 dump con mysql
+      ---- 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)
+
+      mysql:
+      -- local:  -> hash di configurazioni per il DB locale
+          "service": "db"                         -> nome del servizio nel compose locale, DEFAULT: quello definito sopra 
+          "mysql_password_env": "MYSQL_PASSWORD"  -> variabile ambiente interna al servizio contenente PASSWORD, DEFAULT: MYSQL_PASSWORD 
+          "mysql_user_env": "MYSQL_USER"          -> variabile ambiente interna al servizio contenente USERNAME, DEFAULT: MYSQL_USER 
+          "database_name_env": "MYSQL_DATABASE"       -> variabile ambiente interna al servizio contenente NOME DB, DEFAULT: MYSQL_DATABASE         
+      -- remote: -> hash di configurazioni per il DB remoto
+          "service": "db"                         -> nome del servizio nel compose locale, DEFAULT: quello definito sopra 
+          "mysql_password_env": "MYSQL_PASSWORD"  -> variabile ambiente interna al servizio contenente PASSWORD, DEFAULT: MYSQL_PASSWORD
+          "mysql_user_env": "MYSQL_USER"          -> variabile ambiente interna al servizio contenente USERNAME, DEFAULT: MYSQL_USER
+          "database_name_env": "MYSQL_DATABASE"       -> variabile ambiente interna al servizio contenente NOME DB, DEFAULT: MYSQL_DATABASE
+        
+
+      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|
+        sync_cfgs = cfgs.sync_configurations
+        if sync_cfgs.empty?
+          say "Attenzione, configurazioni di sincronizzazione vuoto. Leggere la documentazione"
+        else
+          sync_cfgs.each do |sync|
+            say "----------->>>>>>"
+            say "[ #{sync.class.name} ]"
+            sync.send(direction)
+            say "<<<<<<-----------"
+          end
+        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/commands/compose_container.rb

@@ -0,0 +1,12 @@
+module SwarmClusterCliOpe
+  module Commands
+    class ComposeContainer < Container
+
+      # Siamo in locale
+      def docker_host
+        ""
+      end
+
+    end
+  end
+end

data/lib/swarm_cluster_cli_ope/commands/container.rb

@@ -9,6 +9,13 @@ module SwarmClusterCliOpe
         end.execute
       end
 
+      def exec(container_id,cmd_str)
+        self.base_suffix_command = []
+        command do |cmd|
+          cmd.add("exec #{container_id} #{cmd_str}")
+        end.execute
+      end
+
       ##
       # Esegue il ps sui container, possibile filtrare passando nome stack e/o nome servizio
       # @param [String] service_name

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,46 @@ module SwarmClusterCliOpe
       nodes.find { |c| c.id == node_id }
     end
 
+    ##
+    # Indica il nome del progetto locale compose, quella parte di nome che viene attaccata in fronte
+    # ad ogni nome di servizio locale, e che come default è il nome della cartella in cui risiede
+    # il docker-compose.yml file
+    # @return [String]
+    def local_compose_project_name
+      File.basename(FileUtils.pwd)
+    end
+
+    ##
+    # Elenco di tutte le configurazioni di sincronizzazione
+    # @return [Array]
+    def sync_configurations
+      cfgs = merged_configurations[:sync_configs]
+      return [] if cfgs.nil? or !cfgs.is_a?(Array)
+      cfgs.collect do |c|
+
+        case c[:how]
+        when 'sqlite3'
+          SyncConfigs::Sqlite3.new(self, c)
+        when 'rsync'
+          SyncConfigs::Rsync.new(self, c)
+        when 'mysql'
+          SyncConfigs::Mysql.new(self, c)
+        else
+          logger.error { "CONFIGURAIONE NON PREVISTA: #{c[:how]}" }
+          nil
+        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 +210,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 +224,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/models/compose_container.rb

@@ -0,0 +1,17 @@
+module SwarmClusterCliOpe
+  module Models
+    class ComposeContainer < Container
+
+      # @return [SwarmClusterCliOpe::Models::ComposeContainer]
+      def self.find_by_service_name(service_name, stack_name: '')
+        res = ShellCommandExecution.new("docker inspect #{[stack_name, service_name, "1"].compact.join("_".strip)}").execute
+        self.new(JSON.parse(res.raw_result[:stdout]).first)
+      end
+
+      def mapped_uri_connection
+        nil
+      end
+
+    end
+  end
+end

data/lib/swarm_cluster_cli_ope/models/container.rb

@@ -4,7 +4,7 @@ module SwarmClusterCliOpe
 
       #@return [String]
       attr_accessor :name
-      #@return [String]
+      #@return [String] id del container
       attr_accessor :id
       #@return [String] nome dell'immagine
       attr_accessor :image
@@ -51,6 +51,12 @@ module SwarmClusterCliOpe
         docker_command.cp("#{id}:#{src}", dest).success?
       end
 
+      ##
+      # Esegue il comando passato
+      def exec(cmd)
+        docker_command.exec(id, cmd)
+      end
+
       ##
       # Ritorna il connection_uri del nodo che ospita il container
       # @return [String]

data/lib/swarm_cluster_cli_ope/models/service.rb

@@ -19,7 +19,6 @@ module SwarmClusterCliOpe
 
       ##
       # Containers del servizio
-
       # @return [Array<SwarmClusterCliOpe::Container>]
       def containers
         tasks.collect { |t| t.container }

data/lib/swarm_cluster_cli_ope/sync_configs/base.rb

@@ -0,0 +1,44 @@
+module SwarmClusterCliOpe
+  module SyncConfigs
+    class Base < Thor::Shell::Basic
+      include LoggerConcern
+      #@return [String] nome del servizio dello stack
+      attr_accessor :service
+
+      #@return [Hash] configurazioni di sincro
+      attr_accessor :configs
+
+      # @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
+
+      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/copy.rb

@@ -0,0 +1,31 @@
+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
+
+
+
+
+
+    end
+  end
+end

data/lib/swarm_cluster_cli_ope/sync_configs/env_configs.rb

@@ -0,0 +1,77 @@
+module SwarmClusterCliOpe
+  module SyncConfigs
+    ##
+    # Classe per la gestione dell'ambiente differente fra local e remote
+    # sono presenti le variabili di classe per definire una minima DSL per poter definire le variabili
+    # disponibili e i default da utilizzare
+    class EnvConfigs
+      # @param [Hash] configs
+      # @param [SwarmClusterCliOpe::SyncConfigs::Base] sync_configs
+      # @param [Lambda] lambda che ritorna il container Istanza container su cui la
+      def initialize(sync_configs, configs, container)
+        @configs = configs
+        @sync_configs = sync_configs
+        @lambda_container = container
+      end
+
+      ##
+      # Metodo che richiama la lambda della generazione del container al momento che ne
+      # è proprio necessario
+      def container
+        @container ||= @lambda_container.call
+      end
+
+      # @return [String]
+      def service_name
+        @configs[:service] || @sync_configs.service
+      end
+
+
+      ##
+      # Costruisce i metodi che restituiscono i valori delle configurazioni
+      #
+      # @param [String,Symbol] name -> nome della stringa con cui viene generato il metodo
+      # @param [String,Symbol] default_env -> nome env default nel caso non sia passato
+      # @param [String,Symbol] configuration_name -> nome della configurazione da utilizzare per estrapolare la configurazione
+      #                                           in automatico viene tenuto conto se cercare per la versione
+      #                                           con _env o senza....precedenza SENZA
+      def self.define_cfgs(name, default_env:, configuration_name:)
+        configuration_name ||= name
+
+        define_method(name) do
+          return self.instance_variable_get("@#{name}") if self.instance_variable_defined?("@#{name}")
+
+          #valore restituito direttamente dalla configurazione
+          if @configs.key?(configuration_name)
+            value = @configs["#{configuration_name}".to_sym]
+          else
+            env_var = @configs["#{configuration_name}_env".to_sym] || default_env
+            value = find_env_file_variable(env_var)
+          end
+          self.instance_variable_set("@#{name}", value)
+        end
+
+      end
+
+
+      private
+
+      ##
+      # Estrae l'env dal container e ne tiene in memoria una copia, in modo da non fare multiple chiamate
+      def env
+        @env ||= container.exec("env").raw_result[:stdout].split("\n").collect { |v| v.split('=') }.to_h
+      end
+
+      def find_env_file_variable(env_var)
+        if env_var.match?(/_FILE$/)
+          # dobbiamo controllare la presenza del file e salvarci il contenuto
+          nome_file = env[env_var.to_s]
+          container.exec("cat #{nome_file}").raw_result[:stdout]
+        else
+          # env normale, dobbiamo ricavarlo dal container
+          env[env_var.to_s]
+        end
+      end
+    end
+  end
+end

data/lib/swarm_cluster_cli_ope/sync_configs/mysql.rb

@@ -0,0 +1,78 @@
+module SwarmClusterCliOpe
+  module SyncConfigs
+    class Mysql < Base
+
+      # @return [TrueClass, FalseClass]
+      def pull
+        resume('pull')
+        if yes?("Confermare il comando?[y,yes]")
+          tmp_file = "/tmp/#{Time.now.to_i}.sql.gz"
+          container.exec("bash -c 'mysqldump  -u #{remote.mysql_user} --password=#{remote.mysql_password} #{remote.database_name} | gzip -c -f' > #{tmp_file}")
+          local_container.copy_in(tmp_file, tmp_file)
+          local_container.exec("bash -c 'zcat #{tmp_file} | mysql  -u #{local.mysql_user} --password=#{local.mysql_password} #{local.database_name}'")
+        end
+        true
+      end
+
+      # @return [TrueClass, FalseClass]
+      def push
+        resume('PUSH')
+        if yes?("ATTENZIONE !!!!!!PUSH!!!!! - Confermare il comando?[y,yes]")
+          tmp_file = "/tmp/#{Time.now.to_i}.sql.gz"
+          local_container.exec("bash -c 'mysqldump  -u #{local.mysql_user} --password=#{local.mysql_password} #{local.database_name} | gzip -c -f' > #{tmp_file}")
+          container.copy_in(tmp_file, tmp_file)
+          container.exec("bash -c 'zcat #{tmp_file} | mysql  -u #{remote.mysql_user} --password=#{remote.mysql_password} #{remote.database_name}'")
+        end
+        true
+      end
+
+      # @return [SwarmClusterCliOpe::SyncConfigs::Mysql::EnvConfigs]
+      def remote
+        EnvConfigs.new(self, @configs[:configs][:remote] || {}, -> { container })
+      end
+
+      # @return [SwarmClusterCliOpe::SyncConfigs::Mysql::EnvConfigs]
+      def local
+        EnvConfigs.new(self, @configs[:configs][:local] || {}, -> { local_container })
+      end
+
+
+      ##
+      # Classe interna che rappresenta le configurazioni del DB
+      class EnvConfigs < SwarmClusterCliOpe::SyncConfigs::EnvConfigs
+
+        define_cfgs :database_name, default_env: "MYSQL_DATABASE", configuration_name: :database_name
+        define_cfgs :mysql_user, default_env: "MYSQL_USER", configuration_name: :mysql_user
+        define_cfgs :mysql_password, default_env: "MYSQL_PASSWORD", configuration_name: :mysql_password
+
+      end
+
+
+      ##
+      # Funzione che ricapitola le informazioni utilizzate per eseguire l'operazione
+      def resume(direction)
+        puts "RESUME - #{direction}
+            service: #{service}
+            local:
+              service_name: #{local.service_name}
+              database_name: #{local.database_name}
+              mysql_user: #{local.mysql_user}
+              mysql_password: #{local.mysql_password}
+            remote:
+              service_name: #{remote.service_name}
+              database_name: #{remote.database_name}
+              mysql_user: #{remote.mysql_user}
+              mysql_password: #{remote.mysql_password}"
+
+      end
+
+      private
+
+      def local_container
+        # il nome dello stack del compose usiamo come standard il nome della cartella, come lo fà già composer di default
+        Models::ComposeContainer.find_by_service_name(local.service_name, stack_name: @stack_cfgs.local_compose_project_name)
+      end
+
+    end
+  end
+end

data/lib/swarm_cluster_cli_ope/sync_configs/rsync.rb

@@ -0,0 +1,71 @@
+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)
+
+        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.3.1"
 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.3.1
 platform: ruby
 authors:
 - Marino Bonetti
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2020-05-12 00:00:00.000000000 Z
+date: 2020-09-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -90,6 +90,7 @@ files:
 - lib/swarm_cluster_cli_ope.rb
 - lib/swarm_cluster_cli_ope/cli.rb
 - lib/swarm_cluster_cli_ope/commands/base.rb
+- lib/swarm_cluster_cli_ope/commands/compose_container.rb
 - lib/swarm_cluster_cli_ope/commands/container.rb
 - lib/swarm_cluster_cli_ope/commands/service.rb
 - lib/swarm_cluster_cli_ope/commands/swarm.rb
@@ -99,6 +100,7 @@ files:
 - lib/swarm_cluster_cli_ope/logger_concern.rb
 - lib/swarm_cluster_cli_ope/manager.rb
 - lib/swarm_cluster_cli_ope/models/base.rb
+- lib/swarm_cluster_cli_ope/models/compose_container.rb
 - lib/swarm_cluster_cli_ope/models/container.rb
 - lib/swarm_cluster_cli_ope/models/mapped_volume.rb
 - lib/swarm_cluster_cli_ope/models/service.rb
@@ -107,6 +109,12 @@ 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/env_configs.rb
+- lib/swarm_cluster_cli_ope/sync_configs/mysql.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 +141,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