baha 0.0.1

data/lib/baha/config.rb

@@ -0,0 +1,142 @@
+require 'yaml'
+require 'pathname'
+require 'baha/log'
+
+class Baha::Config
+  DEFAULTS = {
+    :parent => 'ubuntu:14.04.1',
+    :bind   => '/.baha',
+    :command => ['/bin/bash','./init.sh'],
+    :repository => nil,
+    :maintainer => nil,
+    :timeout => 1200
+  }
+  LOG = Baha::Log.for_name("Config")
+  class << self
+    def load(file)
+      LOG.debug { "Loading file #{file}"}
+      filepath = Pathname.new(file)
+      raise ArgumentError.new("Cannot read config file #{file}") unless filepath.readable?
+      config = YAML.load_file(filepath)
+      config['configdir'] ||= filepath.dirname
+      Baha::Config.new(config)
+    end
+  end
+
+  attr_reader :configdir, :workspace, :secure, :options
+  attr_reader :defaults
+
+  def initialize(config)
+    @config = config
+    
+    # Defaults
+    defaults = config['defaults'] || {}
+    raise ArgumentError.new("Expected Hash for defaults") unless defaults.is_a?(Hash)
+    @defaults = {}
+    DEFAULTS.keys.each do |k|
+      @defaults[k] = defaults[k] || defaults[k.to_s] || DEFAULTS[k]
+    end
+
+    @configdir = Pathname.new(config['configdir'] || Pathname.pwd)
+    @workspace = Pathname.new(config['workspace'] || @configdir + 'workspace')
+    @secure = false
+    @options = {}
+    init_security if ENV.has_key?('DOCKER_CERT_PATH') || config.has_key?('ssl')
+  end
+
+  def init_security
+    @secure = true
+    cert_path = ''
+    ssl_options = { }
+    if ENV['DOCKER_CERT_PATH']
+      cert_path = Pathname.new(ENV['DOCKER_CERT_PATH'])
+      ssl_options[:ssl_verify_peer] = (ENV['DOCKER_TLS_VERIFY'] == '1')
+      ssl_options[:client_cert] = (cert_path + 'cert.pem').expand_path.to_s
+      ssl_options[:client_key] = (cert_path + 'key.pem').expand_path.to_s
+      ssl_options[:ssl_ca_file] = (cert_path + 'ca.pem').expand_path.to_s
+    elsif @config.has_key?('ssl')
+      ssl = @config['ssl']
+      ssl_options[:ssl_verify_peer] = ssl['verify'] || false
+      if ssl.has_key?('cert_path')
+        cert_path = Pathname.new(ssl['cert_path'])
+        ssl_options[:client_cert] = (cert_path + 'cert.pem').expand_path.to_s
+        ssl_options[:client_key] = (cert_path + 'key.pem').expand_path.to_s
+        ssl_options[:ssl_ca_file] = (cert_path + 'ca.pem').expand_path.to_s
+      else
+        ssl_options[:client_cert] = ssl['cert']
+        ssl_options[:client_key] = ssl['key']
+        ssl_options[:ssl_ca_file] = ssl['ca']
+      end
+    end
+    @options.merge!(ssl_options)
+  end
+
+  def each_image
+    return unless @config.has_key?('images')
+    @config['images'].each do |image|
+      if image.has_key?('include')
+        path = Pathname.new(image['include'])
+        file = resolve_file(path)
+        if file
+          yml = YAML.load_file(file)
+          yield Baha::Image.new(self,yml)
+        else
+          LOG.error { "Unable to find image include: #{path}"}
+          next
+        end
+      else
+        yield Baha::Image.new(self,image)
+      end
+    end
+  end
+
+  def resolve_file(file)
+    filepath = Pathname.new(file)
+    LOG.debug { "resolve_file(#{file})" }
+    paths = [ 
+      filepath,            # 0. Absolute path
+      @workspace + file,   # 1. Workspace
+      @configdir + file,   # 2. Config
+      Pathname.pwd + file  # 3. Current directory
+    ]
+    paths.reduce(nil) do |result,path|
+      if result.nil?
+        if path.exist?
+          result = path
+          LOG.debug("found file at: #{path}")
+        else
+          LOG.debug("did not find file at: #{path}")
+        end
+      end  
+      result
+    end
+  end
+
+  # Initialize Docker Client
+  def init_docker!
+    Docker.options = @options
+    if @config.has_key?('docker_url')
+      url = @config['docker_url']
+      Docker.url = url
+    end
+    if @secure
+      Docker.url = Docker.url.gsub(/^tcp:/,'https:')
+    end
+    LOG.debug { "Docker URL: #{Docker.url}"}
+    LOG.debug { "Docker Options: #{Docker.options.inspect}"}
+    Docker.validate_version!
+  end
+
+  def inspect
+    <<-eos.gsub(/\n?\s{2,}/,'')
+    #{self.class.name}<
+      @config=#{@config.inspect},
+      @configdir=#{@configdir},
+      @workspace=#{@workspace},
+      @defaults=#{@defaults.inspect},
+      @secure=#{@secure},
+      @options=#{@options.inspect}
+    >
+    eos
+  end
+end

data/lib/baha/container_options/cmd.rb

@@ -0,0 +1,33 @@
+require 'baha/container_options/invalid_option_error'
+require 'baha/container_options/option'
+module Baha
+  module ContainerOptions 
+    class Cmd < Option
+
+      def self.split_command(cmd)
+        require 'csv'
+        CSV.parse_line(cmd,{:col_sep => ' ', :skip_blanks => true, :quote_char => '"'})
+      end
+
+      def initialize(*args)
+        if args.length < 2 then
+          @conf = 'Cmd'
+          super('Cmd',*args)
+        else
+          @conf = args[0]
+          super(*args)
+        end
+      end
+      def apply(config)
+        if @value.kind_of?(Array)
+          config[@conf] = @value
+        else
+          config[@conf] = Cmd::split_command(@value)
+        end
+      end
+      def validate!
+        raise ERROR("should be an array or string") unless @value.kind_of?(Array) or @value.kind_of?(String)
+      end
+    end
+  end
+end

data/lib/baha/container_options/entrypoint.rb

@@ -0,0 +1,10 @@
+require 'baha/container_options/cmd'
+module Baha
+  module ContainerOptions 
+    class Entrypoint < Cmd
+      def initialize(*args)
+        super('Entrypoint',*args)
+      end
+    end
+  end
+end

data/lib/baha/container_options/env.rb

@@ -0,0 +1,21 @@
+require 'baha/container_options/option'
+module Baha
+  module ContainerOptions
+    class Env < Option
+      def initialize(*args)
+        super(:env,*args)
+      end
+      def apply(config)
+        unless config.has_key?('Env')
+          config['Env'] = []
+        end
+        @value.each_pair do |k,v|
+          config['Env'] << "#{k}=#{v}"
+        end
+      end
+      def validate!
+        raise ERROR("should be a hash") unless @value.kind_of?(Hash)
+      end
+    end
+  end
+end

data/lib/baha/container_options/exposed_ports.rb

@@ -0,0 +1,35 @@
+require 'baha/container_options/invalid_option_error'
+require 'baha/container_options/option'
+module Baha
+  module ContainerOptions    
+    class ExposedPorts < Option
+      def initialize(*args)
+        super(:exposedports,*args)
+      end
+      def apply(config)
+        unless config.has_key?('ExposedPorts')
+          config['ExposedPorts'] = {}
+        end
+        @value.each do |port|
+          case port
+            when Fixnum
+              config['ExposedPorts']["#{port}/tcp"] = {}
+            when String
+              config['ExposedPorts'][port] = {}
+          end
+        end
+      end
+
+      def validate!
+        raise ERROR("should be an array") unless @value.kind_of?(Array)
+        @value.each_with_index do |item,index|
+          if item.kind_of?(String)
+            unless /(\d+)\/(tcp|udp)/ =~ item
+              raise ERROR("#{index}: '#{item}' should be in the form 8080/tcp")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/baha/container_options/invalid_option_error.rb

@@ -0,0 +1,15 @@
+module Baha
+  module ContainerOptions
+    class InvalidOptionError < RuntimeError
+      attr_reader :key
+      attr_reader :value
+      attr_reader :reason
+      def initialize(key,value,reason)
+        super("Unable to validate option: #{key}. '#{value}' #{reason}")
+        @key = key
+        @value = value
+        @reason = reason
+      end
+    end
+  end
+end

data/lib/baha/container_options/option.rb

@@ -0,0 +1,59 @@
+require 'baha/container_options/invalid_option_error'
+module Baha
+  module ContainerOptions
+    class Option
+      KEYS = {
+        :cmd => 'Cmd',
+        :cpushares => 'CpuShares',
+        :cpuset => 'Cpuset',
+        :domainname => 'Domainname',
+        :entrypoint => 'Entrypoint',
+        :env => 'Env',
+        :exposedports => 'ExposedPorts',
+        :hostname => 'Hostname',
+        :image => 'Image',
+        :memory => 'Memory',
+        :memoryswap => 'MemorySwap',
+        :networkdisabled => 'NetworkDisabled',
+        :user => 'User',
+        :volumes => 'Volumes',
+        :workingdir => 'WorkingDir',
+      }
+
+      attr_reader :key
+      attr_reader :config_key
+      attr_reader :value
+
+      def initialize(*args)
+        k,@value = args
+        raise ArgumentError, "Cannot understand option key '#{k}'" unless k.respond_to?(:to_sym)
+        @key = k.to_sym.downcase
+        raise ERROR("Option with key '#{@key}' is not found. Expecting #{KEYS.keys.inspect}") unless KEYS.has_key?(@key)
+        @config_key = KEYS[@key]
+      end
+      
+      def eql?(other)
+        @key == other.key and @value == other.value
+      end
+      
+      # Apply this option to the container's config hash
+      def apply(config)
+        config[@config_key] = @value
+      end
+
+      # Validate the option's value
+      def validate!
+        KEYS.has_key?(@key)
+      end
+
+      def inspect
+        "#{self.class.name}<@key=#{@key.inspect},@value=#{@value.inspect}>"
+      end
+
+      private 
+      def ERROR(reason)
+        InvalidOptionError.new(@key,@value,reason)
+      end
+    end
+  end
+end

data/lib/baha/container_options/volumes.rb

@@ -0,0 +1,24 @@
+require 'baha/container_options/option'
+module Baha
+  module ContainerOptions
+    class Volumes < Option
+      def initialize(*args)
+        super(:volumes,*args)
+      end
+      def apply(config)
+        unless config.has_key?('Volumes')
+          config['Volumes'] = {}
+        end
+        @value.each do |mount|
+          config['Volumes'][mount] = {}
+        end
+      end
+      def validate!
+        raise ERROR("should be an array") unless @value.kind_of?(Array)
+        @value.each_with_index do |item,index|
+          raise ERROR("#{index}: '#{item}' should be a string") unless item.kind_of?(String)
+        end
+      end
+    end
+  end
+end

data/lib/baha/container_options.rb

@@ -0,0 +1,38 @@
+require 'baha/container_options/cmd'
+require 'baha/container_options/entrypoint'
+require 'baha/container_options/env'
+require 'baha/container_options/exposed_ports'
+require 'baha/container_options/invalid_option_error'
+require 'baha/container_options/option'
+require 'baha/container_options/volumes'
+module Baha
+  module ContainerOptions
+    def self.parse_options(options)
+      if options
+        Hash[options.map { |k,v| opt = self.parse_option(k,v)
+          [opt.key,opt] }]
+      else
+        {}
+      end
+    end
+    def self.parse_option(key,value)
+      k = key.to_sym.downcase
+      option = case k
+      when :volumes
+        Volumes.new(value)
+      when :env
+        Env.new(value)
+      when :cmd 
+        Cmd.new(value)
+      when :entrypoint
+        Entrypoint.new(value)
+      when :exposedports
+        ExposedPorts.new(value)
+      else
+        Option.new(key,value)
+      end
+      option.validate!
+      option
+    end
+  end
+end

data/lib/baha/image.rb

@@ -0,0 +1,154 @@
+require 'docker'
+require 'baha/container_options'
+require 'baha/log'
+require 'set'
+
+module Baha
+  class ImageNotFoundError < RuntimeError
+    attr_reader :image
+    def initialize(image)
+      super("Unable to locate image : #{image[:name]}:#{image[:tag]}")
+      @image = image
+    end
+  end
+  class Image
+    LOG = Baha::Log.for_name("Image")
+    class << self
+        # Parses an image name
+        def parse_name(image)
+          m = /(?:([a-z0-9\-._\/]+))(?::([a-zA-Z0-9\-._]+))?/.match(image)
+          unless m
+            raise ArgumentError.new("Unable to parse image name #{image}")
+          end
+          tag  = m.captures[1]
+          tag  ||= 'latest'
+          imagename = m.captures[0]
+          m2 = /(?:(.+)\/)?(.+)/.match(imagename)
+          ns = m2.captures[0]
+          name = m2.captures[1]
+          {
+            :ns    => ns,
+            :name  => name,
+            :tag   => tag
+          }
+        end
+
+        def parse_with_default(image,repository)
+          i = parse_name(image)
+          unless i[:ns]
+            i[:ns] = repository
+          end
+          i
+        end
+
+        def get_image!(image)
+          LOG.debug { "get_image!(#{image.inspect})" }
+          tag = image[:tag] || 'latest'
+          repo = "#{image[:ns]}/#{image[:name]}"
+          img = [ 
+            lambda { Docker::Image.get("#{image[:name]}:#{image[:tag]}") },
+            lambda { Docker::Image.create('fromImage'=> image[:name], 'tag' => tag) },
+            lambda { Docker::Image.create('fromImage' => repo, 'tag' => tag) }
+          ].reduce(nil) do |result,block|
+            unless result
+              begin
+                result = block.call
+                result = Docker::Image.get(result.id)
+              rescue
+                result = nil
+              end
+            end
+            result
+          end
+          raise Baha::ImageNotFoundError.new(image) unless img
+          img
+        end
+
+    end
+    attr_reader :parent, :image, :maintainer, :options, :pre_build, :bind, :command, :timeout, :workspace, :name, :tags
+
+    def initialize(config,image)
+      @parent = Baha::Image.parse_with_default(image['parent'] || config.defaults[:parent], config.defaults[:repository])
+      @image  = Baha::Image.parse_with_default(image['name'], config.defaults[:repository])
+      @image[:tag] = image['tag'] if image.has_key?('tag')
+      @maintainer = image['maintainer'] || config.defaults[:maintainer]
+      @options = Baha::ContainerOptions::parse_options(image['config'])
+      @pre_build = image['pre_build']
+      @bind = image['bind'] || config.defaults[:bind]
+      @command = image['command'] || config.defaults[:command]
+      @timeout = image['timeout'] || config.defaults[:timeout]
+      @workspace = config.workspace + (image['workspace'] || @image[:name])
+      @name = @image[:name]
+      @tags = Set.new [
+        "#{@image[:name]}:#{@image[:tag]}",
+        "#{@image[:name]}:latest"
+      ]
+      if @image[:ns]
+        @tags << "#{@image[:ns]}/#{@image[:name]}:#{@image[:tag]}"
+        @tags << "#{@image[:ns]}/#{@image[:name]}:latest"
+      end
+    end
+
+    def env
+      {
+        :parent => @parent,
+        :maintainer => @maintainer,
+        :bind => @bind,
+        :name => @image[:name],
+        :tag  => @image[:tag],
+        :workspace => @workspace.expand_path.to_s
+      }
+    end
+
+    def parent_id
+      parent = Baha::Image.get_image!(@parent)
+      parent.id
+    end
+
+    def commit_config
+      @options.values.reduce({}) do |memo,option|
+        option.apply(memo)
+        memo
+      end
+    end
+
+    # Checks if the image needs updating
+    # 1. If it's parent image has changed
+    # 2. If the desired tag is not found
+    # Will raise Baha::ImageNotFoundError if the parent image can not be found
+    def needs_update?
+      LOG.debug { "needs_update?(#{@image.inspect})" }
+      parent = Baha::Image.get_image!(@parent)
+      LOG.debug { "got parent: #{parent.inspect}" }
+      begin
+        image = Baha::Image.get_image!(@image)
+        LOG.debug { "got image: #{image.inspect}" }
+        parent_id = image.info['Parent']
+        this_tags = image.history[0]["Tags"]
+        local_tag = "#{@image[:name]}:#{@image[:tag]}"
+        remote_tag = "#{@image[:ns]}/#{local_tag}"
+        LOG.debug { "current parent id = #{parent_id}" }
+        LOG.debug { "current image tags = #{parent_id}" }
+        LOG.debug { "current parent id = #{parent_id}" }
+        parent_id != parent.id or not ( this_tags.include?(local_tag) or this_tags.include?(remote_tag) )
+      rescue
+        true
+      end
+    end
+
+    def inspect
+      <<-eos.gsub(/\n?\s{2,}/,'')
+      #{self.class.name}<
+        @parent=#{@parent.inspect},
+        @image=#{@image.inspect},
+        @maintainer=#{@maintainer},
+        @options=#{@options.inspect},
+        @pre_build=#{@pre_build.inspect},
+        @bind=#{@bind},
+        @command=#{@command.inspect},
+        @timeout=#{@timeout}
+      >
+      eos
+    end
+  end
+end

data/lib/baha/log.rb

@@ -0,0 +1,80 @@
+class Baha::Log
+  require 'logger'
+  LEVELS = {
+      :debug => Logger::DEBUG,
+      :info  => Logger::INFO,
+      :warn  => Logger::WARN,
+      :error => Logger::ERROR,
+      :fatal => Logger::FATAL
+  }
+  class Formatter
+    Format = "%s [%5s] %s -- %s\n"
+
+    def call(severity, time, progname, msg)
+      Format % [time.strftime('%Y-%m-%d %H:%M:%S.%L'), severity, progname, msg2str(msg)]
+    end
+
+    private
+
+    def msg2str(msg)
+      case msg
+      when ::String
+        msg
+      when ::Exception
+        "#{ msg.message } (#{ msg.class })\n\t" <<
+          (msg.backtrace || []).join("\n\t")
+      else
+        msg.inspect
+      end
+    end
+  end
+  class << self
+    attr_reader :level, :logfile, :io
+    def logfile=(io)
+      @io = io
+      @logfile = Logger.new(io)
+      @logfile.formatter = Baha::Log::Formatter.new()
+      self.level = :error
+    end
+    def level=(level)
+      key = case level
+      when String
+        @level = level.downcase.to_sym
+      when Symbol
+        @level = level.downcase
+      else
+        raise ArgumentError.new("level must be a string or symbol")
+      end
+      raise ArgumentError.new("level must be in #{LEVELS.keys}") unless LEVELS.has_key?(key)
+      @level = key
+      self.logfile.sev_threshold = LEVELS[@level]
+    end
+    def close!
+      if @logfile
+        @logfile.close
+        @logfile = nil
+      end
+    end
+    def for_name(progname)
+      Baha::Log.new(progname)
+    end
+  end
+
+  attr_reader :progname
+
+  def initialize(progname)
+    @progname = progname
+  end
+
+  LEVELS.keys.each do |level|
+    define_method(level) do |*message, &block|
+      if Baha::Log.logfile
+        if block
+          Baha::Log.logfile.send(level, @progname, &block)
+        else
+          Baha::Log.logfile.send(level, @progname) { message[0] }
+        end
+      end
+    end
+  end
+end

data/lib/baha/pre_build/command.rb

@@ -0,0 +1,51 @@
+require 'baha/pre_build'
+require 'open3'
+
+class Baha::PreBuild::Module::Command
+  LOG = Baha::Log.for_name("Module::Command")
+
+  def self.execute(mod)
+    LOG.debug("execute(#{mod.args.inspect})")
+    command = mod.args['command']
+    creates = mod.args['creates']
+    onlyif  = mod.args['only_if']
+
+    cwd = mod.image.workspace.expand_path
+
+    if creates
+      filepath = cwd + creates
+      LOG.debug { "Checking if file exists #{filepath}"}
+      if filepath.exist?
+        LOG.info("#{creates} exists - skipping command")
+        return
+      end
+    end
+
+    if onlyif
+      exit_status = 0
+      LOG.info { "Running test [onlyif] #{onlyif.inspect}" }
+      Open3.popen2e(onlyif,:chdir=>cwd.to_s) do |stdin, oe, wait_thr|
+        oe.each do |line|
+          LOG.debug { "++ " + line }
+        end
+        exit_status = wait_thr.value # Process::Status object returned.
+      end
+      unless exit_status.success?
+        LOG.debug { "onlyif did not exist successfully - skipping command" }
+        return
+      end
+    end
+
+    LOG.info { "Running command #{command.inspect}" }
+    Open3.popen2e(command,:chdir=>cwd.to_s) do |stdin, oe, wait_thr|
+      oe.each do |line|
+        LOG.debug { "++ " + line.chomp }
+      end
+    end
+
+  end
+end
+
+Baha::PreBuild::Module.register(:command) do |mod|
+  Baha::PreBuild::Module::Command.execute(mod)
+end

data/lib/baha/pre_build/download.rb

@@ -0,0 +1,28 @@
+require 'baha/pre_build'
+require 'open-uri'
+
+class Baha::PreBuild::Module::Download
+  LOG = Baha::Log.for_name("Module::Download")
+
+  def self.execute(mod)
+    LOG.debug("execute(#{mod.args.inspect})")
+
+    filename = mod.image.workspace + mod.args['file']
+    url = mod.args['download']
+    overwrite = mod.args['overwrite'] || false
+    if Pathname.new(filename).exist? and not overwrite
+      LOG.info("#{filename} already exists")
+    else
+      LOG.info("Download #{url} -> #{filename}")
+      File.open(filename, "w") do |saved_file|
+        open(url, "rb") do |read_file|
+          saved_file.write(read_file.read)
+        end
+      end
+    end
+  end
+end
+
+Baha::PreBuild::Module.register(:download) do |mod|
+  Baha::PreBuild::Module::Download.execute(mod)
+end