swarm_cluster_cli_ope 0.1.2

data/lib/swarm_cluster_cli_ope/models/container.rb

@@ -0,0 +1,78 @@
+module SwarmClusterCliOpe
+  module Models
+    class Container < Base
+
+      #@return [String]
+      attr_accessor :name
+      #@return [String]
+      attr_accessor :id
+      #@return [String] nome dell'immagine
+      attr_accessor :image
+      #@return [Hash] labels del container
+      attr_accessor :labels
+
+
+      def labels=(labels)
+        @labels = labels.split(",").collect { |a| a.split("=") }.collect { |a, b| [a, b] }.to_h
+      end
+      ##
+      # Può essere che riceva dei valori dal config, tipo quando facciamo inspect
+      def config=(config)
+        @labels = config["Labels"]
+      end
+
+      # @return [String] id del nodo di appartenenza
+      def node_id
+        labels["com.docker.swarm.node.id"]
+      end
+
+      # @return [SwarmClusterCliOpe::Models::Container]
+      def self.find_by_service_name(service_name, stack_name: nil)
+        Service.find(service_name,stack_name:stack_name).containers.first
+      end
+
+      def self.all(service_name: nil)
+        Commands::Container.new.ps(service_name: service_name).result(object_class: Container)
+      end
+
+      ##
+      # Copia i file dentro al container
+      # @param [String] src sorgente da cui copiare
+      # @param [String] dest destinazione a cui copiare
+      def copy_in(src, dest)
+        docker_command.cp(src, "#{id}:#{dest}").success?
+      end
+
+      ##
+      # Copia i file dal container all'esterno
+      # @param [String] src sorgente da cui copiare
+      # @param [String] dest destinazione a cui copiare
+      def copy_out(src, dest)
+        docker_command.cp("#{id}:#{src}", dest).success?
+      end
+
+      ##
+      # Ritorna il connection_uri del nodo che ospita il container
+      # @return [String]
+      def mapped_uri_connection
+        node.connection_uri
+      end
+
+      ##
+      # Elenco dei volumi mappato
+      # @return [Array<MappedVolume>]
+      def mapped_volumes
+        docker_inspect.Mounts.collect { |v| MappedVolume.new(v, container: self) }
+      end
+
+      ##
+      # Ritorna il nodo dello swarm che contiene questo container
+      # @return [SwarmClusterCliOpe::Node]
+      def node
+        cfgs.get_node_by_id(node_id)
+      end
+
+
+    end
+  end
+end

data/lib/swarm_cluster_cli_ope/models/mapped_volume.rb

@@ -0,0 +1,43 @@
+module SwarmClusterCliOpe
+  module Models
+    class MappedVolume < Base
+
+      #@return [Container]
+      attr_accessor :container
+
+      #@return [String] tipologia di volume mappato [bind,volume]
+      attr_accessor :type
+
+      #@return [String] sorgente del bind
+      attr_accessor :source
+
+      #@return [String] destinazione del bind nel container
+      attr_accessor :destination
+
+      def initialize(obj, container: nil)
+        super(obj)
+        @container = container
+      end
+
+      ##
+      # Controllo se il volume è bindato con l'host
+      def is_binded?
+        type == 'bind'
+      end
+
+      ##
+      # Costruisce tutta la path da utilizzare per connettersi via ssh,
+      # se siamo in locale non sarà presente la parte di server e ":"
+      def ssh_connection_path
+        #costruisco la stringa per la parte di connetività del container
+        out = "#{source}"
+        if container.node.is_over_ssh_uri?
+          out = "#{container.node.hostname}:#{out}"
+        end
+        out
+
+      end
+
+    end
+  end
+end

data/lib/swarm_cluster_cli_ope/models/service.rb

@@ -0,0 +1,38 @@
+module SwarmClusterCliOpe
+  module Models
+    class Service < Base
+
+      #@return [String]
+      attr_accessor :name
+      #@return [String]
+      attr_accessor :id
+
+      # @return [Array<SwarmClusterCliOpe::Service>]
+      def self.all(stack_name: nil)
+        Commands::Service.new.ls(stack_name: stack_name).result(object_class: Service)
+      end
+
+      # @return [SwarmClusterCliOpe::Service]
+      def self.find(service_name, stack_name: nil)
+        Commands::Service.new.find(service_name, stack_name: stack_name).result(object_class: Service).first
+      end
+
+      ##
+      # Containers del servizio
+
+      # @return [Array<SwarmClusterCliOpe::Container>]
+      def containers
+        tasks.collect { |t| t.container }
+      end
+
+      ##
+      # Elenco dei task del servizio
+      # docker service ps SERVICE_NAME --format="{{json .}}" -f "desired-state=running"
+      # @return [Array<Task>]
+      def tasks
+        docker_command.ps(name).result(object_class: Task)
+      end
+
+    end
+  end
+end

data/lib/swarm_cluster_cli_ope/models/stack.rb

@@ -0,0 +1,18 @@
+module SwarmClusterCliOpe
+  module Models
+    class Stack < Base
+
+      #@return [:String]
+      attr_accessor :name
+      #@return [String]
+      attr_accessor :namespace
+      #@return [Integer]
+      attr_accessor :services
+
+      # @return [Array<Stack>]
+      def self.all
+        Commands::Swarm.new.ls.result(object_class: Stack)
+      end
+    end
+  end
+end

data/lib/swarm_cluster_cli_ope/models/task.rb

@@ -0,0 +1,27 @@
+module SwarmClusterCliOpe
+  module Models
+    class Task < Base
+
+      #@return [String]
+      attr_accessor :name
+      #@return [String]
+      attr_accessor :id
+      #@return [String] nome dell'immagine
+      attr_accessor :node
+
+
+      ##
+      # Estrapola il container dal task
+      def container
+        stack_info = docker_inspect
+
+        cmd = Commands::Container.new(connection_uri: cfgs.get_node_by_id(stack_info.NodeID).connection_uri)
+        container = cmd.docker_inspect(stack_info.Status["ContainerStatus"]["ContainerID"]).result(object_class: Container).first
+
+        container
+
+      end
+
+    end
+  end
+end

data/lib/swarm_cluster_cli_ope/node.rb

@@ -0,0 +1,80 @@
+require 'uri'
+
+module SwarmClusterCliOpe
+  class Node
+    include LoggerConcern
+
+    #@return [String] nome del nodo
+    attr_accessor :name
+    #@return [String] nome da utilizzare nella parte DOCKER_HOST=CONNECTION_URI
+    attr_accessor :connection_uri
+
+
+    # @param [String] name
+    # @param [String] connection_uri
+    def initialize(name: nil, connection_uri: nil)
+      @name = name
+      @connection_uri = connection_uri || name
+    end
+
+    ##
+    # Mi definisce se la connessione che stiamo facendo con questo nodo, la facciamo tramite SSH oppure è locale
+    def is_over_ssh_uri?
+      connection_uri.match?(/\Assh\:/)
+    end
+
+    ##
+    # connection_uri senza la parte del protocollo
+    # @return [String]
+    def hostname
+      URI(connection_uri).host
+    end
+
+
+    ##
+    # Controlla se questo nodo è un manager
+    # @return [TrueClass,FalseClass]
+    def manager?
+      info.Swarm["RemoteManagers"].collect { |n| n["NodeID"] }.include?(info.Swarm["NodeID"])
+    end
+
+    ##
+    # ID univoco del nodo
+    # @return [String]
+    def id
+      info.Swarm.NodeID
+    end
+
+    ##
+    # Info del nodo da parte di docker
+    # @return [OpenStruct]
+    def info
+      # path al file di cache
+      # TODO sarebbe da aggiornare ogni tanto, metti che uno non spegne mai il pc
+      path = "/tmp/.swarm_cluster_cli_info_cache_#{name}"
+      if File.exist?(path)
+        i = JSON.parse(File.read(path), object_class: OpenStruct)
+      else
+        i = Node.info(connection_uri)
+        #mi salvo in cache le info scaricate
+        File.open(path, "w") do |f|
+          f.write(i.to_h.to_json)
+        end
+      end
+
+      i
+    end
+
+    ##
+    # Ritorna le info base di un nodo
+    def self.info(connection_uri)
+      command = Commands::Base.new
+      command.docker_host = "DOCKER_HOST=#{connection_uri}"
+      result = command.command do |cmd|
+        cmd.add("info")
+      end.execute.result.first
+      result
+    end
+
+  end
+end

data/lib/swarm_cluster_cli_ope/shell_command_execution.rb

@@ -0,0 +1,68 @@
+require 'open4'
+require 'json'
+
+module SwarmClusterCliOpe
+  class ShellCommandExecution
+    include LoggerConcern
+
+    #@return [Array<String>] comando da eseguire
+    attr_accessor :cmd
+
+    # @param [Array<String>,String] cmd
+    def initialize(cmd)
+      cmd = cmd.split(" ") if cmd.is_a? String
+      @cmd = cmd
+    end
+
+    # @return [SwarmClusterCliOpe::ShellCommandExecution]
+    # @param [*String] append_command
+    def add(*append_command)
+      @cmd.append(append_command)
+      self
+    end
+
+    class Failure < Error
+      def initialize(cmd, error)
+        super("[SYSTEM COMMAND FAILURE] #{cmd} -> #{error}")
+      end
+    end
+
+    ##
+    # Esegue il comando e ritorna STDOUT, altrimenti se va in errore esegue un raise
+    # @return [ShellCommandResponse]
+    # @param [FalseClass] allow_failure -> se impostato a true, ritorniamo risultato anche quando fallisce
+    def execute(allow_failure: false)
+      result = {
+        stdout: nil,
+        stderr: nil,
+        pid: nil,
+        status: nil
+      }
+      logger.debug { "SHELL: #{string_command}" }
+      result[:status] = Open4::popen4(string_command) do |pid, stdin, stdout, stderr|
+        stdin.close
+
+        result[:stdout] = stdout.read.strip
+        result[:stderr] = stderr.read.strip
+        result[:pid] = pid
+      end
+
+      unless allow_failure
+        raise Failure.new(cmd, result[:stderr]) if (result[:status] && result[:status].exitstatus != 0)
+      end
+
+      logger.debug { "SHELL_RESPONSE: #{JSON.pretty_generate(result)}" }
+
+      ShellCommandResponse.new(result)
+    end
+
+    ##
+    # Stampa il comando
+    # @return [String]
+    def string_command
+      @cmd.join(' ')
+    end
+
+
+  end
+end

data/lib/swarm_cluster_cli_ope/shell_command_response.rb

@@ -0,0 +1,68 @@
+require 'forwardable'
+
+module SwarmClusterCliOpe
+##
+# Identifica una risposta dalla shell
+  class ShellCommandResponse
+    extend Forwardable
+    include LoggerConcern
+
+    #@return [String]
+    attr_accessor :raw_result
+
+    # @param [Hash] result composto da:
+    #    stdout: [String],
+    #    stderr: [String],
+    #    pid: [Integer],
+    #    status: [Process::Status]
+    def initialize(result)
+      @raw_result = result
+    end
+
+    # ##
+    # # Ritorna una versione stampabile del risultato
+    # def to_s
+    #   raw_result[:stdout]
+    # end
+    #
+    ##
+    # 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)) }
+    end
+
+    #
+    # def to_a
+    #   raw_result[:stdout].split("\n")
+    # end
+
+    ##
+    # Controlla se il valore di status è diverso da 0
+    def failed?
+      raw_result[:status].exitstatus.to_i != 0
+    end
+
+    ##
+    # Inverso di :failed?
+    # @return [TrueClass, FalseClass]
+    def success?
+      !failed?
+    end
+
+    ##
+    # Ritorna l'errore della shell
+    def stderr
+      raw_result[:stderr]
+    end
+
+    # ##
+    # # Quando il risultato è json, ritorniamo l'hash
+    # def from_json
+    #   JSON.parse(raw_result[:stdout])
+    # end
+
+    def_delegators :result, :collect, :last, :find
+  end
+end

data/lib/swarm_cluster_cli_ope/version.rb

@@ -0,0 +1,3 @@
+module SwarmClusterCliOpe
+  VERSION = "0.1.2"
+end

data/lib/swarm_cluster_cli_ope/worker.rb

@@ -0,0 +1,7 @@
+module SwarmClusterCliOpe
+  class Worker < Node
+    def manager?
+      false
+    end
+  end
+end

data/swarm_cluster_cli_ope.gemspec

@@ -0,0 +1,36 @@
+require_relative 'lib/swarm_cluster_cli_ope/version'
+
+Gem::Specification.new do |spec|
+  spec.name = "swarm_cluster_cli_ope"
+  spec.version = SwarmClusterCliOpe::VERSION
+  spec.authors = ["Marino Bonetti"]
+  spec.email = ["marinobonetti@gmail.com"]
+
+  spec.summary = "WIP Gemma per la gestione del cluster swarm"
+  spec.description = "Gestione di varie operazioni come sincronia con le cartelle bindate dei container (rsync) up o
+                        down e possibilità di scaricare/caricare i file direttamente all'interno del cluster, in
+                        modo facilitato"
+  spec.homepage = "https://gitlab.archimedianet.it/sistemi/swarm_cluster_cli_ope"
+  spec.license = "MIT"
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.metadata["allowed_push_host"] = 'https://rubygems.org/'
+
+  spec.metadata["homepage_uri"] = spec.homepage
+  # spec.metadata["source_code_uri"] = "TODO: Put your gem's public repo URL here."
+  # spec.metadata["changelog_uri"] = "TODO: Put your gem's CHANGELOG.md URL here."
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features|test_folder)/}) }
+  end
+  spec.bindir = "exe"
+  spec.executables = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "thor", '~>1.0'
+  spec.add_dependency "zeitwerk", '~>2.3'
+  spec.add_dependency "open4"
+  spec.add_dependency "activesupport"
+end