swarm_cluster_cli_ope 0.4 → 0.5.0.pre.3

data/lib/swarm_cluster_cli_ope/configuration.rb

@@ -8,17 +8,8 @@ module SwarmClusterCliOpe
   # Classe per la gestione delle configurazioni, unisce le configurazioni di base alle configurazioni di progetto;
   # le quali sono salvate nel file di configurazione del progetto .swarm_cluster_project sottoforma di json
   # che vengono mergiate sulle configurazioni base
-  class Configuration
-    include Singleton
-    include LoggerConcern
+  class Configuration < BaseConfiguration
 
-    #@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)
 
     ##
     # Lista di nodi su cui lavorare
@@ -28,19 +19,6 @@ 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
@@ -80,77 +58,14 @@ module SwarmClusterCliOpe
       self
     end
 
-    # @return [String,NilClass] nome dello stack del progetto se configurato
-    def stack_name
-      return nil unless self.class.exist_base?
-      @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
-      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
-      "0"
-    end
-
-    ##
-    # Siamo in sviluppo?
-    # @return [TrueClass, FalseClass]
-    def development_mode?
-      return false unless self.class.exist_base?
-      merged_configurations.key?(:dev_mode)
-    end
-
-    ##
-    # Controlla se esiste il file di configurazione base, nella home dell'utente
-    def self.exist_base?
-      File.exist?(base_cfg_path)
-    end
-
-
     ##
     # Salva le configurazioni base in HOME
     def save_base_cfgs
-      FileUtils.mkdir_p(File.dirname(self.class.base_cfg_path))
-      File.open(self.class.base_cfg_path, "wb") do |f|
-        f.write({
-                  version: SwarmClusterCliOpe::VERSION,
-                  connections_maps: nodes.collect { |k| [k.name, k.connection_uri] }.to_h
-                }.to_json)
-      end
-    end
-
-    ##
-    # 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(with_env: @environment)), "wb") do |f|
-          f.write({
-                    stack_name: stack_name,
-                    version: VERSION
-                  }.to_json)
-        end
+      super do |obj|
+        obj.merge({connections_maps: nodes.collect { |k| [k.name, k.connection_uri] }.to_h})
       end
     end
 
-    # @return [String] path to base home configurations
-    def self.base_cfg_path
-      File.join(ENV['HOME'], '.swarm_cluster', 'config.json')
-    end
 
     # @return [SwarmClusterCliOpe::Node]
     # @param [String] node nome del nodo
@@ -173,41 +88,8 @@ module SwarmClusterCliOpe
       File.basename(FileUtils.pwd).downcase
     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)
-        when 'pg'
-          SyncConfigs::PostGres.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]
-    # @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
-
     ##
     # Path al file dove salviamo la cache dei managers, ha un TTL legato all'orario (anno-mese-giorno-ora)
     # quindi ogni ora si autoripulisce e con un md5 delle configurazioni di base
@@ -218,67 +100,6 @@ module SwarmClusterCliOpe
       File.join("/tmp", file_name)
     end
 
-    ##
-    # Legge le configurazioni base
-    #
-    # @return [Hash]
-    def self.read_base
-      raise NoBaseConfigurations unless exist_base?
-      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 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
-
-      configuration_version = @_merged_configurations[@environment][:version]
-      if Gem::Version.new(configuration_version) > Gem::Version.new(VERSION)
-        puts "WARNING: Versione del file di configurazione [#{configuration_version}] più aggiornata della gemma [#{VERSION}], eseguire upgrade
-              gem update swarm_cluster_cli_ope"
-        exit
-      end
-
-      @_merged_configurations[@environment]
-
-    end
-
-    private
-
-    def looped_file(start_folder, file)
-      project_file = nil
-      loop do
-
-        if File.exist?(File.join(start_folder, file))
-          project_file = File.join(start_folder, file)
-        end
-
-        break unless project_file.nil?
-        break if start_folder == '/'
-        start_folder = File.expand_path("..", start_folder)
-      end
-
-      project_file
-    end
 
   end
 end

data/lib/swarm_cluster_cli_ope/configuration_concern.rb

@@ -1,8 +1,16 @@
+require 'active_support/concern'
+
 module SwarmClusterCliOpe
   module ConfigurationConcern
+    extend ActiveSupport::Concern
+
+    included do
+
+      # @return [SwarmClusterCliOpe::Configuration]
+      def cfgs
+        self.class.cfgs
+      end
 
-    def self.included(klass)
-      klass.extend(ClassMethods)
     end
 
     module ClassMethods
@@ -13,12 +21,5 @@ module SwarmClusterCliOpe
         Configuration.instance
       end
     end
-
-
-    # @return [SwarmClusterCliOpe::Configuration]
-    def cfgs
-      self.class.cfgs
-    end
-
   end
 end

data/lib/swarm_cluster_cli_ope/k8s.rb

@@ -0,0 +1,90 @@
+module SwarmClusterCliOpe
+  class K8s < Thor
+    include LoggerConcern
+    include ConfigurationConcern
+    include ThorConfigurationConcern
+    include Thor::Actions
+    include StackSyncConcern
+
+    def self.exit_on_failure?
+      true
+    end
+
+    def self.cfgs
+      SwarmClusterCliOpe::Kubernetes::Configuration.instance
+    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
+        if yes? "Sei nel contesto corretto di kubectl?"
+          #scriviamo le varie configurazioni
+          cfg = cfgs
+          cfg.save_base_cfgs
+        else
+          say "Cambia prima contesto, sarà quello usato per l'installazione"
+        end
+      end
+
+    end
+
+
+    desc "rsync <src> <dst>", "esegue un rsync dalla cartella (viene sincronizzato il contenuto)"
+    long_desc "Viene utilizzato rsync standard. La root del pod diviene il context di rsync, quindi
+                possiamo fare rsync con qualsiasi path del filesystem del pod.
+                Il modo con cui scrivere la path sorgente e quello di destinazione è tale a quello di rsync, quindi:
+                - voglio copiare il contenuto della cartella /ciao con il contenuto onlin del pod nella cartella
+                  /home/pippo, dovrò scrivere   /ciao/. podname:/home/pippo "
+    option :stack_name, required: false, type: :string, aliases: ["--namespace", "-n"]
+
+    def rsync(src, dst)
+      reg_exp = /(?<pod_name>.*)\:(?<path>.*)/
+      if File.exist?(src)
+        # il src é la cartella, quindi la destizione è il pod
+        direction = :up
+        local_path = src
+        podname = dst.match(reg_exp)[:pod_name]
+        podpath = dst.match(reg_exp)[:path]
+      else
+        direction = :down
+        podname = src.match(reg_exp)[:pod_name]
+        podpath = src.match(reg_exp)[:path]
+        local_path = dst
+      end
+
+      puts "#{src} #{direction} #{dst}"
+
+      cfgs.env(options[:environment]) do |cfgs|
+
+        cfgs.stack_name = options[:stack_name] || cfgs.stack_name
+
+        sync = Kubernetes::SyncConfigs::Rsync.new(cfgs, {
+          service: Kubernetes::Pod.find_by_name(podname),
+          how: 'rsync',
+          configs: {
+            local: local_path,
+            remote: podpath
+          }
+        })
+
+        if direction == :down
+          sync.pull
+        end
+        if direction == :up
+          sync.push
+        end
+
+      
+
+
+      end
+    end
+
+
+  end
+end

data/lib/swarm_cluster_cli_ope/kubernetes/configuration.rb

@@ -0,0 +1,49 @@
+module SwarmClusterCliOpe
+  module Kubernetes
+    class Configuration < BaseConfiguration
+
+
+      ##
+      # In kubernetes abbiamo il context, il context può essere ricevuto o dalla configurazione oppure dal current_context
+      # di kubelet
+      # @return [String]
+      def context
+        cmd = ShellCommandExecution.new(['kubectl config current-context'])
+        cmd.execute.raw_result[:stdout]
+      end
+
+      ##
+      # Salva le configurazioni base in HOME
+      def save_base_cfgs
+        super do |obj|
+          obj.merge({connections_maps: {context: context}})
+        end
+      end
+
+      ##
+      # In k8s utilizziamo namespace come identificativo per avere le idee più chiare a cosi ci riferiamo
+      alias_method :namespace, :stack_name
+
+
+      ##
+      # Funzione per la restituzione della classe di sincro corretta
+      def get_syncro(name)
+        case name
+        when 'sqlite3'
+          SyncConfigs::Sqlite3
+        when 'rsync'
+          SyncConfigs::Rsync
+        # when 'mysql'
+        #   SyncConfigs::Mysql
+        # when 'pg'
+        #   SyncConfigs::PostGres
+        else
+          logger.error { "CONFIGURAIONE NON PREVISTA: #{name}" }
+          nil
+        end
+      end
+
+
+    end
+  end
+end

data/lib/swarm_cluster_cli_ope/kubernetes/pod.rb

@@ -0,0 +1,143 @@
+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::ShellCommandExecution]
+      def exec(cmd)
+        base_cmd(["exec", name, "--", cmd].flatten)
+      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.result[:items].empty?
+            logger.warn { "non abbiamo trovato il pod" }
+          else
+            self.new(ris.result[: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.result, 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