swarm_cluster_cli_ope 0.1.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '09565df25f695d7e64c5034d7daaa833ba640c61b2b326ad046601355f13f705'
+  data.tar.gz: c997f3969018ae3335e86987595b7c5e1bba6792477c6c343f27e291a1430f47
+SHA512:
+  metadata.gz: b1f2e55552084f16fd1b0f2bc9955113771212b52d5f9d508aac86a578e0bf1d95f2a513fa9b171e31cb7016d9899002331957d38fdc1e71afa0c1a677f95b59
+  data.tar.gz: a0daa2f6d6b4187d038eea485d65c88d5aa670760f99935d8115e4c8cccf6196f991b7e8f71a17881a44117f40a7d60cdde94a7d91707dc7eb154fb9ad70d4c1

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+.idea
+pkg

data/.ruby-gemset

@@ -0,0 +1 @@
+swarm_cluster_cli

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.5.3

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+## Changelog
+
+# 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

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in swarm_cluster_cli_ope.gemspec
+gemspec
+
+gem "rake", "~> 12.0"

data/Gemfile.lock

@@ -0,0 +1,39 @@
+PATH
+  remote: .
+  specs:
+    swarm_cluster_cli_ope (0.1.2)
+      activesupport
+      open4
+      thor (~> 1.0)
+      zeitwerk (~> 2.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    activesupport (6.0.2.2)
+      concurrent-ruby (~> 1.0, >= 1.0.2)
+      i18n (>= 0.7, < 2)
+      minitest (~> 5.1)
+      tzinfo (~> 1.1)
+      zeitwerk (~> 2.2)
+    concurrent-ruby (1.1.6)
+    i18n (1.8.2)
+      concurrent-ruby (~> 1.0)
+    minitest (5.14.0)
+    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)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake (~> 12.0)
+  swarm_cluster_cli_ope!
+
+BUNDLED WITH
+   1.17.3

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2020 Marino Bonetti
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,121 @@
+# SwarmClusterCliOpe
+WIP to translate
+Gemma per la gestione semplificata degli operatori con un cluster swarm
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'swarm_cluster_cli_ope'
+```
+
+And then execute:
+
+    $ bundle install
+
+Or install it yourself as:
+
+    $ gem install swarm_cluster_cli_ope
+
+## Usage
+
+Una volta installato lanciare il comando 
+
+```swarm_cluster_cli_ope install``` che si occuperà di configurare le varie impostazioni dell'ambiente
+
+FILE di configurazione base:
+```json
+{"version":"0.1.0","dev_mode":1,"log_level": "3","connections_maps":{"swm1": "swarm_node_1","swm2": "swarm_node_2","swm3": "swarm_node_3"}}
+```
+
+### LogLevel:
+0 ERROR
+1 WARN
+2 INFO
+3 DEBUG
+
+
+### Configuratione di un progetto
+Si occupa di generare nel progetto il file di configurazione in cui impostare impostazioni specifiche di progetto
+quali stack_name
+```shell script
+swarm_cli_ope configure_project STACK_NAME
+```
+
+### Configurazioni applicate nel progetto:
+```shell script
+swarm_cli_ope config
+```
+
+### Elenco di tutti gli stack disponibili:
+```shell script
+swarm_cli_ope stacks
+```
+
+
+### MC:
+Apre MC collegato al container del servizio specificato
+```shell script
+swarm_cli_ope mc SERVICE_NAME --stack-name=NOME_STACK
+```
+
+### SHELL:
+Apre una shell (default bash) collegato al container del servizio specificato
+```shell script
+swarm_cli_ope shell SERVICE_NAME --stack-name=NOME_STACK
+```
+
+### Elenco di tutti i servizi
+Se siamo nel progetto con il file di progetto vedremo comunque i servizi filtrati
+```shell script
+swarm_cli_ope services
+```
+
+filtrando per stack:
+  
+```shell script
+swarm_cli_ope services --stack-name=NOME_STACK
+```
+
+### Copia di files da/verso container attraverso il docker cp   
+```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
+
+Utilizzare `rsync_binded_from` per scaricare e `rsync_binded_to` per caricare
+
+
+```shell script
+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_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).
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+ 

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/exe/swarm_cli_ope

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+require_relative "../lib/swarm_cluster_cli_ope"
+
+SwarmClusterCliOpe::Cli.start

data/lib/swarm_cluster_cli_ope.rb

@@ -0,0 +1,8 @@
+require "zeitwerk"
+loader = Zeitwerk::Loader.for_gem
+loader.setup # ready!
+
+module SwarmClusterCliOpe
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/lib/swarm_cluster_cli_ope/cli.rb

@@ -0,0 +1,251 @@
+require 'thor'
+require 'mkmf'
+module SwarmClusterCliOpe
+
+  class Cli < Thor
+    include LoggerConcern
+    include ConfigurationConcern
+    include Thor::Actions
+
+    def self.exit_on_failure?
+      true
+    end
+
+    desc "install", "Creazione della configurazione base della gemma"
+
+    def install
+      #contolliamo se presente la configurazione base nella home
+      if Configuration.exist_base?
+        say "Configurazione già presente"
+      else
+        #se non presente allora chiediamo le varie configurazioni
+        lista = []
+        loop do
+          connection_name = ask("Aggiungi un server alla lista dei server Manager(inserire uri: ssh://server | unix:///socket/path:")
+          result = Node.info(connection_name)
+          node = Node.new(name: result.Name, connection_uri: connection_name)
+          say "Aggiungo #{node.name} che si connette con DOCKER_HOST=#{node.connection_uri}"
+          lista << node
+          break if no? "Vuoi inserire al server?[n,no]"
+        end
+        #scriviamo le varie configurazioni
+        cfg = cfgs
+        cfg.nodes = lista
+        cfg.save_base_cfgs
+      end
+
+    end
+
+    desc "config", "Visualizza le configurazioni mergiate (HOME + Project)"
+
+    def config
+      puts JSON.pretty_generate(cfgs.class.merged_configurations)
+    end
+
+
+    # DOCKER_HOST=ssh://swarm_node_1 docker stack ls --format="{{json .}}"
+    desc "stacks", "Lista degli stacks nel cluster"
+
+    def stacks
+      Models::Stack.all.each do |s|
+        puts s.name
+      end
+    end
+
+    desc "services", "lista dei servizi per uno stack"
+    option :stack_name, required: false, type: :string, default: cfgs.stack_name
+
+    def services
+      Models::Service.all(stack_name: options[:stack_name]).each do |s|
+        puts s.name
+      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
+
+    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")
+        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
+
+      end
+    end
+
+    desc "cp SRC DEST", "Copia la sorgente in destinazione"
+    option :stack_name, required: false, type: :string, default: cfgs.stack_name
+    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 :
+      il quale mi identifica l'inizio della PATH assoluta all'interno del  primo container del servizio
+      dove copiare i files
+    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])
+      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
+    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 :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])
+
+      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"
+    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 :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"
+
+    def rsync_binded_from
+      if yes? "Attenzione, i dati locali verranno sovrascritti/cancellati?[y,yes]"
+        rsync_binded(direction: :down, options: options)
+      end
+    end
+
+    desc "rsync_binded_to", "esegue un rsync verso la cartella bindata"
+    option :stack_name, required: false, type: :string, default: cfgs.stack_name
+    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"
+
+    def rsync_binded_to
+      if yes? "ATTENZIONE, i dati remoti verranno sovrascritti/cancellati da quelli locali?[y,yes]"
+        rsync_binded(direction: :up, options: options)
+      end
+    end
+
+
+    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
+      end
+
+
+      # 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
+
+      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