swarm_cluster_cli_ope 0.1.2

data/lib/swarm_cluster_cli_ope/commands/base.rb

@@ -0,0 +1,70 @@
+module SwarmClusterCliOpe
+  module Commands
+    class Base
+      include LoggerConcern
+      include ConfigurationConcern
+
+      #@return [String] Identifivo per potersi collegare
+      attr_accessor :docker_host
+
+      #@return [Array<String>] elenco di comandi da aggiungere in coda al comando lanciato
+      attr_accessor :base_suffix_command
+
+      def initialize(connection_uri: nil, base_suffix_command: ["--format=\"{{json .}}\""])
+        if connection_uri
+          if connection_uri.blank?
+            @docker_host = "DOCKER_HOST=" # casistica di sviluppo, in cui l'host viene mappato localmente
+          else
+            @docker_host = "DOCKER_HOST=#{connection_uri}"
+          end
+        end
+        @base_suffix_command = base_suffix_command
+      end
+
+
+      def docker_host
+        return @docker_host unless @docker_host.nil?
+        @docker_host = if Configuration.exist_base?
+                         "DOCKER_HOST=#{cfgs.managers.first.connection_uri}"
+                       end
+      end
+
+      ##
+      # Aggiunge al blocco passato di comandi, i comandi standard iniziali
+      # @return [SwarmClusterCliOpe::ShellCommandExecution]
+      def command
+        cmd = ShellCommandExecution.new(base_prefix_command)
+        yield cmd if block_given?
+        cmd.add(*base_suffix_command)
+      end
+
+      ##Esegue l'inspect sul componente
+      # @param [String] id
+      # @return [SwarmClusterCliOpe::ShellCommandResponse]
+      def docker_inspect(id)
+        command do |cmd|
+          cmd.add(" #{self.class.object_identifier} inspect #{id}")
+        end.execute
+      end
+
+      ##
+      # Ritorna il nome identificativo dell'elemento all'interno di docker: container,service,stack ecc..
+      # @return [String]
+      def self.object_identifier
+        self.name.demodulize.downcase
+      end
+
+      private
+
+      def base_prefix_command
+        if cfgs.development_mode?
+          ["docker"]
+        else
+          [docker_host, "docker"]
+        end
+      end
+
+
+    end
+  end
+end

data/lib/swarm_cluster_cli_ope/commands/container.rb

@@ -0,0 +1,24 @@
+module SwarmClusterCliOpe
+  module Commands
+    class Container < Base
+
+      def cp(src, dest)
+        self.base_suffix_command = []
+        command do |cmd|
+          cmd.add("cp #{src} #{dest}")
+        end.execute
+      end
+
+      ##
+      # Esegue il ps sui container, possibile filtrare passando nome stack e/o nome servizio
+      # @param [String] service_name
+      # @return [SwarmClusterCliOpe::ShellCommandResponse]
+      def ps(service_name: nil)
+        command do |cmd|
+          cmd.add("ps")
+          cmd.add("--filter=\"label=com.docker.swarm.service.name=#{service_name}\"") if service_name
+        end.execute
+      end
+    end
+  end
+end

data/lib/swarm_cluster_cli_ope/commands/service.rb

@@ -0,0 +1,42 @@
+module SwarmClusterCliOpe
+  module Commands
+    class Service < Base
+
+      # @return [SwarmClusterCliOpe::ShellCommandResponse]
+      # @param [String] stack_name nome dello stack da filtrare
+      def ls(stack_name: nil)
+        command do |cmd|
+          cmd.add("service ls")
+          cmd.add("--filter=\"label=com.docker.stack.namespace=#{stack_name}\"") if stack_name
+        end.execute
+      end
+
+      ##
+      # Ricarca il servizio per nome, nel caso in cui abbiamo anche il nome dello stack, concateniamo il nome
+      # del servizio con lo stack (dato che è il sistema con cui è più semplice trovare un servizio di uno stack).
+      # sucessivamente troviamo tutti i containers legati a quel servizio ed estrapoliamo l'istanza del primo
+      # @param [String] service_name
+      # @param [String] stack_name optional
+      # @return [SwarmClusterCliOpe::ShellCommandResponse]
+      def find(service_name, stack_name: nil)
+        command do |cmd|
+          cmd.add("service ls --filter=\"name=#{  stack_name ? "#{stack_name}_" : "" }#{service_name}\"")
+        end.execute
+      end
+
+      ##
+      # Esegue il ps per un determinato servizio
+      # @param [String] service_name
+      # @param [String] stack_name optional
+      # @return [SwarmClusterCliOpe::ShellCommandResponse]
+      # @param [TrueClass] only_active se si vuole avere solo quelli attivi
+      def ps(service_name, stack_name: nil, only_active: true)
+        command do |cmd|
+          cmd.add("service ps  #{stack_name ? "#{stack_name}_" : "" }#{service_name}")
+          cmd.add('-f "desired-state=running"') if only_active
+        end.execute
+      end
+
+    end
+  end
+end

data/lib/swarm_cluster_cli_ope/commands/swarm.rb

@@ -0,0 +1,14 @@
+module SwarmClusterCliOpe
+  module Commands
+    class Swarm < Base
+
+      # @return [SwarmClusterCliOpe::ShellCommandResponse]
+      def ls
+        command do |cmd|
+          cmd.add("stack ls")
+        end.execute
+      end
+
+    end
+  end
+end

data/lib/swarm_cluster_cli_ope/commands/task.rb

@@ -0,0 +1,11 @@
+module SwarmClusterCliOpe
+  module Commands
+    class Task < Base
+
+      def self.object_identifier
+        ""
+      end
+
+    end
+  end
+end

data/lib/swarm_cluster_cli_ope/configuration.rb

@@ -0,0 +1,189 @@
+require "singleton"
+require "fileutils"
+require "json"
+require 'digest'
+require "active_support/core_ext/hash"
+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
+
+    #@return [String] nome dello stack con cui lavoriamo
+    attr_accessor :stack_name
+
+    NoBaseConfigurations = Class.new(Error)
+
+    ##
+    # Lista di nodi su cui lavorare
+    # @return [Array<SwarmClusterCliOpe::Manager>]
+    def managers
+      return @_managers if @_managers
+      @_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
+
+    ##
+    # 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
+    def refresh_managers_cache_list
+      list = self.nodes.select(&:manager?).collect { |c| Manager.new(name: c.name, connection_uri: c.connection_uri) }
+      File.open(swarm_manager_cache_path, "w") do |f|
+        list.collect(&:name).each do |name|
+          f.puts(name)
+        end
+      end
+    end
+
+    def read_managers_cache_list
+      # TODO sarebbe da aggiornare ogni tanto, metti che uno non spegne mai il pc
+      refresh_managers_cache_list unless File.exists?(swarm_manager_cache_path)
+      File.read(swarm_manager_cache_path).split("\n")
+    end
+
+    ##
+    # Lista di tutti i nodi del cluster
+    #
+    # @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) }
+    end
+
+    ##
+    # Lista di nodi da assegnare alle configurazioni
+    #
+    # @param [Array<SwarmClusterCliOpe::Node>]
+    # @return [Configuration]
+    def nodes=(objs)
+      @_nodes = 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)
+    end
+
+    ##
+    # Livello di logging
+    # @return [Integer]
+    def logger_level
+      self.class.merged_configurations[:log_level].to_s || "0"
+    end
+
+    ##
+    # Siamo in sviluppo?
+    # @return [TrueClass, FalseClass]
+    def development_mode?
+      return false unless self.class.exist_base?
+      self.class.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), "wb") do |f|
+          f.write({
+                    stack_name: stack_name
+                  }.to_json)
+        end
+      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
+    def get_node(node)
+      nodes.find { |c| c.name == node }
+    end
+
+    # @return [SwarmClusterCliOpe::Node]
+    # @param [String] node_id
+    def get_node_by_id(node_id)
+      nodes.find { |c| c.id == node_id }
+    end
+
+    private
+
+    ##
+    # nome del file in cui salvare le configurazioni di progetto
+    # @return [String]
+    def self.cfgs_project_file_name
+      '.swarm_cluster_project'
+    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
+    # @return [String]
+    def swarm_manager_cache_path
+      md5 = Digest::MD5.hexdigest(self.class.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
+
+    ##
+    # 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
+
+    ## Cerca le configurazioni di progetto e le mergia se sono presenti
+    # @return [Hash]
+    def self.merged_configurations
+      return @_merged_configurations if @_merged_configurations
+      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)
+        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
+      end
+
+      @_merged_configurations = read_base.merge(project_cfgs)
+    end
+
+  end
+end

data/lib/swarm_cluster_cli_ope/configuration_concern.rb

@@ -0,0 +1,24 @@
+module SwarmClusterCliOpe
+  module ConfigurationConcern
+
+    def self.included(klass)
+      klass.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      ##
+      # Configurazioni standard
+      # @return [SwarmClusterCliOpe::Configuration]
+      def cfgs
+        Configuration.instance
+      end
+    end
+
+
+    # @return [SwarmClusterCliOpe::Configuration]
+    def cfgs
+      self.class.cfgs
+    end
+
+  end
+end

data/lib/swarm_cluster_cli_ope/logger_concern.rb

@@ -0,0 +1,26 @@
+require 'logger'
+
+module SwarmClusterCliOpe
+  module LoggerConcern
+    def logger
+      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
+                     when "0"
+                       Logger::ERROR
+                     when "1"
+                       Logger::WARN
+                     when "2"
+                       Logger::INFO
+                     when "3"
+                       Logger::DEBUG
+                     else
+                       Logger::ERROR
+                     end
+
+      logger
+    end
+
+  end
+end

data/lib/swarm_cluster_cli_ope/manager.rb

@@ -0,0 +1,9 @@
+module SwarmClusterCliOpe
+  class Manager < Node
+
+    def manager?
+      true
+    end
+
+  end
+end

data/lib/swarm_cluster_cli_ope/models/base.rb

@@ -0,0 +1,42 @@
+require 'active_support/core_ext/string'
+module SwarmClusterCliOpe
+  module Models
+    class Base
+      include LoggerConcern
+      include ConfigurationConcern
+
+      def initialize(obj)
+        logger.debug { obj.inspect }
+        obj.each do |k, v|
+          name = k.underscore
+          self.send("#{name}=", v) if respond_to?("#{name}=".to_sym)
+        end
+      end
+
+      IDNotFoundOnObject = Class.new(Error)
+
+      ##
+      # Esegue un inspect del tipo di componente di docker
+      def docker_inspect
+        raise IDNotFoundOnObject if id.blank?
+        docker_command.docker_inspect(id).result.first
+      end
+
+
+      ##
+      # Ritorna il comando corretto, inizializzato con la connecttion uri corretta
+      # @return [Commands::Base]
+      def docker_command
+        Commands.const_get(self.class.name.demodulize).new(connection_uri: mapped_uri_connection)
+      end
+
+      ##
+      # Override della connessione al nodo corretto, i container sono legati allo swarm, conseguentemente dobbiamo
+      # collegarci al nodo giusto, di default lasiamo nil, così che prende le cfgs di default
+      def mapped_uri_connection
+        nil
+      end
+
+    end
+  end
+end