swarm_cluster_cli_ope 0.5.0.pre.2 → 0.5.1

data/lib/swarm_cluster_cli_ope/kubernetes/pod.rb

@@ -0,0 +1,144 @@
+module SwarmClusterCliOpe
+  module Kubernetes
+    ##
+    # Interfaccia per la comunicazione con il POD
+    class Pod
+      include LoggerConcern
+
+
+      #@return [Hash]
+      attr_accessor :pod_description
+
+      #@return [String]
+      attr_accessor :context
+
+      # @param [Hash] pod_description -> hash con le configurazioni ritornate da kubectl
+      # @param [String] context -> se non presente utiliziamo l'attuale
+      def initialize(pod_description, context:)
+        @pod_description = pod_description.to_h.deep_symbolize_keys
+        @context = context
+      end
+
+
+      # @return [String]
+      def name
+        @pod_description[:metadata][:name]
+      end
+
+      def namespace
+        @pod_description[:metadata][:namespace]
+      end
+
+      # @param [String,Array<String>] cmd -> comando da passare a kubectl exec -- CMD
+      # @return [SwarmClusterCliOpe::ShellCommandResponse]
+      def exec(cmd)
+        base_cmd(["exec", name, "--", cmd].flatten).execute
+      end
+
+      ##
+      # Appende solamente la parte base dei comandi
+      # @return [SwarmClusterCliOpe::ShellCommandExecution]
+      # @param [String,Array<String>] cmd
+      def base_cmd(cmd)
+        ShellCommandExecution.new([base_kubectl_cmd_env, cmd].flatten)
+      end
+
+
+      ##
+      # Comando per la copia del file
+      # @param [String] src
+      # @param [String] dst
+      # @return [SwarmClusterCliOpe::ShellCommandExecution]
+      def cp_in(src, dst)
+        base_cmd(["cp", src, "#{name}:#{dst}"])
+      end
+
+      ##
+      # Comando per la copia del file dal container
+      # @param [String] src
+      # @param [String] dst
+      # @return [SwarmClusterCliOpe::ShellCommandExecution]
+      def cp_out(src, dst)
+        base_cmd(["cp", "#{name}:#{src}", dst])
+      end
+
+      ##
+      # Proxy class per essere simili al container per swarm
+      # @return [TrueClass, FalseClass]
+      # @param [String] src
+      # @param [String] dst
+      def copy_in(src, dst)
+        cp_in(src, dst).execute.success?
+      end
+
+      # @param [String] src
+      # @param [String] dst
+      # @return [TrueClass, FalseClass]
+      def copy_out(src, dst)
+        cp_out(src, dst).execute.success?
+      end
+
+
+      # @param [String] selector
+      # @return [Pod]
+      # @param [nil,String] namespace ->  se la sciato vuoto utiliziamo il namespace corrente
+      # @param [String, nil] context -> contesto di kubectl, nel caso utilizziamo il corrente
+      def self.find_by_selector(selector, namespace: nil, context: nil)
+
+        base_cmd = ["kubectl"]
+        base_cmd << "--namespace=#{namespace}" unless namespace.blank?
+        base_cmd << "--context=#{context}" unless context.blank?
+        base_cmd << "get pod"
+        base_cmd << "--selector=#{selector}"
+        base_cmd << "--output=json"
+
+        cmd = ShellCommandExecution.new(base_cmd)
+        ris = cmd.execute(allow_failure: true)
+        if ris.failed?
+          puts "Problemi nella ricerca del pod"
+          exit
+        else
+          if ris.single_obj[:items].empty?
+            puts  "non abbiamo trovato il pod"
+            exit
+          else
+            self.new(ris.single_obj[:items].first, context: context)
+          end
+        end
+      end
+
+      def self.find_by_name(name, namespace: nil, context: nil)
+        base_cmd = ["kubectl"]
+        base_cmd << "--namespace=#{namespace}" unless namespace.blank?
+        base_cmd << "--context=#{context}" unless context.blank?
+        base_cmd << "get pod #{name}"
+        base_cmd << "--output=json"
+
+        cmd = ShellCommandExecution.new(base_cmd)
+        ris = cmd.execute(allow_failure: true)
+        if ris.failed?
+          puts "Problemi nella ricerca del pod"
+          exit
+        else
+          self.new(ris.single_obj, context: context)
+        end
+      end
+
+
+      private
+
+      ##
+      # Array con i comandi base di kubectl
+      # @return [Array<String>]
+      def base_kubectl_cmd_env(json: false)
+        base_cmd = ["kubectl"]
+        base_cmd << "--namespace=#{namespace}" unless namespace.blank?
+        base_cmd << "--context=#{context}" unless context.blank?
+        base_cmd << "--output=json" if json
+        base_cmd
+      end
+
+
+    end
+  end
+end

data/lib/swarm_cluster_cli_ope/kubernetes/sync_configs/base_decorator.rb

@@ -0,0 +1,28 @@
+require 'active_support/concern'
+module SwarmClusterCliOpe
+  module Kubernetes
+    module SyncConfigs
+      module BaseDecorator
+        extend ActiveSupport::Concern
+
+        included do
+
+          delegate :namespace, :context, to: :@stack_cfgs
+
+          private
+
+          # @return [SwarmClusterCliOpe::Kubernetes::Pod]
+          def container
+            return @service if @service.is_a? SwarmClusterCliOpe::Kubernetes::Pod
+            @_container ||= Pod.find_by_selector(service, namespace: namespace, context: context)
+          end
+
+        end
+
+        #  module ClassMethods
+
+        #  end
+      end
+    end
+  end
+end

data/lib/swarm_cluster_cli_ope/kubernetes/sync_configs/mysql.rb

@@ -0,0 +1,10 @@
+module SwarmClusterCliOpe
+  module Kubernetes
+    module SyncConfigs
+      class Mysql < SwarmClusterCliOpe::SyncConfigs::Mysql
+
+        include BaseDecorator
+      end
+    end
+  end
+end

data/lib/swarm_cluster_cli_ope/kubernetes/sync_configs/post_gres.rb

@@ -0,0 +1,11 @@
+module SwarmClusterCliOpe
+  module Kubernetes
+    module SyncConfigs
+      class PostGres < SwarmClusterCliOpe::SyncConfigs::PostGres
+
+        include BaseDecorator
+
+      end
+    end
+  end
+end

data/lib/swarm_cluster_cli_ope/kubernetes/sync_configs/rsync.rb

@@ -0,0 +1,125 @@
+module SwarmClusterCliOpe
+  module Kubernetes
+    module SyncConfigs
+      class Rsync < SwarmClusterCliOpe::SyncConfigs::Base
+
+        include BaseDecorator
+
+        # @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"
+            exit
+          end
+
+
+          if yes? "Attenzione, i dati locali o remoti verranno sovrascritti/cancellati?[y,yes]"
+
+            podname = container.name
+
+            if namespace.nil?
+              say "Mancata configurazione del namespace tramite argomento o .swarm_cluster_project"
+              exit
+            end
+
+            cmd = container.exec(['bash -c "apt update && apt install -yq rsync psmisc"'])
+            if cmd.failed?
+              puts "Problemi nell'installazione di rsync nel pod"
+            else
+              cmd = container.cp_in(File.expand_path("../../rsync_cfgs/rsyncd.conf", __FILE__), "/tmp/.")
+              copy_1 = cmd.execute.failed?
+              cmd = container.cp_in(File.expand_path("../../rsync_cfgs/rsyncd.secrets", __FILE__), "/tmp/.")
+              copy_2 = cmd.execute.failed?
+              cmd = container.exec(['bash -c "chmod 600 /tmp/rsyncd.secrets  && chown root /tmp/*"'])
+              chmod = cmd.failed?
+              if copy_1 or copy_2 or chmod
+                puts "problema nella copia dei file di configurazione nel pod"
+              else
+
+                begin
+                  cmd = container.exec('bash -c "rsync --daemon --config=/tmp/rsyncd.conf  --verbose --log-file=/tmp/rsync.log"')
+                  if cmd.failed?
+                    say "Rsync non Inizializzato"
+                  else
+                    begin
+                      local_port = rand(30000..40000)
+
+                      p = IO.popen(container.base_cmd("port-forward #{podname} #{local_port}:873").string_command)
+                      pid = p.pid
+                      say "PID in execuzione port forward:#{pid}"
+
+                      begin
+
+                        sleep 1
+
+                        # lanciamo il comando quindi per far rsync
+                        rsync_command = [
+                          "rsync -az --no-o --no-g",
+                          "--delete",
+                          "--password-file=#{ File.expand_path("../../rsync_cfgs/password", __FILE__)}"
+                        ]
+
+                        if direction == :up
+                          rsync_command << "#{local_folder}/."
+                          rsync_command << "rsync://root@0.0.0.0:#{local_port}/archives#{remote_folder}"
+                        else
+                          rsync_command << "rsync://root@0.0.0.0:#{local_port}/archives#{remote_folder}/."
+                          rsync_command << local_folder
+                        end
+                        say "Eseguo rsync #{rsync_command.join(" ")}"
+
+                        cmd = ShellCommandExecution.new(rsync_command)
+                        cmd.execute
+
+                      ensure
+                        sleep 1
+                        say "Stoppo porta forwarded"
+                        Process.kill("INT", pid)
+                      end
+                    ensure
+                      say "Tolgo il servizio di rsyn"
+                      container.exec('bash -c "killall rsync"')
+                    end
+                  end
+
+                ensure
+                  say "Eseguo pulizia configurazioni caricate"
+                  container.exec('bash -c "rm -fr /tmp/rsyncd*"')
+                end
+
+              end
+
+            end
+
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/swarm_cluster_cli_ope/kubernetes/sync_configs/sqlite3.rb

@@ -0,0 +1,9 @@
+module SwarmClusterCliOpe
+  module Kubernetes
+    module SyncConfigs
+      class Sqlite3 < SwarmClusterCliOpe::SyncConfigs::Sqlite3
+        include BaseDecorator
+      end
+    end
+  end
+end

data/lib/swarm_cluster_cli_ope/logger_concern.rb

@@ -6,7 +6,7 @@ module SwarmClusterCliOpe
       return LoggerConcern.const_get("LOGGER") if LoggerConcern.const_defined?("LOGGER")
       logger = Logger.new(STDOUT)
       LoggerConcern.const_set("LOGGER", logger)
-      logger.level = case Configuration.instance.logger_level
+      logger.level = case BaseConfiguration.instance.logger_level
                      when "0"
                        Logger::ERROR
                      when "1"

data/lib/swarm_cluster_cli_ope/shell_command_response.rb

@@ -1,8 +1,8 @@
 require 'forwardable'
 
 module SwarmClusterCliOpe
-##
-# Identifica una risposta dalla shell
+  ##
+  # Identifica una risposta dalla shell
   class ShellCommandResponse
     extend Forwardable
     include LoggerConcern
@@ -28,9 +28,22 @@ module SwarmClusterCliOpe
     ##
     # Risultato, essendo sempre composto da una lista di righe in formato json, ritorniamo un array di json
     # @param [Object] object_class
-    # @return [Array<object_class>]
-    def result(object_class: OpenStruct)
-      raw_result[:stdout].split("\n").collect { |s| object_class.new(JSON.parse(s)) }
+    # @return [Array<object_class>,Object]
+    def result(object_class: OpenStruct, single: false)
+      #tento prima di estrapolare direttamente da json e sucessivamente come array
+      if single
+        # questo per k8s, dato che abbiamo come risposta un json vero
+        object_class.new(JSON.parse(raw_result[:stdout]))
+      else
+        # questo nel caso siamo in swarm che ci ritorna un array di json
+        raw_result[:stdout].split("\n").collect { |s| object_class.new(JSON.parse(s)) }
+      end
+    end
+
+    # @param [Class<OpenStruct>] object_class
+    # @return [Object]
+    def single_obj(object_class: OpenStruct)
+      result(object_class: object_class, single: true)
     end
 
     #

data/lib/swarm_cluster_cli_ope/stack_sync_concern.rb

@@ -0,0 +1,135 @@
+require 'active_support/concern'
+
+module SwarmClusterCliOpe
+  module StackSyncConcern
+    extend ActiveSupport::Concern
+
+    included do
+
+      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 (o nel caso  di k8s una stringa da utilizzare come selettore labels)
+      - 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_password: "root"                -> valore in chiaro, in sostituzione della variabile ambiente, DEFAULT: root
+        - mysql_user_env: "MYSQL_USER"          -> variabile ambiente interna al servizio contenente USERNAME, DEFAULT: MYSQL_USER 
+        - mysql_user: "root"                    -> valore in chiaro, in sostituzione della variabile ambiente, DEFAULT: root
+        - database_name_env: "MYSQL_DATABASE"   -> variabile ambiente interna al servizio contenente NOME DB, DEFAULT: MYSQL_DATABASE         
+        - database_name: "nome_db"       -> valore in chiaro, in sostituzione della variabile ambiente         
+      --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_password: "root"                -> valore in chiaro, in sostituzione della variabile ambiente, DEFAULT: root
+        - mysql_user_env: "MYSQL_USER"          -> variabile ambiente interna al servizio contenente USERNAME, DEFAULT: MYSQL_USER 
+        - mysql_user: "root"              -> valore in chiaro, in sostituzione della variabile ambiente, DEFAULT: root
+        - database_name_env: "MYSQL_DATABASE"       -> variabile ambiente interna al servizio contenente NOME DB, DEFAULT: MYSQL_DATABASE         
+        - database_name: "MYSQL_DATABASE"       -> valore in chiaro, in sostituzione della variabile ambiente     
+      pg:
+      --local:  -> hash di configurazioni per il DB locale
+        - service: "db"                         -> nome del servizio nel compose locale, DEFAULT: quello definito sopra 
+        - pg_password_env: "POSTGRES_USER"      -> variabile ambiente interna al servizio contenente PASSWORD, DEFAULT: POSTGRES_PASSWORD 
+        - pg_password: ""                       -> valore in chiaro, in sostituzione della variabile ambiente
+        - pg_user_env: "POSTGRES_USER"          -> variabile ambiente interna al servizio contenente USERNAME, DEFAULT: POSTGRES_USER 
+        - pg_user: "postgres"                   -> valore in chiaro, in sostituzione della variabile ambiente, DEFAULT: postgres
+        - database_name_env: "POSTGRES_DB"      -> variabile ambiente interna al servizio contenente NOME DB, DEFAULT: POSTGRES_DB         
+        - database_name: "nome_db"              -> valore in chiaro, in sostituzione della variabile ambiente             
+      --remote: -> hash di configurazioni per il DB remoto
+        - service: "db"                         -> nome del servizio nel compose locale, DEFAULT: quello definito sopra 
+        - pg_password_env: "POSTGRES_USER"      -> variabile ambiente interna al servizio contenente PASSWORD, DEFAULT: POSTGRES_PASSWORD 
+        - pg_password: ""                       -> valore in chiaro, in sostituzione della variabile ambiente
+        - pg_user_env: "POSTGRES_USER"          -> variabile ambiente interna al servizio contenente USERNAME, DEFAULT: POSTGRES_USER 
+        - pg_user: "postgres"                   -> valore in chiaro, in sostituzione della variabile ambiente, DEFAULT: postgres
+        - database_name_env: "POSTGRES_DB"      -> variabile ambiente interna al servizio contenente NOME DB, DEFAULT: POSTGRES_DB         
+        - database_name: "nome_db"              -> valore in chiaro, in sostituzione della variabile ambiente     
+              
+
+      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
+
+      def stacksync(direction)
+        direction = case direction
+                    when 'push'
+                      :push
+                    when 'pull'
+                      :pull
+                    else
+                      raise "ONLY [push|pull] action accepted"
+                    end
+
+        if direction == :push
+          unless yes? "ATTENZIONE STAI FACENDO PUSH, proseguire????[y,yes]"
+            exit "OK, CIAO"
+          end
+        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 "COMPLETE"
+              say "<<<<<<-----------"
+            end
+          end
+        end
+      end
+
+
+    end
+
+    #  module ClassMethods
+
+    #  end
+  end
+end