docker-builder 0.1.5

data/lib/docker_builder/config.rb

@@ -0,0 +1,199 @@
+# encoding: utf-8
+require 'docker_builder/config/dsl'
+require 'docker_builder/config/helpers'
+
+
+
+module DockerBuilder
+  module Config
+    #class Error < DockerBuilder::Error; end
+
+    DEFAULTS = {
+        :config_file  => 'config.rb',
+        :tmp_path     => 'temp'
+    }
+
+    class << self
+      #include Utilities::Helpers
+
+      attr_reader :server, :root_path, :config_file, :tmp_path, :options
+
+
+      # Define on self, since it's  a class method
+      def method_missing(method_sym, *arguments, &block)
+        # the first argument is a Symbol, so you need to_s it if you want to pattern match
+        if options.has_key?(method_sym)
+          return options[method_sym]
+        else
+          super
+        end
+        #if method_sym.to_s =~ /^find_by_(.*)$/
+        #  find($1.to_sym => arguments.first)
+
+      end
+
+
+
+      # Loads the user's +config.rb+ and all model files.
+      def load(opts = {})
+        update(opts)  # from the command line
+
+        unless File.exist?(config_file)
+          #raise Error, "Could not find configuration file: '#{config_file}'."
+          raise "Could not find configuration file: '#{config_file}'."
+        end
+
+        config = File.read(config_file)
+
+        #version = DockerBuilder::VERSION.split('.').first
+        #unless config =~ /^# Backup v#{ version }\.x Configuration$/
+        #  raise Error, <<-EOS
+        #    Invalid Configuration File
+        #  EOS
+        #end
+
+        dsl = DSL.new
+        dsl.instance_eval(config, config_file)
+
+        update(dsl._config_options)  # from config.rb
+        update(opts)              # command line takes precedence
+
+        #Dir[File.join(File.dirname(config_file), 'models', '*.rb')].each do |model|
+        #  dsl.instance_eval(File.read(model), model)
+        #end
+
+        # servers
+        load_servers(opts)
+
+      end
+
+
+      def dir_gem_root
+        return @dir_gem_root unless @dir_gem_root.nil?
+
+        #
+        spec = Gem::Specification.find_by_name("docker-builder")
+        @dir_gem_root = spec.gem_dir
+
+        @dir_gem_root
+      end
+
+      def options
+        return @options unless @options.nil?
+
+        @options = {}
+        @options
+      end
+
+      def servers
+        options[:servers]
+      end
+
+      def load_servers(opts)
+        # Identify all servers
+        if opts[:server]
+          options[:servers] = {opts[:server]=>{}}
+        else
+          # get from config
+          #options[:servers] = options[:servers]
+        end
+
+
+      end
+
+
+      private
+
+      # If :root_path is set in the options, all paths will be updated.
+      # Otherwise, only the paths given will be updated.
+      def update(opts = {})
+        #puts "update. opts=#{opts}"
+
+        # root_path
+        root_path = opts[:root_path].to_s.strip
+
+        #puts "root from opts = #{root_path}"
+
+        if root_path.empty?
+          #puts " set default"
+          root_path = File.path(Dir.getwd)
+          #puts "default root = #{root_path}"
+        end
+
+        new_root = root_path.empty? ? false : set_root_path(root_path)
+
+        puts "FINAL root= #{@root_path}"
+        #exit
+
+        DEFAULTS.each do |name, ending|
+          set_path_variable(name, options[name], ending, new_root)
+        end
+
+        # options
+        opts.each do |name, v|
+          set_variable(name, v)
+        end
+      end
+
+      # Sets the @root_path to the given +path+ and returns it.
+      # Raises an error if the given +path+ does not exist.
+      def set_root_path(path)
+        #puts "set path = #{path}"
+
+        # allows #reset! to set the default @root_path,
+        # then use #update to set all other paths,
+        # without requiring that @root_path exist.
+        return @root_path if path == @root_path
+
+        path = File.expand_path(path)
+
+        #puts " res root path=#{path}"
+
+        unless File.directory?(path)
+          raise Error, <<-EOS
+            Root Path Not Found
+            When specifying a --root-path, the path must exist.
+            Path was: #{ path }
+          EOS
+        end
+        @root_path = path
+      end
+
+
+
+      def set_variable(name, v)
+        #instance_variable_set(:"@#{name}", v) if v
+        options[name] = v
+      end
+
+      def set_path_variable(name, path, ending, root_path)
+        # strip any trailing '/' in case the user supplied this as part of
+        # an absolute path, so we can match it against File.expand_path()
+        path = path.to_s.sub(/\/\s*$/, '').lstrip
+        new_path = false
+        # If no path is given, the variable will not be set/updated
+        # unless a root_path was given. In which case the value will
+        # be updated with our default ending.
+        if path.empty?
+          new_path = File.join(root_path, ending) if root_path
+        else
+          # When a path is given, the variable will be set/updated.
+          # If the path is relative, it will be joined with root_path (if given),
+          # or expanded relative to PWD.
+          new_path = File.expand_path(path)
+          unless path == new_path
+            new_path = File.join(root_path, path) if root_path
+          end
+        end
+        instance_variable_set(:"@#{name}", new_path) if new_path
+      end
+
+      #def reset!
+      #  @root_path = File.join(File.expand_path(ENV['HOME'] || ''), 'DockerBuilder')
+      #  update(:root_path => @root_path)
+      #end
+    end
+
+    #reset!  # set defaults on load
+  end
+end

data/lib/docker_builder/config/dsl.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+module DockerBuilder
+  module Config
+    # Context for loading user config.rb and model files.
+    class DSL
+      #class Error < Backup::Error; end
+      #Server = DockerBuilder::Server
+
+      attr_reader :_config_options
+
+      def initialize
+        @_config_options = {}
+      end
+
+      # Allow users to set command line path options in config.rb
+      [:root_path, :tmp_path].each do |name|
+        define_method name, lambda {|path| _config_options[name] = path }
+      end
+
+      # allowed options
+      [:servers, :common, :base].each do |name|
+        define_method name, lambda {|v| _config_options[name] = v }
+      end
+
+
+
+      # Allows users to create preconfigured models.
+=begin
+        def preconfigure(name, &block)
+          unless name.is_a?(String) && name =~ /^[A-Z]/
+            raise Error, "Preconfigured model names must be given as a string " +
+                "and start with a capital letter."
+          end
+
+          if DSL.const_defined?(name)
+            raise Error, "'#{ name }' is already in use " +
+                "and can not be used for a preconfigured model."
+          end
+
+          DSL.const_set(name, Class.new(Model))
+          DSL.const_get(name).preconfigure(&block)
+        end
+=end
+
+    end
+  end
+end

data/lib/docker_builder/config/helpers.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+require 'ostruct'
+
+module DockerBuilder
+  module Config
+    module Helpers
+
+      def self.included(klass)
+        klass.extend ClassMethods
+      end
+
+      module ClassMethods
+
+        def defaults
+          @defaults ||= Config::Defaults.new
+
+          if block_given?
+            yield @defaults
+          else
+            @defaults
+          end
+        end
+
+        # Used only within the specs
+        def clear_defaults!
+          defaults.reset!
+        end
+
+        def deprecations
+          @deprecations ||= {}
+        end
+
+        protected
+
+
+
+      end # ClassMethods
+
+      private
+
+      ##
+      # Sets any pre-configured default values.
+      # If a default value was set for an invalid accessor,
+      # this will raise a NameError.
+      def load_defaults!
+        self.class.defaults._attributes.each do |name|
+          val = self.class.defaults.send(name)
+          val = val.dup rescue val
+          send(:"#{ name }=", val)
+        end
+      end
+
+      ##
+      # Check missing methods for deprecated attribute accessors.
+      #
+      # If a value is set on an accessor that has been deprecated
+      # using #attr_deprecate, a warning will be issued and any
+      # :action (Proc) specified will be called with a reference to
+      # the class instance and the value set on the deprecated accessor.
+      # See #attr_deprecate and #log_deprecation_warning
+      #
+      # Note that OpenStruct (used for setting defaults) does not allow
+      # multiple arguments when assigning values for members.
+      # So, we won't allow it here either, even though an attr_accessor
+      # will accept and convert them into an Array. Therefore, setting
+      # an option value using multiple values, whether as a default or
+      # directly on the class' accessor, should not be supported.
+      # i.e. if an option will accept being set as an Array, then it
+      # should be explicitly set as such. e.g. option = [val1, val2]
+      #
+      def method_missing(name, *args)
+        if method = name.to_s.chomp!('=')
+          if (len = args.count) != 1
+            raise ArgumentError,
+                  "wrong number of arguments (#{ len } for 1)", caller(1)
+          end
+        end
+
+        super
+      end
+
+    end # Helpers
+
+    # Store for pre-configured defaults.
+    class Defaults < OpenStruct
+      # Returns an Array of all attribute method names
+      # that default values were set for.
+      def _attributes
+        @table.keys
+      end
+
+      # Used only within the specs
+      def reset!
+        @table.clear
+      end
+    end
+
+  end
+end

data/lib/docker_builder/manager.rb

@@ -0,0 +1,364 @@
+module DockerBuilder
+class Manager
+
+
+  def self.load_settings(server_name, opts={})
+    settings = Settings.load_settings_for_server(server_name, opts)
+
+    settings.set 'name', server_name
+
+    settings
+  end
+
+  def self.save_chef_config(settings)
+    require 'json'
+    filename = settings.filename_chef_config
+    FileUtils.mkdir_p(File.dirname(filename))
+    File.open(filename,"w+") do |f|
+      f.write(settings.all_attributes.to_json)
+    end
+
+    true
+  end
+
+
+  ###
+  def self.build_image(server_name, settings=nil)
+    puts "building image for #{server_name}..."
+    #puts "settings: #{settings}"
+    #puts "debug: #{settings['attributes']}"
+
+    #settings = load_settings(server_name)
+
+    if settings['build']['build_type']=='dockerfile'
+      return build_image_with_dockerfile(settings)
+    elsif settings['build']['build_type']=='chef'
+      return build_image_with_chef(settings)
+    end
+  end
+
+  def self.build_image_with_dockerfile(settings)
+    puts "build image with Dockerfile. Image: #{settings.image_name}"
+
+    name = settings['name']
+
+    cmd %Q(cd #{name} && docker build -t #{settings.image_name} . )
+
+  end
+
+  def self.build_image_with_chef(settings)
+    puts "build image with chef"
+
+    # config json
+    save_chef_config(settings)
+
+    # check node
+    cmd %Q(cd #{Config.root_path} && chef exec knife node show #{settings.chef_node_name} -c #{chef_config_knife_path})
+
+
+    #cmd %Q(SERVER_NAME=#{settings.name} SERVER_PATH=#{settings.dir_server_root} chef exec chef-client -z -N #{settings.image_name} -j #{settings.filename_config_json} -c #{chef_config_knife_path} #{chef_recipe_path('chef_build_image.rb')} )
+    res_recipe = run_chef_recipe(settings, 'chef_build_image.rb')
+  end
+
+
+
+
+  ### run
+
+  def self.run_container(server_name, settings={})
+    puts "creating and running container.."
+    #settings = load_settings(server_name)
+
+    # provision host before running container
+    res_install = _install_container_provision_host(settings)
+
+    # run container
+    res_run = _run_container(settings)
+
+
+    # TODO: systemd service
+    #res_service = _install_service_container(settings)
+
+
+  end
+
+  def self._install_container_provision_host(settings)
+    script_type = (settings['install']['host']['script_type'] rescue nil)
+    return true unless script_type
+
+    # run provision script on the host machine
+    if script_type=='chef_recipe'
+      return _install_container_provision_host_chef_recipe(settings)
+    else
+      # do nothing
+    end
+
+    true
+  end
+
+
+  #
+  def self._install_container_provision_host_chef_recipe(settings)
+    # run script on host machine
+    script_name = settings['install']['host']['script'] || 'install_host'
+
+    # check script exists
+    #script_path = "#{settings.name}/cookbooks/#{settings.name}/recipes/#{script_name}.rb"
+    #f = File.expand_path('.', script_path)
+
+    #if !File.exists?(f)
+    #  puts "script not found: #{f}. Skipping"
+    #  return false
+    #end
+
+    #puts "pwd= #{Dir.pwd}"
+    #puts "root = #{Config.root_path}"
+    #exit
+
+    #
+    res_chef = run_chef_recipe_server_recipe(settings, script_name)
+    #cmd %Q(SERVER_NAME=#{settings.name} chef-client -z -N #{settings.name} --override-runlist 'recipe[#{settings.name}::#{script_name}]' )
+
+    return true
+  end
+
+  # run
+  def self._run_container(settings)
+    puts "run container ..."
+
+    script_type = (settings['install']['node']['script_type'] rescue nil)
+
+    if script_type && script_type=='chef_recipe'
+      # run container and provision with chef
+      _run_container_chef(settings)
+
+      # ???
+      #_provision_container_chef_recipe(settings)
+    else
+      #_run_container_docker(settings)
+
+      # docker run
+      cmd %Q(docker run -d --name #{settings.container_name} #{settings.docker_ports_string} #{settings.docker_volumes_string} #{settings.docker_volumes_from_string} #{settings.docker_links_string} #{settings.run_env_variables_string} #{settings.image_name} #{settings['docker']['command']} #{settings['docker']['run_options']})
+
+    end
+
+
+    # fix hosts
+    #puts "adding hosts..."
+    #puts "a= #{settings.attributes}"
+
+    container_hosts = settings.node['hosts'] || []
+    container_hosts.each do |r|
+      cmd %Q(docker exec #{settings.container_name} bash -c 'echo "#{r[0]} #{r[1]}" >>  /etc/hosts')
+    end
+
+
+    true
+  end
+
+
+  ### systemd service
+
+  def self._install_service_container(settings)
+    # not work
+    #cmd %Q(SERVER_NAME=#{settings.name} chef-client -z -N #{settings.name} install_container_service.rb )
+
+    # work
+    #cmd %Q(SERVER_NAME=#{settings.name} chef-client -z -N #{settings.name} -j config_run_install_container_service.json )
+
+    # work
+    #cmd %Q(SERVER_NAME=#{settings.name} chef-client -z -N #{settings.name} --override-runlist 'recipe[server-api::install_container_service]' )
+
+    #
+    cmd %Q(SERVER_NAME=#{settings.name} chef-client -z -N #{settings.name} -j config/config-#{settings.name}.json --override-runlist 'recipe[server-api::install_container_service]' )
+  end
+
+
+  def self._remove_service_container(settings)
+    cmd %Q(SERVER_NAME=#{settings.name} chef-client -z -N #{settings.name} -j config/config-#{settings.name}.json --override-runlist 'recipe[server-api::remove_container_service]' )
+  end
+
+
+  ### provision
+
+  def self._provision_container_chef_recipe(settings)
+    puts "provisioning container #{settings.container_name}"
+
+    #cmd %Q(SERVER_NAME=#{settings.name} chef-client -z -N #{settings.name} #{settings.name}/cookbooks/#{settings.name}/ )
+  end
+
+=begin
+
+  def self._run_container_docker(settings)
+
+  end
+=end
+
+  def self._run_container_chef(settings)
+    # generate json config for chef
+    save_chef_config(settings)
+
+    # run chef
+    #s_run = %Q(cd #{settings.name} && chef-client -z -j config.json -c ../.chef/knife.rb -N #{settings.name} ../lib/chef_container_run.rb)
+    #s_run = %Q(cd #{settings.name} && SERVER_NAME=#{settings.name} chef-client -z -j  config.common.json -N #{settings.name} ../container.rb)
+    #s_run = %Q(cd #{settings.name} && SERVER_NAME=#{settings.name} chef-client -z -N #{settings.name} ../container.rb)
+
+    # good - 2016-nov-19
+    #cmd %Q(SERVER_NAME=#{settings.name} chef-client -z -N #{settings.name} chef_run_container.rb)
+
+    #
+    res_chef = run_chef_recipe(settings, 'chef_run_container.rb')
+
+    res_chef
+  end
+
+
+  def self.destroy_image(server_name, settings={})
+    cmd %Q(docker rmi #{settings.image_name} )
+    cmd %Q(docker rm -f chef.converge.#{settings.image_name} )
+
+    # delete chef data
+    if settings['build']['build_type']=='chef'
+      return destroy_image_chef(settings)
+    end
+  end
+
+
+  def self.destroy_image_chef(settings)
+    puts "destroying image with chef..."
+
+    # config json
+    save_chef_config(settings)
+
+    # destroy temp container
+    cmd %Q(docker rm -f chef-converge.#{settings.image_name} )
+
+    #
+    cmd %Q(cd #{Config.root_path} && chef exec knife node delete #{settings.chef_node_name}  -y -c #{chef_config_knife_path})
+
+    #cmd %Q(SERVER_NAME=#{settings.name} chef-client -z -N #{settings.name} chef_destroy_image.rb)
+    #cmd %Q(SERVER_NAME=#{settings.name} SERVER_PATH=#{settings.dir_server_root} chef exec chef-client -z -N #{settings.image_name} -j #{settings.filename_config_json} -c #{chef_config_knife_path} #{chef_recipe_path('chef_destroy_image.rb')} )
+
+    res_recipe = run_chef_recipe(settings, 'chef_destroy_image.rb')
+
+    chef_remove_data(settings)
+
+    # work - before 2016-nov-19
+    #cmd %Q(cd #{Config.root_path} && chef exec knife node delete #{settings.chef_node_name}  -y -c #{chef_config_knife_path})
+
+    # clean chef client, node
+    #cmd %Q(cd #{Config.root_path} && rm -f #{settings.filename_chef_node_json} )
+    #cmd %Q(cd #{Config.root_path} && rm -f #{settings.filename_chef_client_json} )
+  end
+
+  ###
+
+
+  def self.destroy_container(server_name, settings)
+   puts "destroying container #{server_name}..."
+
+   # TODO: stop, remove systemd service
+   #res_service = _remove_service_container(settings)
+
+   #
+   cmd %Q(docker rm -f #{settings.container_name} )
+
+
+
+   # if chef
+   if settings['build']['build_type']=='chef'
+     return destroy_container_chef(settings)
+   end
+
+   #
+   return true
+ end
+
+
+  def self.destroy_container_chef(settings)
+    #
+    res_chef = run_chef_recipe(settings, 'chef_destroy_container.rb')
+    #cmd %Q(SERVER_NAME=#{settings.name} chef-client -z -N #{settings.name} chef_destroy_container.rb)
+
+    #
+    chef_remove_data(settings)
+
+  end
+
+
+  def self.start_container(server_name)
+    settings = load_settings(server_name)
+
+    #
+    cmd %Q(docker start #{settings.container_name} )
+
+    return true
+  end
+
+  ### run task on running container
+  def self.exec_task(server_name, recipe_name)
+    #raise 'not implemented'
+
+    settings = load_settings(server_name)
+
+    # check script exists
+    script_path = "#{settings.name}/cookbooks/#{settings.name}/recipes/#{recipe_name}.rb"
+    f = File.expand_path('.', script_path)
+
+    if !File.exists?(f)
+      puts "script not found: #{f}. Skipping"
+      return false
+    end
+
+    #
+    cmd %Q(SERVER_NAME=#{settings.name} chef-client -z --override-runlist 'recipe[server-api::exec_container]' )
+    #cmd %Q(SERVER_NAME=#{settings.name} chef-client -z -N #{settings.name} --override-runlist 'recipe[#{settings.name}::#{recipe_name}]' )
+    #cmd %Q(SERVER_NAME=#{settings.name} chef-client -z -N #{settings.name} chef_exec_container.rb )
+
+    return true
+  end
+
+  ###
+
+  def self.cmd(s)
+    puts "running: #{s}"
+
+    res = nil
+    Bundler.with_clean_env do
+      res = `#{s}`
+    end
+
+    puts "#{res}"
+  end
+
+
+  ### helpers - chef
+
+  def self.run_chef_recipe(settings, recipe_rb)
+    cmd %Q(cd #{Config.root_path} && SERVER_NAME=#{settings.name} SERVER_PATH=#{settings.dir_server_root} chef exec chef-client -z -N #{settings.image_name} -j #{settings.filename_config_json} -c #{chef_config_knife_path} #{chef_recipe_path(recipe_rb)} )
+  end
+
+  def self.run_chef_recipe_server_recipe(settings, server_recipe)
+    cmd %Q(cd #{Config.root_path} && SERVER_NAME=#{settings.name} SERVER_PATH=#{settings.dir_server_root} chef exec chef-client -z -N #{settings.image_name} -c #{chef_config_knife_path} --override-runlist 'recipe[#{settings.name}::#{server_recipe}]' )
+  end
+
+
+  def self.chef_config_knife_path
+    "#{Config.dir_gem_root}/lib/docker_builder/chef/.chef/knife.rb"
+  end
+
+  def self.chef_recipe_path(p)
+    "#{Config.dir_gem_root}/lib/docker_builder/chef/#{p}"
+  end
+
+
+  def self.chef_remove_data(settings)
+    #
+    cmd %Q(cd #{Config.root_path} && chef exec knife node delete #{settings.chef_node_name}  -y -c #{chef_config_knife_path})
+
+    # clean chef client, node
+    cmd %Q(cd #{Config.root_path} && rm -f #{settings.filename_chef_node_json} )
+    cmd %Q(cd #{Config.root_path} && rm -f #{settings.filename_chef_client_json} )
+  end
+end
+end