docker-compose-api 1.0.5 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8cd19119cd22c6ff9c235e71f0f3b7dda2170cd9
-  data.tar.gz: d8a5b668de10c6fecad255cc96f0359f59c1888c
+  metadata.gz: cf18202df3237d79dc3ef72446eec4f226d12ec0
+  data.tar.gz: 1810eb1c15212070d375d6bf626cd8b94ab7bd81
 SHA512:
-  metadata.gz: 38ccca06b4af322ed96bab86176f2ded9b61da314cd51b57cb485d4dc445a074cca17a800d20450f6731078fc7c3b36ca484f50baf218ec0db7cccba7703daf6
-  data.tar.gz: 169c08e927c55f7544036e2a4c4572300cfc886bd6ae035e02cb3ab1cd93bf95e9b0dbcbbbfd073a85b3f7fb5a81224d90bca6182a3ce5c56714690fa0292d6c
+  metadata.gz: 4108355ffb6c39c9424b98ce271b83f1e992d3bfd9bbc067c5d570ba1996ec946af63de1babecb8640dfa84452eb930654060c551ecee2e23025a7bfdd6cbb75
+  data.tar.gz: da6d88fe21804f589edcbdb5287518c0b8d9f8a9e7cbec06c701b9c43c4347a6c999ec979086bfd169b4cd5cefc0c85b622c0a04dd3269f8e7fa2829e320d8ab

data/README.md

@@ -43,11 +43,26 @@ DockerCompose.version
 # Loading a compose file
 compose = DockerCompose.load('[path to docker compose file]')
 
+# 'Load' method accepts a second argument, telling to do load or not
+# containers started previously by this compose file.
+#
+# So, loading a compose file + containers started by this compose previously
+compose = DockerCompose.load('[path to docker compose file]', true)
+
 # Accessing containers
 compose.containers                                   # access all containers
 compose.containers['container_label']                # access a container by its label (DEPRECATED)
 compose.get_containers_by(label: 'foo', name: 'bar') # Returns an array of all containers with label = 'foo' and name = bar
 
+# Containers names are generated using the pattern below:
+#  [Directory name]_[Container label]_[Sequential ID]
+#
+# So, you can access a container by its full name...
+compose.get_containers_by(name: 'myawessomedir_foobar_1')
+
+# ... or by its given name (ignores both prefix and suffix)
+compose.get_containers_by_given_name('foobar')
+
 # Starting containers (and their dependencies)
 compose.start                                    # start all containers
 compose.start(['container1', 'container2', ...]) # start a list of specific containers

data/docker-compose-api.gemspec

@@ -18,7 +18,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "docker-api", "1.22.2"
+  spec.add_dependency "docker-api", "~> 1.22"
 
   spec.add_development_dependency "bundler", "~> 1.7"
   spec.add_development_dependency "rspec", "~> 3.3"

data/lib/docker-compose.rb

@@ -17,16 +17,30 @@ module DockerCompose
   # Load a given docker-compose file.
   # Returns a new Compose object
   #
-  def self.load(filepath)
+  def self.load(filepath, do_load_running_containers = false)
     unless File.exist?(filepath)
       raise ArgumentError, 'Compose file doesn\'t exists'
     end
 
     compose = Compose.new
 
+    # Create containers from compose file
     _compose_entries = YAML.load_file(filepath)
-    _compose_entries.each do |entry|
-      compose.add_container(create_container(entry))
+
+    if _compose_entries
+      _compose_entries.each do |entry|
+        compose.add_container(create_container(entry))
+      end
+    end
+
+    # Load running containers
+    if do_load_running_containers
+      Docker::Container
+        .all(all: true)
+        .select {|c| c.info['Names'].last.match(/\A\/#{ComposeUtils.dir_name}\w*/) }
+        .each do |container|
+          compose.add_container(load_running_container(container))
+      end
     end
 
     # Perform containers linkage
@@ -45,9 +59,29 @@ module DockerCompose
       ports: attributes[1]['ports'],
       volumes: attributes[1]['volumes'],
       command: attributes[1]['command'],
-      environment: attributes[1]['environment']
+      environment: attributes[1]['environment'],
+      labels: attributes[1]['labels']
     })
   end
 
-  private_class_method :create_container
+  def self.load_running_container(container)
+    info = container.json
+
+    container_args = {
+      label:       info['Name'].split(/_/)[1] || '',
+      full_name:   info['Name'],
+      image:       info['Image'],
+      build:       nil,
+      links:       info['HostConfig']['Links'],
+      ports:       ComposeUtils.format_ports_from_running_container(info['NetworkSettings']['Ports']),
+      volumes:     info['Config']['Volumes'],
+      command:     info['Config']['Cmd'].join(' '),
+      environment: info['Config']['Env'],
+      labels:      info['Config']['Labels']
+    }
+
+    ComposeContainer.new(container_args, container)
+  end
+
+  private_class_method :create_container, :load_running_container
 end

data/lib/docker-compose/models/compose.rb

@@ -15,6 +15,11 @@ class Compose
   # Add a new container to compose
   #
   def add_container(container)
+    # Avoid duplicated labels on compose
+    while @containers.has_key?(container.attributes[:label]) do
+      container.attributes[:label].succ!
+    end
+
     @containers[container.attributes[:label]] = container
     true
   end
@@ -28,6 +33,16 @@ class Compose
     end
   end
 
+  #
+  # Select containers based on its given name
+  # (ignore basename)
+  #
+  def get_containers_by_given_name(given_name)
+    @containers.select { |label, container|
+      container.attributes[:name].match(/#{ComposeUtils.dir_name}_#{given_name}_\d+/)
+    }.values
+  end
+
   #
   # Create link relations among containers
   #

data/lib/docker-compose/models/compose_container.rb

@@ -4,24 +4,25 @@ require_relative 'compose_port'
 require_relative '../utils/compose_utils'
 
 class ComposeContainer
-  attr_reader :attributes, :container, :dependencies
+  attr_reader :attributes, :internal_image, :container, :dependencies
 
-  def initialize(hash_attributes)
+  def initialize(hash_attributes, docker_container = nil)
     @attributes = {
       label: hash_attributes[:label],
-      name: hash_attributes[:name].nil? ? hash_attributes[:label] : hash_attributes[:name],
+      name: hash_attributes[:full_name] || ComposeUtils.generate_container_name(hash_attributes[:name], hash_attributes[:label]),
       image: ComposeUtils.format_image(hash_attributes[:image]),
       build: hash_attributes[:build],
       links: ComposeUtils.format_links(hash_attributes[:links]),
       ports: prepare_ports(hash_attributes[:ports]),
       volumes: hash_attributes[:volumes],
       command: ComposeUtils.format_command(hash_attributes[:command]),
-      environment: prepare_environment(hash_attributes[:environment])
+      environment: prepare_environment(hash_attributes[:environment]),
+      labels: prepare_labels(hash_attributes[:labels])
     }.reject{ |key, value| value.nil? }
 
     # Docker client variables
     @internal_image = nil
-    @container = nil
+    @container = docker_container
     @dependencies = []
   end
 
@@ -68,6 +69,7 @@ class ComposeContainer
       Env: @attributes[:environment],
       Volumes: volumes,
       ExposedPorts: exposed_ports,
+      Labels: @attributes[:labels],
       HostConfig: {
         Binds: volume_binds,
         Links: links,
@@ -163,6 +165,14 @@ class ComposeContainer
     env_entries.to_a.map { |x| x.join('=') }
   end
 
+  #
+  # Forces the labels structure to use the hash format.
+  #
+  def prepare_labels(labels)
+    return labels unless labels.is_a?(Array)
+    Hash[labels.map { |label| label.split('=') }]
+  end
+
   #
   # Check if a given image already exists in host
   #

data/lib/docker-compose/utils/compose_utils.rb

@@ -1,4 +1,29 @@
 module ComposeUtils
+  @dir_name = File.split(Dir.pwd).last.gsub(/[-_]/, '')
+  @current_container_id = nil
+
+  #
+  # Returns the directory name where compose
+  # file is saved (used in container naming)
+  #
+  def self.dir_name
+    @dir_name
+  end
+
+  #
+  # Provides the next available ID
+  # to container names
+  #
+  def self.next_available_id
+    if @current_container_id.nil?
+      # Discovery the max id used by already running containers
+      # (default to '0' if no container is running)
+      @current_container_id = Docker::Container.all(all: true).map {|c| c.info['Names'].last.split(/_/).last.to_i}.flatten.max || 0
+    end
+
+    @current_container_id += 1
+  end
+
   #
   # Format a given docker image in a complete structure (base image + tag)
   #
@@ -58,6 +83,30 @@ module ComposeUtils
     compose_port
   end
 
+  #
+  # Format ports from running container
+  #
+  def self.format_ports_from_running_container(port_entry)
+    entries = []
+    container_port = nil
+    host_ip = nil
+    host_port = nil
+
+    if port_entry.nil?
+      return entries
+    end
+
+    port_entry.each do |key, value|
+      container_port = key.gsub(/\D/, '').to_i
+      host_ip = value.first['HostIp']
+      host_port = value.first['HostPort']
+
+      entries << "#{container_port}:#{host_ip}:#{host_port}"
+    end
+
+    entries
+  end
+
   #
   # Generate a pair key:hash with
   # format {service:label}
@@ -83,4 +132,19 @@ module ComposeUtils
 
     links
   end
+
+  #
+  # Generate a container name, based on:
+  # - directory where the compose file is saved;
+  # - container name (or label, if name isn't provided);
+  # - a sequential index;
+  #
+  def self.generate_container_name(container_name, container_label)
+    label = container_name.nil? ? container_label : container_name
+    index = next_available_id
+
+    "#{@dir_name}_#{label}_#{index}"
+  end
+
+  private_class_method :next_available_id
 end

data/lib/version.rb

@@ -1,5 +1,5 @@
 module DockerCompose
   def self.version
-    "1.0.5"
+    "1.1.0"
   end
 end

data/spec/docker-compose/docker_compose_spec.rb

@@ -1,286 +1,332 @@
 require 'spec_helper'
 
 describe DockerCompose do
-  before(:all) do
-    @compose = DockerCompose.load(File.expand_path('spec/docker-compose/fixtures/compose_1.yaml'))
-  end
+  context 'Without memory' do
+    before(:all) do
+      @compose = DockerCompose.load(File.expand_path('spec/docker-compose/fixtures/compose_1.yaml'))
+    end
 
-  it 'should be able to access gem version' do
-    expect(DockerCompose.version).to_not be_nil
-  end
+    it 'should be able to access gem version' do
+      expect(DockerCompose.version).to_not be_nil
+    end
 
-  it 'should be able to access Docker client' do
-    expect(DockerCompose.docker_client).to_not be_nil
-  end
+    it 'should be able to access Docker client' do
+      expect(DockerCompose.docker_client).to_not be_nil
+    end
 
-  it 'should read a YAML file correctly' do
-    expect(@compose.containers.length).to eq(3)
-  end
+    it 'should read a YAML file correctly' do
+      expect(@compose.containers.length).to eq(3)
+    end
 
-  it 'should raise error when reading an invalid YAML file' do
-    expect{DockerCompose.load('')}.to raise_error(ArgumentError)
-  end
+    it 'should raise error when reading an invalid YAML file' do
+      expect{DockerCompose.load('')}.to raise_error(ArgumentError)
+    end
 
-  context 'All containers' do
-    it 'should start/stop all containers' do
-      # Start containers to test Stop
-      @compose.start
-      @compose.containers.values.each do |container|
-        expect(container.running?).to be true
+    context 'All containers' do
+      it 'should start/stop all containers' do
+        # Start containers to test Stop
+        @compose.start
+        @compose.containers.values.each do |container|
+          expect(container.running?).to be true
+        end
+
+        # Stop containers
+        @compose.stop
+        @compose.containers.values.each do |container|
+          expect(container.running?).to be false
+        end
       end
 
-      # Stop containers
-      @compose.stop
-      @compose.containers.values.each do |container|
-        expect(container.running?).to be false
-      end
-    end
-
-    it 'should start/kill all containers' do
-      # Start containers to test Kill
-      @compose.start
-      @compose.containers.values.each do |container|
-        expect(container.running?).to be true
+      it 'should start/kill all containers' do
+        # Start containers to test Kill
+        @compose.start
+        @compose.containers.values.each do |container|
+          expect(container.running?).to be true
+        end
+
+        # Kill containers
+        @compose.kill
+        @compose.containers.values.each do |container|
+          expect(container.running?).to be false
+        end
       end
 
-      # Kill containers
-      @compose.kill
-      @compose.containers.values.each do |container|
-        expect(container.running?).to be false
+      it 'should start/delete all containers' do
+        # Start containers to test Delete
+        @compose.start
+        @compose.containers.values.each do |container|
+          expect(container.running?).to be true
+        end
+
+        # Delete containers
+        @compose.delete
+        @compose.containers.values.each do |container|
+          expect(container.exist?).to be false
+        end
       end
     end
 
-    it 'should start/delete all containers' do
-      # Start containers to test Delete
-      @compose.start
-      @compose.containers.values.each do |container|
-        expect(container.running?).to be true
+    context 'Single container' do
+      context 'Without dependencies' do
+        it 'should start/stop a single container' do
+          container1 = @compose.containers.values.first.attributes[:label]
+          container2 = @compose.containers.values[1].attributes[:label]
+
+          @compose.start([container2])
+          expect(@compose.containers[container1].running?).to be false
+          expect(@compose.containers[container2].running?).to be true
+
+          @compose.stop([container2])
+          expect(@compose.containers[container1].running?).to be false
+          expect(@compose.containers[container2].running?).to be false
+        end
+
+        it 'should start/kill a single container' do
+          container1 = @compose.containers.values.first.attributes[:label]
+          container2 = @compose.containers.values[1].attributes[:label]
+
+          @compose.start([container2])
+          expect(@compose.containers[container1].running?).to be false
+          expect(@compose.containers[container2].running?).to be true
+
+          @compose.kill([container2])
+          expect(@compose.containers[container1].running?).to be false
+          expect(@compose.containers[container2].running?).to be false
+        end
       end
 
-      # Delete containers
-      @compose.delete
-      @compose.containers.values.each do |container|
-        expect(container.exist?).to be false
+      context 'With dependencies' do
+        it 'should start/stop a single container' do
+          container1 = @compose.containers.values.first.attributes[:label]
+          container2 = @compose.containers.values[1].attributes[:label]
+
+          @compose.start([container1])
+          expect(@compose.containers[container1].running?).to be true
+          expect(@compose.containers[container2].running?).to be true
+
+          @compose.stop([container1])
+          expect(@compose.containers[container1].running?).to be false
+          expect(@compose.containers[container2].running?).to be true
+
+          @compose.stop([container2])
+          expect(@compose.containers[container2].running?).to be false
+        end
+
+        it 'should start/kill a single container' do
+          container1 = @compose.containers.values.first.attributes[:label]
+          container2 = @compose.containers.values[1].attributes[:label]
+
+          @compose.start([container1])
+          expect(@compose.containers[container1].running?).to be true
+          expect(@compose.containers[container2].running?).to be true
+
+          @compose.kill([container1])
+          expect(@compose.containers[container1].running?).to be false
+          expect(@compose.containers[container2].running?).to be true
+
+          @compose.kill([container2])
+          expect(@compose.containers[container2].running?).to be false
+        end
+
+        it 'should be able to ping a dependent container' do
+          container1 = @compose.containers.values.first.attributes[:label]
+          container2 = @compose.containers.values[1].attributes[:label]
+
+          # Start all containers
+          @compose.start
+          expect(@compose.containers[container1].running?).to be true
+          expect(@compose.containers[container2].running?).to be true
+
+          # Ping container2 from container1
+          ping_response = @compose.containers[container1].container.exec(['ping', '-c', '3', 'busybox2'])
+          expect(ping_response[2]).to eq(0) # Status 0 = OK
+        end
+
+        it 'should be able to ping a dependent aliased container' do
+          container2 = @compose.containers.values[1].attributes[:label]
+          container3 = @compose.containers.values[2].attributes[:label]
+
+          # Start all containers
+          @compose.start
+          expect(@compose.containers[container2].running?).to be true
+          expect(@compose.containers[container3].running?).to be true
+
+          # Ping container3 from container1
+          ping_response = @compose.containers[container3].container.exec(['ping', '-c', '3', 'bb2'])
+          expect(ping_response[2]).to eq(0) # Status 0 = OK
+        end
       end
     end
-  end
 
-  context 'Single container' do
-    context 'Without dependencies' do
-      it 'should start/stop a single container' do
-        container1 = @compose.containers.values.first.attributes[:label]
-        container2 = @compose.containers.values[1].attributes[:label]
-
-        # Should start Redis only, since it hasn't dependencies
-        @compose.start([container2])
-        expect(@compose.containers[container1].running?).to be false
-        expect(@compose.containers[container2].running?).to be true
-
-        # Stop Redis
-        @compose.stop([container2])
-        expect(@compose.containers[container1].running?).to be false
-        expect(@compose.containers[container2].running?).to be false
-      end
+    it 'should assign ports' do
+      container = @compose.get_containers_by(label: 'busybox1').first
 
-      it 'should start/kill a single container' do
-        container1 = @compose.containers.values.first.attributes[:label]
-        container2 = @compose.containers.values[1].attributes[:label]
+      # Start container
+      container.start
 
-        # Should start Redis only, since it hasn't dependencies
-        @compose.start([container2])
-        expect(@compose.containers[container1].running?).to be false
-        expect(@compose.containers[container2].running?).to be true
+      port_bindings = container.stats['HostConfig']['PortBindings']
+      exposed_ports = container.stats['Config']['ExposedPorts']
 
-        # Stop Redis
-        @compose.kill([container2])
-        expect(@compose.containers[container1].running?).to be false
-        expect(@compose.containers[container2].running?).to be false
-      end
-    end # context 'Without dependencies'
-
-    context 'With dependencies' do
-      it 'should start/stop a single container' do
-        container1 = @compose.containers.values.first.attributes[:label]
-        container2 = @compose.containers.values[1].attributes[:label]
-
-        # Should start Ubuntu and Redis, since Ubuntu depends on Redis
-        @compose.start([container1])
-        expect(@compose.containers[container1].running?).to be true
-        expect(@compose.containers[container2].running?).to be true
-
-        # Stop Ubuntu (Redis keeps running)
-        @compose.stop([container1])
-        expect(@compose.containers[container1].running?).to be false
-        expect(@compose.containers[container2].running?).to be true
-
-        # Stop Redis
-        @compose.stop([container2])
-        expect(@compose.containers[container2].running?).to be false
-      end
+      # Check port bindings
+      expect(port_bindings.length).to eq(3)
+      expect(port_bindings.key?('3000/tcp')).to be true
+      expect(port_bindings.key?('8000/tcp')).to be true
+      expect(port_bindings.key?('8001/tcp')).to be true
 
-      it 'should start/kill a single container' do
-        container1 = @compose.containers.values.first.attributes[:label]
-        container2 = @compose.containers.values[1].attributes[:label]
+      # Check exposed ports
+      expect(exposed_ports.key?('3000/tcp')).to be true
+      expect(exposed_ports.key?('8000/tcp')).to be true
+      expect(exposed_ports.key?('8001/tcp')).to be true
 
-        # Should start Ubuntu and Redis, since Ubuntu depends on Redis
-        @compose.start([container1])
-        expect(@compose.containers[container1].running?).to be true
-        expect(@compose.containers[container2].running?).to be true
+      # Stop container
+      container.stop
+    end
 
-        # Kill Ubuntu (Redis keeps running)
-        @compose.kill([container1])
-        expect(@compose.containers[container1].running?).to be false
-        expect(@compose.containers[container2].running?).to be true
+    it 'should link containers' do
+      container = @compose.get_containers_by(label: 'busybox1').first
 
-        # Kill Redis
-        @compose.kill([container2])
-        expect(@compose.containers[container2].running?).to be false
-      end
+      # Start container
+      container.start
 
-      it 'should be able to ping a dependent container' do
-        container1 = @compose.containers.values.first.attributes[:label]
-        container2 = @compose.containers.values[1].attributes[:label]
+      # Ubuntu should be linked to Redis
+      links = container.stats['HostConfig']['Links']
+      expect(links.length).to eq(1)
 
-        # Start all containers
-        @compose.start
-        expect(@compose.containers[container1].running?).to be true
-        expect(@compose.containers[container2].running?).to be true
+      # Stop container
+      container.stop
+    end
 
-        # Ping container2 from container1
-        ping_response = @compose.containers[container1].container.exec(['ping', '-c', '3', 'busybox2'])
-        expect(ping_response[2]).to eq(0) # Status 0 = OK
-      end
+    it 'binds volumes' do
+      container = @compose.get_containers_by(label: 'busybox1').first
 
-      it 'should be able to ping a dependent aliased container' do
-        container2 = @compose.containers.values[1].attributes[:label]
-        container3 = @compose.containers.values[2].attributes[:label]
+      # Start container
+      container.start
 
-        # Start all containers
-        @compose.start
-        expect(@compose.containers[container2].running?).to be true
-        expect(@compose.containers[container3].running?).to be true
+      volumes = container.stats['HostConfig']['Binds']
+      expect(volumes).to match_array(['/tmp/test:/tmp:ro'])
 
-        # Ping container3 from container1
-        ping_response = @compose.containers[container3].container.exec(['ping', '-c', '3', 'bb2'])
-        expect(ping_response[2]).to eq(0) # Status 0 = OK
-      end
-    end # context 'with dependencies'
-  end # context 'Single container'
+      # Stop container
+      container.stop
+    end
 
-  it 'should assign ports' do
-    container1 = @compose.containers.values.first
+    it 'supports setting environment as array' do
+      container = @compose.get_containers_by(label: 'busybox1').first
 
-    # Start container
-    container1.start
+      # Start container
+      container.start
 
-    port_bindings = container1.stats['HostConfig']['PortBindings']
-    exposed_ports = container1.stats['Config']['ExposedPorts']
+      env = container.stats['Config']['Env']
+      expect(env).to eq(%w(MYENV1=variable1))
 
-    # Check port bindings
-    expect(port_bindings.length).to eq(3)
-    expect(port_bindings.key?('3000/tcp')).to be true
-    expect(port_bindings.key?('8000/tcp')).to be true
-    expect(port_bindings.key?('8001/tcp')).to be true
+      # Stop container
+      container.stop
+    end
 
-    # Check exposed ports
-    expect(exposed_ports.key?('3000/tcp')).to be true
-    expect(exposed_ports.key?('8000/tcp')).to be true
-    expect(exposed_ports.key?('8001/tcp')).to be true
+    it 'supports setting environment as hash' do
+      container = @compose.get_containers_by(label: 'busybox2').first
 
-    # Stop container
-    container1.stop
-  end
+      # Start container
+      container.start
 
-  it 'should link containers' do
-    container1 = @compose.containers.values.first
+      env = container.stats['Config']['Env']
+      expect(env).to eq(%w(MYENV2=variable2))
 
-    # Start container
-    container1.start
+      # Stop container
+      container.stop
+    end
 
-    # Ubuntu should be linked to Redis
-    links = container1.stats['HostConfig']['Links']
-    expect(links.length).to eq(1)
+    it 'supports setting labels as an array' do
+      container = @compose.get_containers_by(label: 'busybox1').first
 
-    # Stop container
-    container1.stop
-  end
+      # Start container
+      container.start
 
-  it 'binds volumes' do
-    container1 = @compose.containers.values.first
+      env = container.stats['Config']['Labels']
+      expect(env).to eq({ 'com.example.foo' => 'bar' })
 
-    # Start container
-    container1.start
+      # Stop container
+      container.stop
+    end
 
-    volumes = container1.stats['HostConfig']['Binds']
-    expect(volumes).to match_array(['/tmp/test:/tmp:ro'])
+    it 'supports setting labels as a hash' do
+      container = @compose.get_containers_by(label: 'busybox2').first
 
-    # Stop container
-    container1.stop
-  end
+      # Start container
+      container.start
 
-  it 'supports setting environment as array' do
-    container1 = @compose.containers.values.first
+      env = container.stats['Config']['Labels']
+      expect(env).to eq({ 'com.example.foo' => 'bar' })
 
-    # Start container
-    container1.start
+      # Stop container
+      container.stop
+    end
 
-    env = container1.stats['Config']['Env']
-    expect(env).to eq(%w(MYENV1=variable1))
+    it 'should assing given name to container' do
+      container = @compose.get_containers_by(label: 'busybox1').first
 
-    # Stop container
-    container1.stop
-  end
+      # Start container
+      container.start
 
-  it 'supports setting environment as hash' do
-    container1 = @compose.containers.values[1]
+      container_name = container.stats['Name']
+      expect(container_name).to match(/\/#{ComposeUtils.dir_name}_busybox-container_\d+/)
 
-    # Start container
-    container1.start
+      # Stop container
+      container.stop
+    end
 
-    env = container1.stats['Config']['Env']
-    expect(env).to eq(%w(MYENV2=variable2))
+    it 'should assing a random name to container when name is not given' do
+      container = @compose.get_containers_by(label: 'busybox2').first
 
-    # Stop container
-    container1.stop
-  end
+      # Start container
+      container.start
 
-  it 'should assing given name to container' do
-    container = @compose.containers.values[0]
+      container_name = container.stats['Name']
+      expect(container_name).to_not be_nil
 
-    # Start container
-    container.start
+      # Stop container
+      container.stop
+    end
 
-    container_name = container.stats['Name']
-    expect(container_name).to eq('/busybox-container')
+    it 'should filter containers by its attributes' do
+      expect(@compose.get_containers_by(label: 'busybox2')).to eq([@compose.containers['busybox2']])
+      expect(@compose.get_containers_by(name: @compose.containers['busybox1'].attributes[:name])).to eq([@compose.containers['busybox1']])
+      expect(@compose.get_containers_by_given_name('busybox-container')).to eq([@compose.containers['busybox1']])
+      expect(@compose.get_containers_by(image: 'busybox:latest')).to eq([
+          @compose.containers['busybox1'],
+          @compose.containers['busybox2'],
+          @compose.containers['busybox3']
+      ])
+    end
 
-    # Stop container
-    container.stop
+    after(:all) do
+      @compose.delete
+    end
   end
 
-  it 'should assing a random name to container when name is not given' do
-    container = @compose.containers.values[1]
+  context 'With memory' do
+    before(:all) do
+      @compose1 = DockerCompose.load(File.expand_path('spec/docker-compose/fixtures/compose_1.yaml'), false)
+      @compose1.start
 
-    # Start container
-    container.start
+      @compose2 = DockerCompose.load(File.expand_path('spec/docker-compose/fixtures/empty_compose.yml'), true)
+    end
 
-    container_name = container.stats['Name']
-    expect(container_name).to_not be_nil
+    it 'should load all running containers from this directory' do
+      expect(@compose2.containers.length).to eq(@compose1.containers.length)
+    end
 
-    # Stop container
-    container.stop
-  end
+    it '@compose2 should have the same containers of @compose1' do
+      docker_containers_compose1 = @compose1.containers.values.select { |c| c.container }
+      docker_containers_compose2 = @compose2.containers.values.select { |c| c.container }
 
-  it 'should filter containers by its attributes' do
-    expect(@compose.get_containers_by(label: 'busybox2')).to eq([@compose.containers['busybox2']])
-    expect(@compose.get_containers_by(name: 'busybox-container')).to eq([@compose.containers['busybox1']])
-    expect(@compose.get_containers_by(image: 'busybox:latest')).to eq([
-        @compose.containers['busybox1'],
-        @compose.containers['busybox2'],
-        @compose.containers['busybox3']
-    ])
-  end
+      # Check that both composes have the same containers (based on its names)
+      docker_containers_compose2.each_index do |index|
+        expect(docker_containers_compose2[index].attributes['Name']).to eq(docker_containers_compose1[index].attributes['Name'])
+      end
+    end
 
-  after(:all) do
-    @compose.delete
+    after(:all) do
+      @compose1.delete
+    end
   end
 end

data/spec/docker-compose/fixtures/compose_1.yaml

@@ -14,6 +14,8 @@ busybox1:
     - MYENV1=variable1
   volumes:
     - "/tmp/test:/tmp:ro"
+  labels:
+    - com.example.foo=bar
 
 busybox2:
   image: busybox
@@ -22,6 +24,8 @@ busybox2:
   command: ping localhost
   environment:
     MYENV2: variable2
+  labels:
+    com.example.foo: bar
 
 busybox3:
   image: busybox

data/spec/docker-compose/models/compose_container_spec.rb

@@ -11,7 +11,8 @@ describe ComposeContainer do
         ports: ['3000', '8000:8000', '127.0.0.1:8001:8001'],
         volumes: ['/tmp'],
         command: 'ping -c 3 localhost',
-        environment: ['ENVIRONMENT']
+        environment: ['ENVIRONMENT'],
+        labels: { 'com.example.foo' => 'bar' }
       }
 
       @entry = ComposeContainer.new(@attributes)
@@ -19,12 +20,13 @@ describe ComposeContainer do
 
     it 'should prepare attributes correctly' do
       expect(@entry.attributes[:image]).to eq(@attributes[:image])
-      expect(@entry.attributes[:name]).to eq(@attributes[:name])
+      expect(@entry.attributes[:name]).to match(/#{ComposeUtils.dir_name}_#{@attributes[:name]}_\d+/)
       expect(@entry.attributes[:links])
         .to eq({'service1' => 'label', 'service2' => 'service2'})
       expect(@entry.attributes[:volumes]).to eq(@attributes[:volumes])
       expect(@entry.attributes[:command]).to eq(@attributes[:command].split(' '))
       expect(@entry.attributes[:environment]).to eq(@attributes[:environment])
+      expect(@entry.attributes[:labels]).to eq(@attributes[:labels])
     end
 
     it 'should map ports' do
@@ -49,6 +51,10 @@ describe ComposeContainer do
       expect(port_entry.host_ip).to eq('127.0.0.1')
       expect(port_entry.host_port).to eq('8001')
     end
+
+    after(:all) do
+      @entry.delete
+    end
   end
 
   context 'From image' do
@@ -93,7 +99,7 @@ describe ComposeContainer do
       #Start container
       @entry.start
 
-      expect(@entry.stats['Name']).to eq("/#{@attributes[:name]}")
+      expect(@entry.stats['Name']).to match(/#{ComposeUtils.dir_name}_#{@attributes[:name]}_\d+/)
 
       # Stop container
       @entry.stop
@@ -103,16 +109,22 @@ describe ComposeContainer do
       #Start container
       @entry_autogen_name.start
 
-      expect(@entry_autogen_name.stats['Name']).to eq("/#{@entry_autogen_name.attributes[:label]}")
+      expect(@entry_autogen_name.stats['Name']).to match(/#{ComposeUtils.dir_name}_#{@entry_autogen_name.attributes[:label]}_\d+/)
 
       # Stop container
       @entry_autogen_name.stop
     end
+
+    after(:all) do
+      @entry.delete
+      @entry_autogen_name.delete
+    end
   end
 
   context 'From Dockerfile' do
     before(:all) do
       attributes = {
+        label: 'foobar',
         build: File.expand_path('spec/docker-compose/fixtures/'),
         links: ['links:links'],
         volumes: ['/tmp']
@@ -142,6 +154,11 @@ describe ComposeContainer do
       @entry.stop
       expect(@entry.running?).to be false
     end
+
+    after(:all) do
+      Docker::Image.get(@entry.internal_image).remove(force: true)
+      @entry.delete
+    end
   end
 
   context 'Without image or Dockerfile' do
@@ -159,6 +176,10 @@ describe ComposeContainer do
     it 'should not start a container' do
       expect{@entry.start}.to raise_error(ArgumentError)
     end
+
+    after(:all) do
+      @entry.delete
+    end
   end
 
   context 'With environment as a hash' do
@@ -175,9 +196,13 @@ describe ComposeContainer do
     it 'should prepare environment attribute correctly' do
       expect(@entry.attributes[:environment]).to eq(%w(ENVIRONMENT=VALUE))
     end
+
+    after(:all) do
+      @entry.delete
+    end
   end
 
-  describe '#prepare_volumes' do
+  describe 'prepare_volumes' do
     let(:attributes) do
       { image: 'busybox:latest' }
     end

data/spec/docker-compose/models/compose_spec.rb

@@ -72,5 +72,18 @@ describe Compose do
         expect(container3.dependencies.empty?).to be true
       end
     end
+
+    it 'should increment label when already exists' do
+      @compose = Compose.new
+
+      # Add the same container twice
+      @compose.add_container(ComposeContainer.new(@attributes_container1))
+      @compose.add_container(ComposeContainer.new(@attributes_container1))
+
+      label_first_container  = @compose.containers.keys[0]
+      label_second_container = @compose.containers.keys[1]
+
+      expect(label_first_container).to_not eq(label_second_container)
+    end
   end
 end

data/spec/docker-compose/utils/compose_utils_spec.rb

@@ -52,6 +52,26 @@ describe ComposeUtils do
     end
   end
 
+  context 'Format ports from running containers' do
+    before(:all) do
+      @hash_attr = {
+        '8000/tcp' => [{
+          'HostIp' => '0.0.0.0',
+          'HostPort' => '4444'
+        }]
+      }
+      @expected_format = ['8000:0.0.0.0:4444']
+    end
+
+    it 'should format ports correctly' do
+      expect(ComposeUtils.format_ports_from_running_container(@hash_attr)).to eq(@expected_format)
+    end
+
+    it 'should return an empty array when ports are nil' do
+      expect(ComposeUtils.format_ports_from_running_container(nil)).to eq([])
+    end
+  end
+
   context 'Format links' do
     it 'should recognize pattern "[service]"' do
       links = ComposeUtils.format_links(['service'])
@@ -65,4 +85,21 @@ describe ComposeUtils do
       expect(links['service']).to eq('label')
     end
   end
+
+  context 'Generate container name' do
+    before(:all) do
+      @name = 'foo'
+      @label = 'bar'
+    end
+
+    it 'should generate name with given name' do
+      name = ComposeUtils.generate_container_name(@name, @label)
+      expect(name).to match(/#{ComposeUtils.dir_name}_#{@name}_\d+/)
+    end
+
+    it 'should generate name with label' do
+      name = ComposeUtils.generate_container_name(nil, @label)
+      expect(name).to match(/#{ComposeUtils.dir_name}_#{@label}_\d+/)
+    end
+  end
 end

metadata

@@ -1,29 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: docker-compose-api
 version: !ruby/object:Gem::Version
-  version: 1.0.5
+  version: 1.1.0
 platform: ruby
 authors:
 - Mauricio S. Klein
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-01-22 00:00:00.000000000 Z
+date: 2016-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: docker-api
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.22.2
+        version: '1.22'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.22.2
+        version: '1.22'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -89,6 +89,7 @@ files:
 - spec/docker-compose/docker_compose_spec.rb
 - spec/docker-compose/fixtures/Dockerfile
 - spec/docker-compose/fixtures/compose_1.yaml
+- spec/docker-compose/fixtures/empty_compose.yml
 - spec/docker-compose/models/compose_container_spec.rb
 - spec/docker-compose/models/compose_spec.rb
 - spec/docker-compose/utils/compose_utils_spec.rb
@@ -121,6 +122,7 @@ test_files:
 - spec/docker-compose/docker_compose_spec.rb
 - spec/docker-compose/fixtures/Dockerfile
 - spec/docker-compose/fixtures/compose_1.yaml
+- spec/docker-compose/fixtures/empty_compose.yml
 - spec/docker-compose/models/compose_container_spec.rb
 - spec/docker-compose/models/compose_spec.rb
 - spec/docker-compose/utils/compose_utils_spec.rb