fidoci 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3c0a4c8ac5bb0ee9815e811ee7ac2008b5151522
-  data.tar.gz: 3e5346e307739072c6d5033637486a36e30bc035
+  metadata.gz: 50e39b8284a7f267079d82b4386bb5a7d0ba8727
+  data.tar.gz: 244499f405776ab68b08560320d94a004047f0fd
 SHA512:
-  metadata.gz: 049af0b54f5a8103fd900643ad3a2a0e34be8ea587ac6bc464dc1370b18e04939acb77deef10e515a46323ce9d41e562921d92157c9ad8a46fa38224bacd0199
-  data.tar.gz: 1d26968117084c495dc55b1c2613a5397812c9ec4100e4f5b3a5e1f66f6949a8555eff0bebc59226cbf30d846c13d1a79272e38f607e0332d0d6b90a6c522892
+  metadata.gz: 93563c1ab7a9f6e6e725aa1c3c9a4220a0fce1c5f7fc26a649667771bef1f1b09dbdaeb19d36c11db8c1ecdf88dcc0d4be0502817e38e8d21f5276fca7cade9b
+  data.tar.gz: 3674e2bf7980ad3cf17a362e505323fd2bd53ef51b0db85d9fd2aea65bb4555bc6a8de2c753fbe0b61bf275f82bd1062c818de9bebbe460a3f69f9f1ccf61f62

data/bin/d

@@ -10,8 +10,8 @@ if ARGV.size == 0
     puts
     puts "Options:"
     puts
-    puts "  --build [--clean] tag      Builds 'test' image, run tests inside and if successful, tag image by given 'tag'"
-    puts "  --clean                    Removes all containers and images from docker related to this repo"
+    puts "  --build success-tag [build-id]   Builds 'build_id' image, run tests inside and if successful, tag image by given 'tag'"
+    puts "  --clean                          Removes all containers and images from docker related to this repo"
     puts
     puts "Command:"
     puts "  Running with command will build 'exec' image, start docker-compose with that image and run given command in container"
@@ -31,10 +31,10 @@ when '--clean'
     # clean service and intermediate docker images
     environment.clean
 when '--build'
-    # d --build [--clean] latest-staging
+    # d --build success-tag build-id
     # build image, test it and if successful, tag as latest-staging
     # if --clean is present, will clean all intermediate docker images after
-    if environment.build(ARGV.last, ARGV.size > 1 && ARGV[1] == '--clean')
+    if environment.build(ARGV.drop(1)[0], ARGV.drop(1)[1])
         exit 0
     else
         exit 1
@@ -43,5 +43,5 @@ else
     # d cmd args args
     # run cmd in exec environment
     # build container image and run all services if not yet
-    environment.cmd(*ARGV)
+    exit environment.cmd(*ARGV)
 end

data/lib/fidoci/env.rb

@@ -10,60 +10,293 @@ module Fidoci
             @env_config = env_config
         end
 
-        def build_image()
-            if image_exists?
-                puts "Using exisitng image #{image_name}..."
-                return true
+        def debug(msg)
+            puts msg if ENV['DEBUG']
+        end
+
+        def info(msg)
+            puts msg
+        end
+
+        def build_image
+            image = Docker::Image.get(image_name) rescue nil
+            unless image
+                image = do_build_image
             end
 
-            puts "Building image #{image_name}..."
-            params = []
+            image
+        end
+
+        def do_build_image
+            info "Building image #{image_name}..."
+            params = {}
 
-            params << '--force-rm=true'
-            params << "-t #{image_name}"
+            params['forcerm'] = true
+            params['t'] = image_name
             if env_config['dockerfile']
-                params << "-f #{env_config['dockerfile']}"
+                params['dockerfile'] = env_config['dockerfile']
+            end
+
+            last_intermediate_image = nil
+            image = Docker::Image.build_from_dir('.', params) do |chunk|
+                json = JSON.parse(chunk)
+                if (json['stream'] =~ /\ --->\ ([a-f0-9]{12})/) == 0
+                    last_intermediate_image = $1
+                end
+                $stdout << json['stream']
             end
+            last_intermediate_image = nil
 
-            system "docker build #{params.join(' ')} ."
+            image
+        ensure
+            begin
+                if last_intermediate_image
+                    img = Docker::Image.get(last_intermediate_image)
+                    img.json
+                    puts "Removing intermediate image #{last_intermediate_image}"
+                    img.remove('force' => true)
+                end
+            rescue
+                nil
+            end
         end
 
         def image_name
             "%s:%s" % [@image, @name]
         end
 
+        def tag_image(tag)
+            image = Docker::Image.get(image_name)
+            image.tag(@image => tag)
+        end
+
+        def container_name
+            @image.gsub(/[^a-zA-Z0-9_]/, '_') + "_" + @name.gsub(/[^a-zA-Z0-9_]/, '_')
+        end
+
         def clean_image!
-            system "docker rmi -f #{image_name}"
+            begin
+                debug "Cleaning image #{image_name}"
+                image = Docker::Image.get(image_name)
+                image.remove(force: true)
+            rescue
+                true
+            end
+        end
+
+        def clean_container(cname)
+            begin
+                debug "Cleaning container #{cname}..."
+                container = Docker::Container.get(cname)
+                container.remove(force: true)
+            rescue
+                debug "Cleaning failed"
+                nil
+            end
+        end
+
+        def links
+            env_config['links'] || []
         end
 
-        def image_exists?
-            images = `docker images`
-            images_names  = images.split("\n").drop(1).map{|line|
-                parts = line.split(/\s+/)
-                parts[0..1].join(':')
+        def clean_containers!
+            containers = [container_name]
+            containers += links.map{|key, config| link_container_name(key) }
+
+            containers.each{|cname|
+                clean_container(cname)
             }
+            true
+        end
 
-            images_names.any?{|i| i == image_name}
+        # clean images and containers associated with this Env
+        def clean!
+            clean_containers! rescue nil
+            clean_image! rescue nil
+        end
+
+        # stop services and clean main container
+        def stop!
+            links.map{|key, config|
+                cname = link_container_name(key)
+                begin
+                    debug "Stopping container #{cname}..."
+                    container = Docker::Container.get(cname)
+                    container.stop!
+                rescue
+                    nil
+                end
+            }
         end
 
+        # run command in docker, building the image and starting services first
+        # if needed
         def cmd(*args)
-            if build_image
-                puts "Running `#{args.join(' ')}`..."
-                system "docker-compose run --rm #{@name} #{args.join(' ')}"
+            if build_image && link_containers
+                debug "Running `#{args.join(' ')}`..."
+                docker_run_or_exec(*args)
             else
-                puts "Build failed"
+                debug "Build failed"
                 return false
             end
         end
 
+        def link_container_name(key)
+            "#{container_name}_#{key}"
+        end
+
+        # starts link containers and return dict name:container_name
+        def link_containers
+            links = env_config['links'] || []
+
+            links.map {|key, link_config|
+                [key, start_link(link_container_name(key), link_config)]
+            }
+        end
+
+        def start_link(link_container_name, link_config)
+            container = Docker::Container.get(link_container_name) rescue nil
+
+            unless container
+                params = {}
+                params['name'] = link_container_name
+                params['Image'] = link_config['image']
+
+                config_params(params, link_config)
+
+                debug "Creating container #{link_container_name}..."
+                container = Docker::Container.create(params)
+            end
+
+            unless container.json['State']['Running']
+                debug "Starting container #{link_container_name}..."
+                container.start!
+            end
+
+            debug "Using container #{link_container_name}..."
+
+            link_container_name
+        end
+
+        def docker_run_or_exec(*args)
+            container = Docker::Container.get(container_name) rescue nil
+
+            if container
+                docker_exec(container.id, *args)
+            else
+                docker_run(*args)
+            end
+        end
+
+        def docker_exec(id, *args)
+            params = {}
+            params["Container"] = id
+            params["AttachStdin"] = true
+            params["AttachStdout"] = true
+            params["AttachStderr"] = true
+            params["Tty"] = true
+            params["Cmd"] = args
+
+            docker_exec = Docker::Exec.create(params)
+            result = docker_exec.start!(tty: true, stdin: $stdin) do |msg|
+                $stdout << msg
+            end
+
+            debug "Exited with status #{result[2]}"
+
+            result[2]
+        end
+
+        # calls docker run command with all needed parameters
+        # attaches stdin and stdout
+        def docker_run(*args)
+            params = {}
+            params['AttachStdin'] = true
+            params['OpenStdin'] = true
+            params['Tty'] = true
+            params['name'] = container_name
+
+            # links
+            link_containers.each{|name, container_name|
+                params['HostConfig'] ||= {}
+                params['HostConfig']['Links'] ||= []
+                params['HostConfig']['Links'] << "#{container_name}:#{name}"
+            }
+
+            config_params(params, env_config)
+            params['Image'] = image_name
+            params['Cmd'] = args
+
+            #puts params
+
+            container = Docker::Container.create(params)
+
+            container.start!.attach(stdin: $stdin, tty: true) do |msg|
+                $stdout << msg
+            end
+
+            status = container.json['State']['ExitCode']
+            debug "Exited with status #{status}"
+
+            status
+        ensure
+            clean_container(container_name)
+        end
+
+        def config_params(params, config)
+            params['HostConfig'] ||= {}
+
+            # env
+            if config['environment']
+                config['environment'].each {|key,val|
+                    params['Env'] ||= []
+                    params['Env'] << "#{key}=#{val}"
+                }
+            end
+
+            # volumes
+            if config['volumes']
+                config['volumes'].each {|v|
+                    params['HostConfig']['Binds'] ||= []
+
+                    host_path, container_path = v.split(':')
+                    host_path = File.expand_path(host_path)
+
+                    params['HostConfig']['Binds'] << "#{host_path}:#{container_path}"
+                }
+            end
+
+            # ports
+            if config['ports']
+                config['ports'].each {|p|
+                    parts = p.split(':')
+                    container_port = parts.last
+                    host_port = parts[-2]
+                    host_ip = parts[-3] || ""
+
+                    params['HostConfig']['PortBindings'] ||= {}
+                    params['HostConfig']['PortBindings']["#{container_port}/tcp"] = [
+                        {
+                            "HostIp" => host_ip,
+                            "HostPort" => host_port
+                        }
+                    ]
+                }
+            end
+
+            params
+        end
+
         def commands
             return false unless env_config['commands']
 
             success = env_config['commands'].all? { |command|
-                cmd command.split(/\s+/)
+                state = cmd(*command.split(/\s+/))
+                info "Exited with state #{state}"
+
+                state == 0
             }
 
-            puts "Test failed" unless success
             success
         end
     end

data/lib/fidoci/main.rb

@@ -1,4 +1,6 @@
 require 'yaml'
+require 'securerandom'
+require 'docker'
 
 module Fidoci
     # Main entry point for D command
@@ -11,14 +13,20 @@ module Fidoci
         # config_file - yml file path with configuration
         def initialize(config_file = 'd.yml')
             @config = YAML.load_file(config_file)
-            puts @config['image']
+
+            Docker.options = {
+                read_timeout: 3600
+            }
         end
 
         # Run command in default "exec" environment
         # ie in container build and started with exec configuration
         # args - command and arguments to pass to docker run command
         def cmd(*args)
-            env(:exec).cmd(*args)
+            exec_env = env(:dev, 'dev')
+            exec_env.cmd(*args)
+        ensure
+            exec_env.stop!
         end
 
         # Configured docker repository name
@@ -29,38 +37,39 @@ module Fidoci
 
         # Create environment instance with given name
         # name - key that will be used to configure this env
-        def env(name)
-            Env.new(repository_name, name.to_s, config[name.to_s])
+        # id - unique identifier of env that will be used to tag containers and images
+        def env(name, id)
+            Env.new(repository_name, id.to_s, config[name.to_s])
         end
 
         # Clean system
         # removes all service and running containers and their images
         # and removes all images build by d
         def clean
-            system 'docker-compose kill'
-            system 'docker-compose rm -f'
-
             (config.keys - ['image']).each { |name|
-                env = env(name)
-                env.clean_image!
+                env = env(name, name)
+                env.clean!
             }
         end
 
         # Build image and run test in it
         # tag - tag name to tag image after successful build and test
-        # do_clean - if true, will do clean after build (whether successful or not)
-        def build(tag, do_clean = false)
-            test_env = env(:test)
-            test_env.clean_image!
+        # build_id - unique build_id to be used to identify docker images and containers
+        def build(tag, build_id)
+            build_id = SecureRandom.hex(10) unless build_id
+
+            test_env = env(:build, build_id)
+            test_env.clean!
+
             success = test_env.commands
 
             if success
-                system "docker tag #{test_env.image_name} #{repository_name}:#{tag}"
+                test_env.tag_image(tag)
             end
 
             success
         ensure
-            clean if do_clean
+            test_env.clean! if test_env
         end
     end
 end

data/lib/fidoci.rb

@@ -1,5 +1,7 @@
+require 'docker'
 require 'fidoci/env'
 require 'fidoci/main'
 
 module Fidoci
+
 end

metadata

@@ -1,15 +1,29 @@
 --- !ruby/object:Gem::Specification
 name: fidoci
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Lukas Dolezal
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-07-10 00:00:00.000000000 Z
-dependencies: []
+date: 2015-07-11 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: docker-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Simple tool around docker-compose to enable dockerized dev-2-test-2-production
   workflow
 email: lukas@dolezalu.cz