docker_brick 0.0.1

data/lib/brick/mixin/docker_support.rb

@@ -0,0 +1,253 @@
+require 'shellwords'
+require 'pathname'
+
+module Brick::Mixin
+  module DockerSupport
+    
+    #from yml file to the configuration for creating container
+    def create_config hash
+      hash=transform_docker_hash hash
+      
+      create_config_for_port hash
+      
+      create_config_for_volumes hash
+      
+      hash
+    end
+    
+    def start_config hash
+      hash=transform_docker_hash hash
+      
+      start_config_for_port hash
+      
+      start_config_for_volumes hash
+      
+      hash 
+    end
+    
+    #the format is captalized
+    private
+    def transform_docker_hash hash
+      hash= Hash[hash.map do |k,v| 
+        keys=k.split('_')
+        
+        keys.map!{|key|key.capitalize}
+        
+        [keys.join(''), v]
+      end
+      ]
+      
+      common_config_for_cmd hash
+      
+      common_config_for_env hash
+      
+      common_config_for_volumes hash
+            
+      hash
+    end
+    
+    
+    
+    def common_config_for_cmd hash
+      cmd= hash.delete('Command')
+      
+      #hash['Cmd']=cmd.split(' ') unless cmd.nil? 
+      
+      unless cmd.nil?
+        if cmd.instance_of? Array
+          hash['Cmd'] = cmd
+        else
+          hash['Cmd'] = Shellwords.split(cmd)       
+        end
+      end
+      
+      hash
+    end
+    
+    #common configuration for environment variable
+    def common_config_for_env hash
+      #Support environment variables
+      env_variables = hash.delete('Environment')
+      
+      unless env_variables.nil?
+        if env_variables.instance_of? Array
+          hash['Env'] = env_variables
+        elsif env_variables.instance_of? Hash
+          var_arrays = []
+          env_variables.each {|key, value| var_arrays<<"#{key}=#{value}" }
+          hash['Env'] = var_arrays       
+        end
+      end
+      hash
+    end
+    
+    def common_config_for_volumes hash
+      #volumes 
+      unless hash["Volumes"].nil?
+        volumes = hash["Volumes"]
+        
+        if volumes.instance_of? Array
+          volumes.map!{|vo| 
+            vo_parts = vo.split(":")
+            
+            container_volume = nil
+            
+            host_volume = vo_parts[0]
+            
+            option = "rw"
+            
+            if(Pathname.new(host_volume).relative?)
+                 host_volume = File.absolute_path(File.join(::Brick::Config[:project_dir],host_volume))
+            end
+            
+            
+            if vo_parts.size==1    
+              container_volume = host_volume
+            elsif vo_parts.size>=2
+              container_volume = vo_parts[1]
+              
+              if(Pathname.new(container_volume).relative?)
+                 container_volume = File.absolute_path(File.join(::Brick::Config[:project_dir],container_volume))
+             end
+           end
+           
+           if vo_parts.size==3
+             option = vo_parts[2]
+           end
+           
+            
+            [host_volume, container_volume, option].join(':')
+          }
+        else
+          raise "the value of volumes should be an array"
+        end
+      end
+      
+      hash
+    end
+    
+    def create_config_for_volumes hash
+      #create config for volumes
+      unless hash["Volumes"].nil?
+        volumes = hash.delete('Volumes')
+        
+        volume_hash={}
+        
+        volumes.each{|vo| 
+          vo_parts = vo.split(':')
+          
+          volume_hash[vo_parts[1]] = {}
+          
+        }
+        
+        hash['Volumes'] = volume_hash
+        
+        hash
+      end
+      hash
+    end
+    
+    def start_config_for_volumes hash
+      #start config for volumes
+      #start config for volumes
+      unless hash["Volumes"].nil?
+        binds = hash.delete('Volumes')
+        
+        hash["Binds"] = binds
+      end
+      hash
+    end
+    
+    #the port configuration for creating container 
+    def create_config_for_port hash
+      exposed_ports = []
+      
+      
+      #add expose ports  
+      unless hash["Ports"].nil?
+        ports = hash.delete "Ports"
+        
+        ports.each{|port| 
+          
+          container_port = (port.split(':'))[-1]
+          
+          exposed_ports << container_port
+        }
+        
+      end
+      
+      #Add expose to exposed ports
+      unless hash["Expose"].nil?
+        exposes = hash.delete "Expose"
+        
+        exposes.each{|expose| 
+          exposed_ports << expose
+        }
+      end
+      
+      
+      
+      if exposed_ports.size > 0
+        
+        proto = 'tcp'
+        
+        exposed_port_hash = Hash.new
+        
+        exposed_ports.each {|container_port| exposed_port_hash["#{container_port}/#{proto}"]={}}
+        
+        hash["ExposedPorts"]=exposed_port_hash
+      end
+      
+      hash
+    end
+    
+    #the port configuration for starting container  
+    def start_config_for_port hash
+      #the setting for start config  
+      port_bindings = {}
+      
+      unless hash["Ports"].nil?
+        ports = hash.delete "Ports"
+        
+        ports.each{|port| 
+          
+          port_definition = port.split(':')
+          
+           proto ="tcp"
+          
+          if port_definition.size > 1
+            
+            container_port = port_definition[-1]
+            
+            host_port = port_definition[-2]
+      
+            port_bindings["#{container_port}/#{proto}"] = [{"HostPort"=>host_port}]
+            
+            # port_bindings << {"#{container_port}/#{proto}"=>[{"HostPort"=>host_port}]}
+          else
+            port_bindings["#{port}/#{proto}"] = [{"HostPort"=>port}]
+          end
+        }
+        
+        hash["PortBindings"]=port_bindings
+      end
+      hash
+    end
+    
+    def determine_dockerfile_path dockerfile_path, project_dir
+      
+      pathname= Pathname.new(dockerfile_path)
+      
+      if pathname.absolute?
+        real_dockerfile_path = dockerfile_path
+      else
+        unless project_dir.nil?
+          real_dockerfile_path = File.absolute_path(File.join(project_dir, dockerfile_path))
+        end
+      end
+      
+      real_dockerfile_path
+    end
+    
+  end
+end

data/lib/brick/mixin/yaml_helper.rb

@@ -0,0 +1,18 @@
+require 'yaml'
+
+module Brick::Mixin
+  module YamlHelper
+    def load_yaml_file(path, expected_type = Hash)
+      raise("Cannot find file `#{path}'") unless File.exists?(path)
+      yaml = YAML::load_file(path)
+      
+      if expected_type && !yaml.is_a?(expected_type)
+        raise "Incorrect file format in `#{path}', #{expected_type} expected"
+      end
+      
+      yaml
+    rescue SystemCallError => e
+      raise  "Cannot load YAML file at `#{path}': #{e}"
+    end
+  end 
+end

data/lib/brick/mixin.rb

@@ -0,0 +1,8 @@
+
+require "brick/mixin/convert_to_class_name"
+
+require "brick/mixin/aliasing"
+
+require 'brick/mixin/docker_support'
+
+require 'brick/mixin/colors'

data/lib/brick/models/project.rb

@@ -0,0 +1,139 @@
+require 'brick/mixin/yaml_helper'
+require 'brick/docker/docker_client'
+#require 'deepstruct'
+
+module Brick
+  module Models
+    class Project
+      
+      include Brick::Mixin::YamlHelper
+      
+      attr_accessor :services, :docker_client, :name, :recreate, :insecure_registry
+      
+      def initialize(project_name ,options={},client=nil)
+        
+         @name = project_name
+        
+         unless options[:config_file].nil?
+           @config_file = options[:config_file]
+         end
+         
+         @docker_client = client ? client : Brick::Docker::DockerClient::default
+        
+         init_services_from_config(@config_file)
+                 
+      end
+      
+      
+      def get_services(service_name, inlcude_links=false) 
+        
+      end
+      
+      def get_service(name)
+        
+        service = nil
+        
+        unless @services.nil?
+        
+          service = @services[name]
+           
+       end
+       
+       service
+      end
+      
+      #initialize the configuration of each service, and put it into services
+      def init_services_from_config(config_file=nil)
+        config_hash = load_yaml_file config_file
+        
+       # config = config_hash.to_ostruct
+        
+        @services = {}
+        
+        config_hash.each_key{|key|  
+        #  @services << Service.new(key,eval("config.#{key}"))  
+           @services[key] =Service.new("#{@name}_#{key}_1",config_hash[key],@docker_client)        
+        }
+        
+        @services.each_key{|key|  
+            service = @services[key]
+            service.update_links @services
+            service.update_volumes_from @services
+            service.update_image_for_building_tag("#{self.name}_#{key}")
+        }
+        
+      end
+      
+      
+      def up(detach_mode = true, enable_link=true, recreate=false)
+          
+          self.services.each_key{|key| service= services[key]
+          
+              if service.container_exist?
+                puts "Recreating #{service.name} ..."
+              else
+                puts "Creating #{service.name} ..."
+              end
+          
+              if service.can_be_built?
+                unless service.image_exist?
+                  # by default, not set cache
+                  service.build nil, true, ::Brick::Config[:project_dir]
+                end
+              end
+             
+              service.run enable_link, recreate, detach_mode
+              
+              
+          }
+          
+          Service.wait_for_deamon
+      end
+      
+      
+      #create the service according to the service name
+      def run_services(service_name, enable_link=true)
+        
+        service = @services[service_name]  
+        
+        to_build = false
+        
+         if service.can_be_built?
+           
+           if service.image_exist? 
+             if ::Brick::Config[:rebuild]
+                to_build=true
+              else
+                puts "The image #{service.image_name} already exists!"
+             end
+           else
+             to_build = true
+           end
+           
+         end
+         
+         if to_build
+           service.build nil, true, ::Brick::Config[:project_dir]
+         end
+        
+        raise ServicesNotFoundException.new("service #{service_name} is not found in #{@config_file}") if service.nil?
+        service.run enable_link
+        
+      end
+      
+      def build_services no_cache=false, project_dir=nil
+        self.services.each_key{|key| service= services[key]
+          
+          
+          if service.can_be_built?
+            service.build("#{self.name}_#{key}",no_cache,project_dir)
+          else
+            ::Brick::CLI::logger.info("uses an image, skipping #{key}")
+          end
+          
+        }
+      end
+      
+    end
+  end  
+end

data/lib/brick/models/service.rb

@@ -0,0 +1,276 @@
+require 'brick/mixin'
+require 'colorize'
+
+
+module Brick
+  module Models
+    class Service
+      
+      include ::Brick::Mixin::Colors
+      
+      @@waiting_pool = []
+      
+      attr_accessor :client, :name, :links, :service_config_hash, :container, :volumes_from, :image, :image_name
+      
+      def self.wait_for_deamon
+        @@waiting_pool.each{|thr|
+            thr.join       
+        }
+      end
+      
+      
+      def initialize(name, config, client)
+        self.name = name
+        self.service_config_hash = config
+        self.client = client
+        #puts "client=#{client}"
+        
+        determine_color
+        
+        unless config["links"].nil?         
+          if  config["links"].instance_of?(String)
+            self.links= [config["links"]]
+          else
+            self.links= config["links"].dup
+          end
+        end
+        
+        unless config["volumes_from"].nil?
+          if  config["volumes_from"].instance_of?(String)
+            self.volumes_from= [config["volumes_from"]]
+          else
+            self.volumes_from= config["volumes_from"].dup
+          end
+        end
+        
+        begin
+          self.container = ::Docker::Container.get(name)
+        rescue 
+          self.container = nil
+        end
+        
+      end
+      
+      def update_volumes_from services
+        
+        new_volumes_from_config = []
+        
+        new_volumes_from = []
+        
+        unless volumes_from.nil?
+          
+          volumes_from.each {|vo|
+            #new_volumes_from << services[vo]
+            vo_parts = vo.split(':')
+            
+            #only one part
+            if vo_parts.size == 1
+              new_vo = "#{services[vo_parts[0]].name}:rw"
+            else
+              new_vo=  "#{services[vo_parts[0]].name}:#{vo_parts[1]}"
+            end
+            
+            new_volumes_from<< services[vo_parts[0]]
+            
+            new_volumes_from_config << new_vo
+            
+          }
+          self.volumes_from = new_volumes_from
+          
+          service_config_hash["volumes_from"] = new_volumes_from_config
+        end
+      end
+      
+      
+      def update_links services
+        
+        new_links_config = []
+        
+        new_links =[]
+        
+        unless links.nil?
+          links.each{|link|
+            
+            link_array=link.split(':')
+            
+            #It's for getting the real service name
+            service_key = link_array[0]
+            
+            alias_name = link_array[-1]
+            
+            service_container= services[service_key]
+            
+            new_links << service_container
+            
+            new_links_config << "#{service_container.name}:#{alias_name}"
+          }
+          
+          self.links=new_links
+          
+          service_config_hash["links"] = new_links_config
+        end
+        
+        
+      end
+      
+      def exec cmd_array, options ={}
+        if self.container.nil?
+          raise "no container #{name} running, so we can't execute "
+        end
+        
+        self.container.exec(cmd_array, options){|stream, chunk| puts "#{color_generator(name)} | #{chunk}".chomp }
+        
+      end
+      
+      #equals to "docker run"
+      def run enable_link=true, recreate=true, detach_mode=false
+        
+        if running? and (!recreate or can_be_skipped_this_time?)
+          Brick::CLI::logger.debug "the service #{name} is already running. exited."
+          unless detach_mode
+             attach
+          end
+          
+          return
+        end
+        
+        unless volumes_from.nil?
+          volumes_from.each{|vo| vo.run enable_link}
+        end
+        
+        config_hash = @service_config_hash.dup
+        
+        if enable_link and !links.nil?
+          links.each{|linked_service|
+            linked_service.run enable_link
+            
+            unless detach_mode
+                linked_service.attach
+            else
+                puts "Service #{linked_service.name} has been started"
+            end
+          }
+        end
+        
+        if !enable_link
+          config_hash.delete("links")
+        end
+        
+        if recreate and !container.nil?
+          #if recreate is true, it will destory the old container, and create a new one
+          if running?
+            container.stop
+          end
+          container.delete(:force => true)
+          self.container=nil
+          skip_next_time
+        end
+        
+        if container.nil?       
+          self.container = client.run config_hash, name        
+        else
+          container.start
+        end
+        
+        unless detach_mode
+             attach
+        else
+            puts "Service #{name} has been started"
+        end
+        
+      end
+      
+      #Check if the container is running
+      def running?
+        is_running = false
+        
+        if container.nil?
+          begin
+            self.container = ::Docker::Container.get(name)
+          rescue 
+            self.container = nil
+          end
+        end
+        
+        unless container.nil?
+          is_running = container.is_running?
+        end
+        
+        is_running
+      end
+      
+      def container_info
+       (client.get_container_by_id(container.id)).info rescue {}
+      end
+      
+      
+      def attach
+        
+        thr=Thread.new{
+          puts "Attaching to service #{name}"
+          container.attach(:stdin => STDIN, :tty => true){|message| 
+            
+          if message.length > 0
+            puts "#{color_generator(name)} | #{message}".chomp
+          end
+          
+          }
+        }
+        
+        #thr.join
+        @@waiting_pool << thr
+      end
+      
+      
+      def can_be_built?
+        !service_config_hash["build"].nil?
+      end
+      
+      def skip_next_time
+        @skip = true
+      end
+      
+      def can_be_skipped_this_time?
+        @skip == true
+      end
+      
+      def build name=nil, no_cache=false, project_dir=nil
+        
+        if name.nil?
+          name = self.image_name
+        end
+        
+        puts "Start building #{name}..."
+        
+        if can_be_built?
+          self.image = client.build_from_dir({:image_name => name,
+            :no_cache => no_cache,
+            :project_dir=>project_dir,
+            :build_dir=>service_config_hash["build"]})
+        else
+          Brick::CLI::logger.debug "no build defintion for #{image_build},skip it"
+        end
+        self.image
+      end
+      
+      def image_exist? 
+        ::Docker::Image.exist?(image_name)
+      end
+      
+      def container_exist?
+        ::Docker::Container.exist?(name)
+      end
+      
+      #If it's using build tag, will create an actual image name for it.
+      #For example, if project name is test, service name is web, the image name should 
+      #be test_web
+      def update_image_for_building_tag name
+        unless service_config_hash["build"].nil?
+          service_config_hash["image"]=name
+        end
+        
+        self.image_name = service_config_hash["image"]
+      end
+    end
+  end  
+end

data/lib/brick/models.rb

@@ -0,0 +1,13 @@
+module Brick
+  module Models 
+    class ServicesNotFoundException < RuntimeError
+      
+    end
+  end
+end
+
+#BKm = Brick::Models
+
+require 'brick/models/service'
+
+require 'brick/models/project'