jarl 0.7.0 → 0.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5236af50f9ae03530ad885c513aa7f2cab5ec001
-  data.tar.gz: c054de648fe8d3d61af434f4c7eae774ed9513b9
+  metadata.gz: 83b74b296a0d7b717781e0e95afc0229fccf6806
+  data.tar.gz: ad1000a7b31104b2f4c89850acec71e59cd52a12
 SHA512:
-  metadata.gz: 96e8031a848011187b457d2e2eb0399df81ae93395f418014c243937073f380b7eeb497f7e94a80fc9426fbfb724e7607ef4a34f7dfe288c50dbf12fcb6a41bf
-  data.tar.gz: 1a125e6dab7a71f8300e63f37ac496421949e0f97dab6df46c381680cf3c9fcb086c359addff5cd8d89a80d7366d00ee7b7410ecaf62304d13eda999885cfbbf
+  metadata.gz: 40284867d9621630fa84494ede01af179a92474c61ac1fe723358a55c0115848a056cbba18bc41fc5aa1a3ceb308f48e3219add98ba5695798fe9fc9e80816b1
+  data.tar.gz: f4d2e5ae060dbcfff10601956dac755c706972d3099009017aa78acd762ffb6d28493225a32812d0d05480dc7cb6c240198a526b1a2d29d410dd466289d33b0b

data/lib/jarl/application.rb

@@ -1,7 +1,7 @@
 module Jarl
   class Application
     attr_reader :group, :name, :hostname, :base_path
-    attr_reader :image, :volumes, :ports, :environment, :entrypoint, :command
+    attr_reader :image, :scale, :volumes, :ports, :environment, :entrypoint, :command
     attr_reader :serial
 
     # Create Application object from application definition:
@@ -22,6 +22,10 @@ module Jarl
       unless @image.is_a?(String)
         fail "Application '#{self}' has invalid 'image' definition, String is expected"
       end
+      @scale = params['scale'] || 1
+      unless @scale.is_a?(Integer) && @scale > 0
+        fail "Application '#{self}' has invalid 'scale' definition, Integer > 0 is expected"
+      end
       @volumes = params['volumes'] || []
       unless @volumes.is_a?(Array)
         fail "Application '#{self}' has invalid 'volumes' definition, Array is expected"
@@ -59,18 +63,42 @@ module Jarl
     end
 
     def running?
-      instances.size > 0
+      instances.any?(&:running?)
     end
 
     def instances
-      Docker.containers_running.select { |c| c.name =~ /^#{full_name}(\.\d+)?$/ }.map do |c|
-        Instance.new(self, c)
+      running_instances + stopped_instances
+    end
+
+    def running_containers
+      @running_containers ||= Docker.containers_running.select do |c|
+        c.name =~ /^#{full_name}(\.\d+)?$/
       end
     end
 
-    # Start +scale+ instances of the application
+    def running_instances
+      @running_instances ||= running_containers.map do |c|
+        n = c.name.sub(/^#{full_name}\.?/, '')
+        n = n.empty? ? nil : n.to_i
+        Instance.new(self, n, c)
+      end
+    end
+
+    def stopped_instances
+      return @stopped_instances if @stopped_instances
+      n_range = scale == 1 ? [nil] : (1..scale).to_a
+      @stopped_instances = n_range.reject do |n|
+        running_instances.map(&:n).include?(n)
+      end
+      @stopped_instances = @stopped_instances.map do |n|
+        Instance.new(self, n, nil)
+      end
+      @stopped_instances
+    end
+
+    # Start instances of the application
     #
-    def start(scale = 1)
+    def start
       instances.map(&:stop!) if running?
       if scale > 1
         scale.times { |n| Instance.start(self, n + 1) }
@@ -129,35 +157,60 @@ module Jarl
     # Application::Instance represents a single running instance of the application
     #
     class Instance
-      attr_reader :application, :container
-      def initialize(application, container)
+      attr_reader :application, :n, :container
+
+      # @param application [Application]
+      # @param n [nil,Integer] Instance number, nil if an instance is the primary instance
+      # @param container [nil,Docker::Container] Running container, if present
+      #
+      def initialize(application, n, container)
         @application = application
+        @n = n
         @container = container
       end
 
+      def running?
+        !@container.nil?
+      end
+
+      def full_name
+        n ? "#{application.full_name}.#{n}" : application.full_name
+      end
+
+      def hostname
+        n ? "#{application.hostname}-#{n}" : application.hostname
+      end
+
       def stop!
+        return unless running?
         @container.stop!
       end
 
-      def name
-        @container.name
-      end
+      def start!
+        return if running?
+        # puts esc_yellow("Starting #{application.name}.#{n}") if n
 
-      def n
-        suffix = @container.name.split('.').last
-        suffix =~ /^\d+$/ ? suffix : nil
+        Docker.start(
+          name: full_name,
+          hostname: hostname,
+          image: application.image_name,
+          volumes: application.volumes,
+          ports: application.ports,
+          environment: application.environment,
+          command: application.command
+        )
       end
 
       def tail_log(*_args)
+        return unless running?
         color_code = Console::Colors::SEQUENCE[application.serial % Console::Colors::SEQUENCE.size]
         begin
-          instance_no = n ? ".#{n}" : ''
           IO.popen "docker logs -f #{container.id}", 'r' do |p|
             str = '<<< STARTED >>>'
             while str
               str = p.gets
               str.split("\n").each do |s|
-                puts "#{esc_color color_code, application.full_name}#{instance_no}: #{s}"
+                puts "#{esc_color color_code, full_name}: #{s}"
               end
             end
           end
@@ -167,20 +220,9 @@ module Jarl
       end
 
       def ssh(command = nil)
+        fail "Failed to open SSH, no running container for '#{full_name}'" unless running?
         container.open_ssh_session!(Jarl.config.params, command)
       end
-
-      def self.start(application, n = nil)
-        Docker.start(
-          name: (n ? "#{application.full_name}.#{n}" : application.full_name),
-          hostname: (n ? "#{application.hostname}-#{n}" : application.hostname),
-          image: application.image_name,
-          volumes: application.volumes,
-          ports: application.ports,
-          environment: application.environment,
-          command: application.command
-        )
-      end
     end # class Instance
   end # class Application
 end # module Jarl

data/lib/jarl/base.rb

@@ -42,10 +42,49 @@ module Jarl
     end.flatten
   end
 
+  # Returns list of running application instances
+  #
+  def self.application_instances
+    @application_instances ||= applications.map(&:instances).flatten
+  end
+
   # Returns list of applications matching the pattern
   #
-  def self.find_applications_by(pattern)
-    applications.select { |a| a.full_name.index(pattern) }
+  # @param patterns [nil] Match all application instances
+  # @param patterns [String] Match application instances by single pattern
+  # @param patterns [Arary<String>] Match application instances by all patterns
+  #
+  def self.find_applications_by(patterns)
+    find_application_instances_by(patterns).map(&:application).uniq
+  end
+
+  # Returns list of running application instances matching the pattern(s)
+  #
+  # @param patterns [nil] Match all application instances
+  # @param patterns [String] Match application instances by single pattern
+  # @param patterns [Arary<String>] Match application instances by all patterns
+  #
+  def self.find_application_instances_by(patterns)
+    patterns = nil if patterns && patterns.empty?
+    case patterns
+    when nil
+      application_instances
+    when String
+      application_instances.select { |i| i.full_name.index(patterns) }
+    when Array
+      application_instances.select { |i| patterns.any? { |p| i.full_name.index(p) } }
+    else
+      fail "Unexpected #{patterns.class} passed as argument to .find_application_instances_by"
+    end
+  end
+
+  #
+  #
+  def self.reload!
+    @jarl_files = nil
+    @applications = nil
+    @application_instances = nil
+    Docker.reload!
   end
 
   private

data/lib/jarl/cli.rb

@@ -25,52 +25,58 @@ module Jarl
           puts "    #{app.name}"
         end
       end
-      # show_jarl_applications_status(apps)
     end
 
     #
-    desc 'status [NAME]', '(default) Show applications statuses'
-    def status(name = nil)
+    desc 'status [NAME ...]', '(default) Show applications statuses'
+    def status(*names)
       Jarl.load(options)
-      apps = name ? Jarl.find_applications_by(name) : Jarl.applications
-      show_jarl_applications_status(apps)
+      ais = Jarl.find_application_instances_by(names)
+      show_jarl_application_instances_status(ais)
     end
     default_task :status
 
-    #
-    option :scale,
-      type: :numeric,
-      default: 1,
-      desc: 'Start several instances'
-    desc 'up [NAME]', 'Start or restart applications'
-    def up(name = nil)
+    desc 'up [NAME ...]', 'Start or restart applications'
+    def up(*names)
       Jarl.load(options)
-      apps = name ? Jarl.find_applications_by(name) : Jarl.applications
-      apps.each do |app|
-        puts esc_green(app.running? ? "Restarting '#{app}'..." : "Starting '#{app}'...")
-        app.start(options[:scale])
+      if Jarl.find_application_instances_by(names).any?(&:running?)
+        down(*names)
+        Jarl.reload!
+      end
+      ais = Jarl.find_application_instances_by(names)
+      ais.each do |i|
+        puts esc_green "Starting '#{i.full_name}'..."
+        i.start!
       end
+      # apps = name ? Jarl.find_applications_by(name) : Jarl.applications
+      # apps.each do |app|
+      #   puts esc_green(app.running? ? "Restarting '#{app}'..." : "Starting '#{app}'...")
+      #   app.start
+      # end
       # show_jarl_applications_status(apps)
     end
 
     #
-    desc 'down [NAME]', 'Stop applications'
-    def down(name = nil)
+    desc 'down [NAME ...]', 'Stop applications'
+    def down(*names)
       Jarl.load(options)
-      apps = name ? Jarl.find_applications_by(name) : Jarl.applications
-      apps.each do |app|
-        next unless app.running?
-        app.instances.each do |i|
-          puts esc_yellow "Stopping '#{i.name}'..."
-          i.stop!
-        end
+      ais = Jarl.find_application_instances_by(names).select(&:running?)
+      puts esc_yellow 'No running applications found' unless ais.size > 0
+      ais.each do |i|
+        puts esc_yellow "Stopping '#{i.full_name}'..."
+        i.stop!
       end
     end
 
     desc 'execute NAME [COMMAND ...]', 'Run a single command against application image'
     def execute(name, command = nil, *args)
       Jarl.load(options)
-      app = Jarl.find_applications_by(name).first
+      apps = Jarl.find_applications_by(name)
+      if apps.size > 1
+        puts esc_yellow 'More than one application matches the pattern, using the first one:'
+        puts esc_yellow "  #{apps.map(&:full_name).join(', ')}"
+      end
+      app = apps.first
       abort "Failed to find application by name: '#{name}'" unless app
       app.execute(command, args)
     end
@@ -79,7 +85,13 @@ module Jarl
     desc 'ssh NAME [COMMAND ...]', 'Open an interactive SSH session to a running application or execute a command and exit'
     def ssh(name, command = nil, *args)
       Jarl.load(options)
-      app = Jarl.find_applications_by(name).first
+      ais = Jarl.find_application_instances_by(name).select(&:running?)
+      abort 'No running applications found' unless ais.size > 0
+      if ais.size > 1
+        puts esc_yellow 'More than one running application instance matches the pattern, using the first one:'
+        puts esc_yellow "  #{ais.map(&:full_name).join(', ')}"
+      end
+      app = ais.first
       abort "Failed to find application by name: '#{name}'" unless app
       abort "Application is not running: '#{app.full_name}'" unless app.running?
       app.ssh([command] + args)
@@ -87,45 +99,46 @@ module Jarl
 
     #
     option :ip, type: :boolean, desc: 'Show only IPs'
-    desc 'inspect [NAME]', 'Inspect applications'
-    def inspect(name = nil)
+    desc 'inspect [NAME ...]', 'Inspect running application instances'
+    def inspect(*names)
       Jarl.load(options)
-      apps = name ? Jarl.find_applications_by(name) : Jarl.applications
-      apps.each do |app|
+      ais = Jarl.find_application_instances_by(names).select(&:running?)
+      abort 'No running applications found' unless ais.size > 0
+      ais.each do |ai|
         if options[:ip]
-          puts app.instances.map(&:container).map(&:ip) if app.running?
+          puts ai.container.ip
         else
-          show_jarl_application_inspect(app)
+          show_jarl_application_instance_inspect(ai)
         end
       end
     end
 
-    desc 'build [NAME]', 'Rebuild docker images for Dockerfile based applications'
-    def build(name = nil)
+    desc 'build [NAME ...]', 'Rebuild docker images for Dockerfile based applications'
+    def build(*names)
       Jarl.load(options)
-      apps = name ? Jarl.find_applications_by(name) : Jarl.applications
+      apps = Jarl.find_applications_by(names)
       apps.select(&:image_is_a_path?).each do |app|
         puts esc_yellow "Building image for '#{app}'..."
         app.build
       end
     end
 
-    desc 'pull [NAME]', 'Pull docker images for regestry based applications'
-    def pull(name = nil)
+    desc 'pull [NAME ...]', 'Pull docker images for regestry based applications'
+    def pull(*names)
       Jarl.load(options)
-      apps = name ? Jarl.find_applications_by(name) : Jarl.applications
+      apps = Jarl.find_applications_by(names)
       apps.select(&:image_is_a_registry_path?).each do |app|
         puts esc_yellow "Pulling image '#{app}'..."
         app.pull
       end
     end
 
-    desc 'logs [NAME]', 'Show log output for applications'
-    def logs(name = nil)
+    desc 'logs [NAME ...]', 'Show log output for applications'
+    def logs(*names)
       Jarl.load(options)
-      apps = name ? Jarl.find_applications_by(name) : Jarl.applications
+      ais = Jarl.find_application_instances_by(names)
       threads = []
-      apps.select(&:running?).map(&:instances).flatten.each do |instance|
+      ais.select(&:running?).flatten.each do |instance|
         threads << Thread.new { instance.tail_log }
       end
 
@@ -148,14 +161,12 @@ module Jarl
       "Jarl v#{Jarl::VERSION}"
     end
 
-    def show_jarl_applications_status(apps)
-      if apps.size == 0
+    def show_jarl_application_instances_status(ais)
+      if ais.size == 0
         puts esc_yellow 'No applications found'
         return
       end
-      full_names = apps.map do |app|
-        app.running? ? app.instances.map { |i| i.container.name } : app.full_name
-      end.flatten
+      full_names = ais.map(&:full_name)
       max_full_name_len = [full_names.map(&:size).max, 12].max
       puts esc_format(
         ['APPLICATION', max_full_name_len],
@@ -164,20 +175,18 @@ module Jarl
         ['IP', 12],
         ['PORTS']
       )
-      apps.each do |app|
-        if app.running?
-          app.instances.each do |i|
-            puts esc_format(
-              [i.container.name, max_full_name_len, :yellow],
-              [i.container.id, 12, :green],
-              [seconds_to_human(i.container.uptime), 12, :yellow],
-              [i.container.ip, 12, :yellow],
-              [i.container.ports.map { |p| "#{p[:from]}" }.join(', ')]
-            )
-          end
+      ais.each do |i|
+        if i.running?
+          puts esc_format(
+            [i.container.name, max_full_name_len, :yellow],
+            [i.container.id, 12, :green],
+            [seconds_to_human(i.container.uptime), 12, :yellow],
+            [i.container.ip, 12, :yellow],
+            [i.container.ports.map { |p| "#{p[:from]}" }.join(', ')]
+          )
         else
           puts esc_format(
-            [app.full_name, max_full_name_len, :yellow],
+            [i.full_name, max_full_name_len, :yellow],
             ['no', 12],
             ['', 12],
             ['', 12],
@@ -187,21 +196,21 @@ module Jarl
       end
     end
 
-    def show_jarl_application_inspect(app)
-      unless app.running?
-        puts esc_yellow("#{app.full_name}: ") + 'down'
+    def show_jarl_application_instance_inspect(ai)
+      unless ai.running?
+        puts esc_yellow("#{ai.full_name}: ") + 'off'
         return
       end
-      app.instances.map(&:container).each do |container|
-        puts esc_yellow "#{container.name}: " + esc_green(container.id)
-        puts "      app: #{esc_yellow app.full_name}"
-        puts "    image: #{esc_yellow container.image}"
-        puts "  full ID: #{esc_yellow container.long_id}"
-        puts "   uptime: #{esc_yellow seconds_to_human container.uptime}"
-        puts "       IP: #{esc_yellow container.ip}"
-        puts "    ports: #{esc_yellow container.ports.map { |p| "#{p[:from]}->#{p[:to]}"}.join(', ')}"
-        puts "  volumes: #{esc_yellow container.params['Volumes']}"
-      end
+      app = ai.application
+      container = ai.container
+      puts esc_yellow "#{container.name}: " + esc_green(container.id)
+      puts "      app: #{esc_yellow app.full_name}"
+      puts "    image: #{esc_yellow container.image}"
+      puts "  full ID: #{esc_yellow container.long_id}"
+      puts "   uptime: #{esc_yellow seconds_to_human container.uptime}"
+      puts "       IP: #{esc_yellow container.ip}"
+      puts "    ports: #{esc_yellow container.ports.map { |p| "#{p[:from]}->#{p[:to]}"}.join(', ')}"
+      puts "  volumes: #{esc_yellow container.volumes}"
     end
   end # class CLI
 end # module Jarl

data/lib/jarl/docker.rb

@@ -64,9 +64,17 @@ module Docker
     @docker_containers_running
   end
 
+  # Returns `docker ps` info inspector instance
+  #
+  def self.ps
+    @docker_ps ||= Ps.new
+  end
+
+
   # Reloads lists of images and containers
   #
   def self.reload!
+    @docker_ps = nil
     @docker_images = nil
     @docker_images_used = nil
     @docker_containers_running = nil
@@ -134,6 +142,52 @@ module Docker
     sh docker_cmd
   end
 
+  # `docker ps` info inspector
+  #
+  class Ps
+    FIELDS = [
+      'CONTAINER ID', 'IMAGE', 'COMMAND', 'CREATED', 'STATUS', 'PORTS', 'NAMES'
+    ]
+
+    attr_reader :entries
+
+    def initialize
+      lines = `docker ps`.split("\n")
+      @headers = lines.shift
+      @data = lines
+      @entries = lines.map do |line|
+        FIELDS.map { |name| [name, field(line, name)] }.to_h
+      end
+    end
+
+    def field_i_start(name)
+      i_start = @headers.index(name)
+      fail "Failed to find the field #{name} in docker ps" unless i_start
+      i_start
+    end
+
+    # @return [nil,Integer] right index for field or -1 if the field is rightmost
+    #
+    def field_i_end(name)
+      i_start = field_i_start(name)
+      r_headers = @headers[i_start..-1].sub(/^#{name}/, '')
+      m = r_headers.match(/^(\s+)/)
+      m ? i_start + name.size + m[1].size - 1 : -1
+    end
+
+    def field_i_range(name)
+      field_i_start(name)..field_i_end(name)
+    end
+
+    def field(line, name)
+      line[field_i_range(name)].strip
+    end
+
+    def [](id)
+      entries.find { |e| id == e['CONTAINER ID'] }
+    end
+  end
+
   # Image
   #
   class Image
@@ -205,24 +259,54 @@ module Docker
   # Container
   #
   class Container
-    attr_accessor :id, :long_id, :name, :image, :image_id, :ip, :ps, :ports, :params
+    attr_accessor :id
 
     def initialize(id)
       @id = id
-      @ps = `docker ps | grep #{id}`
-      container_inspect = `docker inspect #{id}`
-      @params = JSON.parse(container_inspect).first
-      @long_id = params['Id']
-      @name = params['Name'].gsub('/', '')
-      @image = params['Config']['Image']
-      @image_id = params['Image']
-      @ip = params['NetworkSettings']['IPAddress']
-      port_maps = params['NetworkSettings']['Ports']
-      @ports = port_maps.keys.map do |port|
+    end
+
+    def ps
+      Docker.ps[id] or fail "Failed to find ps info for #{id}"
+    end
+
+    def container_inspect
+      return @container_inspect if @container_inspect
+      # puts "Loading inspect for: #{ps}"
+      @container_inspect ||= JSON.parse(`docker inspect #{id}`).first
+    end
+
+    def long_id
+      container_inspect['Id']
+    end
+
+    def name
+      ps['NAMES']
+      # container_inspect['Name'].gsub('/', '')
+    end
+
+    def image
+      container_inspect['Config']['Image']
+    end
+
+    def image_id
+      container_inspect['Image']
+    end
+
+    def ip
+      container_inspect['NetworkSettings']['IPAddress']
+    end
+
+    def ports
+      port_maps = container_inspect['NetworkSettings']['Ports']
+      port_maps.keys.map do |port|
         { from: port, to: port_maps[port] }
       end
     end
 
+    def volumes
+      container_inspect['Volumes']
+    end
+
     def open_ssh_session!(params = {}, command = nil)
       ssh_flags = ['-oStrictHostKeyChecking=no']
       if params['ssh_identity']
@@ -246,8 +330,8 @@ module Docker
     end
 
     def uptime
-      params['State'] && params['State']['StartedAt'] &&
-      Time.now.utc - DateTime.parse(params['State']['StartedAt']).to_time.utc
+      container_inspect['State'] && container_inspect['State']['StartedAt'] &&
+      Time.now.utc - DateTime.parse(container_inspect['State']['StartedAt']).to_time.utc
     end
 
     def self.clean_containers(*names)

data/lib/jarl/version.rb

@@ -1,3 +1,3 @@
 module Jarl
-  VERSION = '0.7.0'
+  VERSION = '0.8.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jarl
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  version: 0.8.1
 platform: ruby
 authors:
 - Alex Kukushkin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-15 00:00:00.000000000 Z
+date: 2015-07-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -111,7 +111,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.2
+rubygems_version: 2.4.5
 signing_key: 
 specification_version: 4
 summary: Jarl, docker container management tool