docker-compose-api 1.0.1 → 1.0.2

data/lib/docker-compose.rb

@@ -19,8 +19,7 @@ module DockerCompose
   #
   def self.load(filepath)
     unless File.exist?(filepath)
-      puts("Compose file doesn't exists")
-      raise ENOENT
+      raise ArgumentError, 'Compose file doesn\'t exists'
     end
 
     compose = Compose.new

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

@@ -28,8 +28,8 @@ class Compose
 
       next if links.nil?
 
-      links.each do |link|
-        dependency_container = @containers[link]
+      links.each do |service, label|
+        dependency_container = @containers[service]
         container.add_dependency(dependency_container)
       end
     end

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

@@ -1,16 +1,17 @@
 require 'docker'
+require 'securerandom'
 require_relative 'compose_port'
 require_relative '../utils/compose_utils'
 
 class ComposeContainer
-  attr_reader :attributes
+  attr_reader :attributes, :container, :dependencies
 
   def initialize(hash_attributes)
     @attributes = {
       label: hash_attributes[:label],
       image: ComposeUtils.format_image(hash_attributes[:image]),
       build: hash_attributes[:build],
-      links: hash_attributes[:links],
+      links: ComposeUtils.format_links(hash_attributes[:links]),
       ports: prepare_ports(hash_attributes[:ports]),
       volumes: hash_attributes[:volumes],
       command: ComposeUtils.format_command(hash_attributes[:command]),

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

@@ -57,4 +57,28 @@ module ComposeUtils
 
     compose_port
   end
+
+  #
+  # Generate a pair key:hash with
+  # format {service:label}
+  #
+  def self.format_links(links_array)
+    links = {}
+
+    return if links_array.nil?
+
+    links_array.each do |link|
+      parts = link.split(':')
+
+      case parts.length
+        when 1
+          links[parts[0]] = SecureRandom.hex
+
+        when 2
+          links[parts[0]] = parts[1]
+      end
+    end
+
+    links
+  end
 end

data/lib/version.rb

@@ -1,5 +1,5 @@
 module DockerCompose
   def self.version
-    "1.0.1"
+    "1.0.2"
   end
 end

data/spec/docker-compose/docker_compose_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe DockerCompose do
   before(:all) do
-    @compose = DockerCompose.load(File.expand_path('spec/docker-compose/fixtures/sample1.yaml'))
+    @compose = DockerCompose.load(File.expand_path('spec/docker-compose/fixtures/compose_1.yaml'))
   end
 
   it 'should be able to access gem version' do
@@ -17,6 +17,10 @@ describe DockerCompose do
     expect(@compose.containers.length).to eq(2)
   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
@@ -50,85 +54,99 @@ describe DockerCompose do
   context 'Single container' do
     context 'Without dependencies' do
       it 'should start/stop a single container' do
-        ubuntu = @compose.containers.values.first.attributes[:label]
-        redis  = @compose.containers.values.last.attributes[:label]
+        container1 = @compose.containers.values.first.attributes[:label]
+        container2 = @compose.containers.values.last.attributes[:label]
 
         # Should start Redis only, since it hasn't dependencies
-        @compose.start([redis])
-        expect(@compose.containers[ubuntu].running?).to be false
-        expect(@compose.containers[redis].running?).to be true
+        @compose.start([container2])
+        expect(@compose.containers[container1].running?).to be false
+        expect(@compose.containers[container2].running?).to be true
 
         # Stop Redis
-        @compose.stop([redis])
-        expect(@compose.containers[ubuntu].running?).to be false
-        expect(@compose.containers[redis].running?).to be false
+        @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
-        ubuntu = @compose.containers.values.first.attributes[:label]
-        redis  = @compose.containers.values.last.attributes[:label]
+        container1 = @compose.containers.values.first.attributes[:label]
+        container2 = @compose.containers.values.last.attributes[:label]
 
         # Should start Redis only, since it hasn't dependencies
-        @compose.start([redis])
-        expect(@compose.containers[ubuntu].running?).to be false
-        expect(@compose.containers[redis].running?).to be true
+        @compose.start([container2])
+        expect(@compose.containers[container1].running?).to be false
+        expect(@compose.containers[container2].running?).to be true
 
         # Stop Redis
-        @compose.kill([redis])
-        expect(@compose.containers[ubuntu].running?).to be false
-        expect(@compose.containers[redis].running?).to be false
+        @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
-        ubuntu = @compose.containers.values.first.attributes[:label]
-        redis  = @compose.containers.values.last.attributes[:label]
+        container1 = @compose.containers.values.first.attributes[:label]
+        container2 = @compose.containers.values.last.attributes[:label]
 
         # Should start Ubuntu and Redis, since Ubuntu depends on Redis
-        @compose.start([ubuntu])
-        expect(@compose.containers[ubuntu].running?).to be true
-        expect(@compose.containers[redis].running?).to be true
+        @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([ubuntu])
-        expect(@compose.containers[ubuntu].running?).to be false
-        expect(@compose.containers[redis].running?).to be true
+        @compose.stop([container1])
+        expect(@compose.containers[container1].running?).to be false
+        expect(@compose.containers[container2].running?).to be true
 
         # Stop Redis
-        @compose.stop([redis])
-        expect(@compose.containers[redis].running?).to be false
+        @compose.stop([container2])
+        expect(@compose.containers[container2].running?).to be false
       end
 
       it 'should start/kill a single container' do
-        ubuntu = @compose.containers.values.first.attributes[:label]
-        redis  = @compose.containers.values.last.attributes[:label]
+        container1 = @compose.containers.values.first.attributes[:label]
+        container2 = @compose.containers.values.last.attributes[:label]
 
         # Should start Ubuntu and Redis, since Ubuntu depends on Redis
-        @compose.start([ubuntu])
-        expect(@compose.containers[ubuntu].running?).to be true
-        expect(@compose.containers[redis].running?).to be true
+        @compose.start([container1])
+        expect(@compose.containers[container1].running?).to be true
+        expect(@compose.containers[container2].running?).to be true
 
         # Kill Ubuntu (Redis keeps running)
-        @compose.kill([ubuntu])
-        expect(@compose.containers[ubuntu].running?).to be false
-        expect(@compose.containers[redis].running?).to be true
+        @compose.kill([container1])
+        expect(@compose.containers[container1].running?).to be false
+        expect(@compose.containers[container2].running?).to be true
 
         # Kill Redis
-        @compose.kill([redis])
-        expect(@compose.containers[redis].running?).to be false
+        @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.last.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
     end # context 'with dependencies'
   end # context 'Single container'
 
   it 'should assign ports' do
-    ubuntu = @compose.containers.values.first
+    container1 = @compose.containers.values.first
 
     # Start container
-    ubuntu.start
+    container1.start
 
-    port_bindings = ubuntu.stats['HostConfig']['PortBindings']
-    exposed_ports = ubuntu.stats['Config']['ExposedPorts']
+    port_bindings = container1.stats['HostConfig']['PortBindings']
+    exposed_ports = container1.stats['Config']['ExposedPorts']
 
     # Check port bindings
     expect(port_bindings.length).to eq(3)
@@ -142,21 +160,21 @@ describe DockerCompose do
     expect(exposed_ports.key?('8001/tcp')).to be true
 
     # Stop container
-    ubuntu.stop
+    container1.stop
   end
 
   it 'should link containers' do
-    ubuntu = @compose.containers.values.first
+    container1 = @compose.containers.values.first
 
     # Start container
-    ubuntu.start
+    container1.start
 
     # Ubuntu should be linked to Redis
-    links = ubuntu.stats['HostConfig']['Links']
+    links = container1.stats['HostConfig']['Links']
     expect(links.length).to eq(1)
 
     # Stop container
-    ubuntu.stop
+    container1.stop
   end
 
   after(:all) do

data/spec/docker-compose/fixtures/Dockerfile

@@ -1,2 +1,2 @@
-FROM ubuntu
-CMD ["sleep", "1000"]
+FROM busybox
+CMD ["ping", "localhost"]

data/spec/docker-compose/fixtures/{sample1.yaml → compose_1.yaml}

@@ -1,5 +1,5 @@
-ubuntu:
-  image: ubuntu
+busybox1:
+  image: busybox
   ports:
     - "3000"
     - "8000:8000"
@@ -7,10 +7,11 @@ ubuntu:
   expose:
     - "5000"
   links:
-    - redis
-  command: /bin/sleep 60
+    - busybox2
+  command: ping busybox2
 
-redis:
-  image: redis
+busybox2:
+  image: busybox
   expose:
     - "6000"
+  command: ping localhost

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

@@ -2,87 +2,123 @@ require 'spec_helper'
 
 describe ComposeContainer do
   context 'Object creation' do
-    it 'should prepare the attributes correctly' do
-      attributes = {
-        image: 'ubuntu:latest',
-        links: ['links:links'],
+    before(:all) do
+      @attributes = {
+        image: 'busybox:latest',
+        links: ['service:label'],
         ports: ['3000', '8000:8000', '127.0.0.1:8001:8001'],
         volumes: {'/tmp' => {}},
-        command: 'ps aux',
+        command: 'ping -c 3 localhost',
         environment: ['ENVIRONMENT']
       }
 
-      entry = ComposeContainer.new(attributes)
+      @entry = ComposeContainer.new(@attributes)
+    end
 
-      expect(entry.attributes[:image]).to eq(attributes[:image])
-      expect(entry.attributes[:links]).to eq(attributes[:links])
-      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])
+    it 'should prepare attributes correctly' do
+      expect(@entry.attributes[:image]).to eq(@attributes[:image])
+      expect(@entry.attributes[:links]).to eq({'service' => 'label'})
+      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])
+    end
 
+    it 'should map ports' do
       # Check ports structure
-      expect(entry.attributes[:ports].length).to eq(attributes[:ports].length)
+      expect(@entry.attributes[:ports].length).to eq(@attributes[:ports].length)
 
       # Port 1: '3000'
-      port_entry = entry.attributes[:ports][0]
+      port_entry = @entry.attributes[:ports][0]
       expect(port_entry.container_port).to eq('3000')
       expect(port_entry.host_ip).to eq(nil)
       expect(port_entry.host_port).to eq(nil)
 
       # Port 2: '8000:8000'
-      port_entry = entry.attributes[:ports][1]
+      port_entry = @entry.attributes[:ports][1]
       expect(port_entry.container_port).to eq('8000')
       expect(port_entry.host_ip).to eq(nil)
       expect(port_entry.host_port).to eq('8000')
 
       # Port 3: '127.0.0.1:8001:8001'
-      port_entry = entry.attributes[:ports][2]
+      port_entry = @entry.attributes[:ports][2]
       expect(port_entry.container_port).to eq('8001')
       expect(port_entry.host_ip).to eq('127.0.0.1')
       expect(port_entry.host_port).to eq('8001')
     end
   end
 
-  context 'Start container' do
-    it 'should start/stop a container from image' do
+  context 'From image' do
+    before(:all) do
       attributes = {
-        image: 'ubuntu:latest',
+        image: 'busybox:latest',
         links: ['links:links'],
         volumes: {'/tmp' => {}},
-        command: 'ps aux',
+        command: 'ping -c 3 localhost',
         environment: ['ENVIRONMENT']
       }
 
-      entry = ComposeContainer.new(attributes)
+      @entry = ComposeContainer.new(attributes)
+    end
+
+    it 'should start/stop a container' do
+      #Start container
+      @entry.start
+      expect(@entry.running?).to be true
+
+      # Stop container
+      @entry.stop
+      expect(@entry.running?).to be false
+    end
 
+    it 'should provide container stats' do
       #Start container
-      entry.start
-      expect(entry.running?).to be true
+      @entry.start
+      expect(@entry.running?).to be true
+
+      expect(@entry.stats).to_not be_nil
 
       # Stop container
-      entry.stop
-      expect(entry.running?).to be false
+      @entry.stop
+      expect(@entry.running?).to be false
     end
+  end
 
-    it 'should start/stop a container from build' do
+  context 'From Dockerfile' do
+    before(:all) do
       attributes = {
         build: File.expand_path('spec/docker-compose/fixtures/'),
         links: ['links:links'],
         volumes: {'/tmp' => {}}
       }
 
-      entry = ComposeContainer.new(attributes)
+      @entry = ComposeContainer.new(attributes)
+    end
+
+    it 'should start/stop a container' do
+      #Start container
+      @entry.start
+      expect(@entry.running?).to be true
+
+      # Stop container
+      @entry.stop
+      expect(@entry.running?).to be false
+    end
 
+    it 'should provide container stats' do
       #Start container
-      entry.start
-      expect(entry.running?).to be true
+      @entry.start
+      expect(@entry.running?).to be true
+
+      expect(@entry.stats).to_not be_nil
 
       # Stop container
-      entry.stop
-      expect(entry.running?).to be false
+      @entry.stop
+      expect(@entry.running?).to be false
     end
+  end
 
-    it 'should not start a container without either image and build commands' do
+  context 'Without image or Dockerfile' do
+    before(:all) do
       attributes = {
         links: ['links:links'],
         volumes: {'/tmp' => {}},
@@ -90,8 +126,11 @@ describe ComposeContainer do
         environment: ['ENVIRONMENT']
       }
 
-      entry = ComposeContainer.new(attributes)
-      expect{entry.start}.to raise_error(ArgumentError)
+      @entry = ComposeContainer.new(attributes)
+    end
+
+    it 'should not start a container' do
+      expect{@entry.start}.to raise_error(ArgumentError)
     end
   end
 end

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

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe Compose do
+  context 'Initialize' do
+    before(:all) do
+      @compose = Compose.new
+    end
+
+    it 'should start with no containers' do
+      expect(@compose.containers.empty?).to be true
+    end
+  end
+
+  context 'Add containers' do
+    before(:all) do
+      @attributes_container1 = {
+        label: 'container1',
+        image: 'busybox:latest',
+        command: 'ping -c 3 localhost'
+      }
+
+      @attributes_container2 = {
+        label: 'container2',
+        image: 'busybox:latest',
+        links: ['container3'],
+        command: 'ping -c 3 localhost'
+      }
+
+      @attributes_container3 = {
+        label: 'container3',
+        image: 'busybox:latest',
+        command: 'ping -c 3 localhost'
+      }
+    end
+
+    context 'Without dependencies' do
+      before(:all) do
+        @compose = Compose.new
+        @compose.add_container(ComposeContainer.new(@attributes_container1))
+        @compose.add_container(ComposeContainer.new(@attributes_container3))
+        @compose.link_containers
+      end
+
+      it 'should have 2 containers' do
+        expect(@compose.containers.length).to eq(2)
+      end
+
+      it 'should not have dependencies between containers' do
+        @compose.containers.values.each do |container|
+          expect(container.dependencies.empty?).to be true
+        end
+      end
+    end
+
+    context 'With dependencies' do
+      before(:all) do
+        @compose = Compose.new
+        @compose.add_container(ComposeContainer.new(@attributes_container2))
+        @compose.add_container(ComposeContainer.new(@attributes_container3))
+        @compose.link_containers
+      end
+
+      it 'should have 2 containers' do
+        expect(@compose.containers.length).to eq(2)
+      end
+
+      it 'container2 should depend on container3' do
+        container2 = @compose.containers[@attributes_container2[:label]]
+        container3 = @compose.containers[@attributes_container3[:label]]
+
+        expect(container2.dependencies.include?(container3)).to be true
+        expect(container3.dependencies.empty?).to be true
+      end
+    end
+  end
+end

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

@@ -51,4 +51,18 @@ describe ComposeUtils do
       expect(compose_port.host_ip).to eq('127.0.0.1')
     end
   end
+
+  context 'Format links' do
+    it 'should recognize pattern "[service]"' do
+      links = ComposeUtils.format_links(['service'])
+      expect(links.key?('service')).to be true
+      expect(links['service']).to_not be_nil
+    end
+
+    it 'should recognize pattern "[service:label]"' do
+      links = ComposeUtils.format_links(['service:label'])
+      expect(links.key?('service')).to be true
+      expect(links['service']).to eq('label')
+    end
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: docker-compose-api
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-23 00:00:00.000000000 Z
+date: 2015-10-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: docker-api
@@ -97,8 +97,9 @@ files:
 - lib/version.rb
 - spec/docker-compose/docker_compose_spec.rb
 - spec/docker-compose/fixtures/Dockerfile
-- spec/docker-compose/fixtures/sample1.yaml
+- spec/docker-compose/fixtures/compose_1.yaml
 - spec/docker-compose/models/compose_container_spec.rb
+- spec/docker-compose/models/compose_spec.rb
 - spec/docker-compose/utils/compose_utils_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/mauricioklein/docker-compose-api
@@ -129,7 +130,8 @@ summary: A simple ruby client for docker-compose api
 test_files:
 - spec/docker-compose/docker_compose_spec.rb
 - spec/docker-compose/fixtures/Dockerfile
-- spec/docker-compose/fixtures/sample1.yaml
+- spec/docker-compose/fixtures/compose_1.yaml
 - spec/docker-compose/models/compose_container_spec.rb
+- spec/docker-compose/models/compose_spec.rb
 - spec/docker-compose/utils/compose_utils_spec.rb
 - spec/spec_helper.rb