docker-app 0.2.1

data/lib/docker_app/command.rb

@@ -0,0 +1,16 @@
+module DockerApp
+  class Command
+
+    def self.cmd(s)
+      puts "running: #{s}"
+
+      res = nil
+      Bundler.with_clean_env do
+        res = `#{s}`
+      end
+
+      puts "#{res}"
+    end
+
+  end
+end

data/lib/docker_app/config.rb

@@ -0,0 +1,249 @@
+# encoding: utf-8
+require 'docker_app/config/dsl'
+require 'docker_app/config/helpers'
+
+
+
+module DockerApp
+  module Config
+    #class Error < DockerApp::Error; end
+
+    DEFAULTS = {
+        :config_file  => 'config.rb',
+        :tmp_path     => 'temp'
+    }
+
+    class << self
+      #include Utilities::Helpers
+
+      attr_reader :servers, :options,
+                  :root_path, :config_file, :tmp_path
+
+
+      # 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
+
+        #config_file = 'temp_config.rb'
+
+        puts "config file: #{config_file}"
+
+        unless File.exist?(config_file)
+          #raise Error, "Could not find configuration file: '#{config_file}'."
+          raise "Could not find configuration file: '#{config_file}'."
+        end
+
+        text_config = File.read(config_file)
+
+        dsl = DSL.new
+        dsl.instance_eval(text_config, config_file)
+
+        # set options from dsl object
+        update(dsl._config_options)  # from config.rb
+        # command line takes precedence
+        update(opts)
+
+        #Dir[File.join(File.dirname(config_file), 'models', '*.rb')].each do |model|
+        #  dsl.instance_eval(File.read(model), model)
+        #end
+
+        # servers
+        # Identify all servers
+        if @options['server']
+          srv_name = @options['server'] || @options[:server]
+          # one server
+          @servers = {srv_name => dsl._config_servers[srv_name]}
+        else
+          # all servers
+          @servers = dsl._config_servers
+        end
+
+
+        @servers.each do |name, sc|
+          # from common config
+          sc.common_config = self
+          sc.properties['name'] ||= name
+          #sc.properties['common'] = Config.options[:common]
+        end
+
+
+
+      end
+
+
+      def dir_gem_root
+        return @dir_gem_root unless @dir_gem_root.nil?
+
+        #
+        spec = Gem::Specification.find_by_name("docker-app")
+        @dir_gem_root = spec.gem_dir
+
+        @dir_gem_root
+      end
+
+      def options
+        return @options unless @options.nil?
+
+        @options = {}
+        @options
+      end
+
+      #def servers
+        #options[:servers]
+        #@_servers || []
+      #end
+
+
+      ### NOT USED
+      ## TODO: refactor
+      def self.load_settings_for_server(name, opts={})
+        settings = ServerSettings.new
+
+        settings.set 'name', name
+
+        # set from main Config
+        Config.servers[name].each do |k,v|
+          settings.properties[k]=v
+        end
+
+
+        #puts "current=#{File.dirname(__FILE__)}"
+        #puts "ff=#{file_base_settings}"
+
+        #
+        #t = File.read(file_base_settings) rescue ''
+        #eval(t, settings.get_binding)
+
+
+        #
+        f = file_settings_for_server(name)
+        t = File.read(f) rescue ''
+        eval(t, settings.get_binding)
+
+        #
+        settings.properties['name'] ||= name
+
+        # from common config
+        settings.properties['common'] = Config.options[:common]
+
+        settings
+      end
+
+
+      ### helpers
+
+      def self.file_settings_for_server(name)
+        #File.join(File.dirname(__FILE__), '..', 'config', "#{name}.rb")
+        File.join(Config.root_path, 'servers', name, 'config.rb')
+      end
+
+      def self.file_server_base_settings
+        File.join(File.dirname(__FILE__), '..', 'config' ,'common.rb')
+      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?
+          root_path = File.path(Dir.getwd)
+        end
+
+        new_root = root_path.empty? ? false : set_root_path(root_path)
+
+        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
+
+        # config file
+        set_path_variable("config_file", options['config_file'], DEFAULTS['config_file'], new_root)
+
+      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)
+        # 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)
+
+        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'] || ''), 'DockerApp')
+      #  update(:root_path => @root_path)
+      #end
+    end
+
+    #reset!  # set defaults on load
+  end
+end

data/lib/docker_app/config/dsl.rb

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+module DockerApp
+  module Config
+    # Context for loading user config.rb and model files.
+    class DSL
+      #class Error < Backup::Error; end
+      #Server = DockerApp::Server
+
+      attr_reader :_config_options
+      attr_reader :_config_servers
+
+      def initialize
+        @_config_options = {}
+        @_config_servers = {}
+      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
+
+      # options - common
+      [
+          :prefix, :image_prefix, :container_prefix, :service_prefix,
+          :dir_data
+      ].each do |name|
+        define_method name, lambda {|path| _config_options[name] = path }
+      end
+
+      # allowed options
+      [:common, :base].each do |name|
+        define_method name, lambda {|v| _config_options[name] = v }
+      end
+
+
+      def server(server_name, &block)
+        sc = ServerSettings.new
+        block.call(sc)
+        #sc.instance_eval(&block)
+        _config_servers[server_name] = sc
+      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_app/config/helpers.rb

@@ -0,0 +1,99 @@
+# encoding: utf-8
+require 'ostruct'
+
+module DockerApp
+  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_app/manager_container.rb

@@ -0,0 +1,376 @@
+module DockerApp
+class ManagerContainer
+
+  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.save_config_json(settings)
+    require 'json'
+    filename = settings.filename_config_json
+    FileUtils.mkdir_p(File.dirname(filename))
+    File.open(filename,"w+") do |f|
+      f.write(settings.all_attributes.to_json)
+    end
+
+    true
+  end
+
+
+
+
+  ### run
+
+  def self.run_container(server_name, settings={})
+    puts "creating and running container.."
+    #settings = load_settings(server_name)
+
+    # generate config
+    save_config_json(settings)
+
+
+    # destroy
+    destroy_container(server_name, settings)
+
+    # create
+    create_container(settings)
+
+
+    # START && run provision after start
+    start_container(name, settings)
+
+
+    # TODO: systemd service
+    #res_service = _install_service_container(settings)
+
+
+    true
+  end
+
+  def self.create_container(settings)
+    # create
+    net_options = ""
+    networks = settings['docker'].fetch('network', {}).fetch('networks', [])
+    if networks && networks[0]
+      network = networks[0]
+      #puts "network=#{network}"
+      net_options << "--net #{network['net']} "
+      net_options << "--ip #{network['ip']} "  if network['ip']
+      net_options << "--mac-address #{network['mac_address']} "  if network['mac_address']
+    end
+
+
+    cmd %Q(docker create --name #{settings.container_name} #{net_options} #{settings.docker_ports_string} #{settings.docker_volumes_string} #{settings.docker_volumes_from_string} #{settings.docker_links_string}  #{settings.run_extra_options_string} #{settings.run_env_variables_string} #{settings.image_name} #{settings['docker']['command']} #{settings['docker']['run_options']})
+
+    # network
+    setup_network(settings)
+  end
+
+
+  def self.setup_network(settings)
+    container_name = settings.container_name
+
+    # networks
+    networks = settings['docker'].fetch('network', {}).fetch('networks', [])
+    if networks
+      ind = 0
+      networks.each do |net|
+        ind = ind + 1
+
+        #
+        next if net['action']=='remove'
+
+        # skip first network
+        next if ind==1
+
+        # connect
+        ip = net['ip']
+        s_ip = "--ip #{ip}" if ip
+        #puts %Q(docker network connect #{s_ip}  #{net['net']} #{settings.container_name})
+        cmd %Q(docker network connect #{s_ip}  #{net['net']} #{settings.container_name})
+      end
+
+      # remove
+      networks.each do |net|
+        next unless net['action']=='remove'
+        cmd %Q(docker network disconnect #{net['net']} #{settings.container_name})
+      end
+    end
+  end
+
+
+
+
+  def self.start_container(name, settings)
+    ### BEFORE START
+    # run setup provision scripts
+    DockerApp::Provisioner::Base.run_provision_scripts_setup(settings)
+
+
+    ### start
+    cmd %Q(docker start #{settings.container_name})
+
+    # wait
+    wait_until_running(settings.container_name)
+
+    ### AFTER START
+
+    # setup
+    setup_container_after_start(settings)
+
+    # provision after start
+    # run bootstrap provision scripts
+    DockerApp::Provisioner::Base.run_provision_scripts_bootstrap(settings)
+
+  end
+
+
+  def self.wait_until_running(container_name)
+    retries = 10
+    until system("docker exec #{container_name} true") || retries < 0
+      sleep 1
+      retries = retries - 1
+    end
+
+    assert_container_running(container_name)
+  end
+
+  def self.assert_container_running(container_name)
+    res = system("docker exec #{container_name} true")
+    assert res, "Container #{container_name} is not running"
+  end
+
+
+=begin
+  def self._prepare_provision_before_start_chef(settings, script)
+    puts "_prepare_provision_before_start_chef"
+
+    require_relative '../../lib/docker_app/provisioner/provisioner_chef'
+
+    provisioner = DockerApp::Provisioner::Chef.new(settings)
+    provisioner.copy_config_file
+
+  end
+=end
+
+  def self.setup_container_after_start(settings)
+
+    # default gateway
+    network = settings['docker']['network']
+    if network
+      gateway = network['default_gateway']
+
+      if gateway
+        # fix default gateway
+        #cmd %Q(docker exec #{settings.container_name} ip route change default via #{gateway} dev eth1)
+        cmd %Q(docker exec #{settings.container_name} ip route change default via #{gateway})
+      end
+    end
+
+
+
+    # fix hosts
+    container_hosts = settings['docker']['hosts'] || []
+    container_hosts.each do |r|
+      #cmd %Q(docker exec #{settings.container_name} bash -c 'echo "#{r[0]} #{r[1]}" >>  /etc/hosts')
+      cmd %Q(docker exec #{settings.container_name} sh -c 'echo "#{r[0]} #{r[1]}" >>  /etc/hosts')
+    end
+  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
+
+
+
+=begin
+  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)
+
+    # 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
+
+=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)
+    # destroy temp container
+    cmd %Q(docker rm -f chef-converge.#{settings.image_name} )
+
+    #
+    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
+
+
+
+
+  ### stop container
+
+  def self.stop_container(server_name, settings)
+    puts "stopping container #{server_name}..."
+
+    #
+    cmd %Q(docker stop #{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.clear_cache(name, settings)
+    # common cache
+    cmd("rm -rf ~/.chef/cache")
+    cmd("rm -rf ~/.chef/local-mode-cache")
+
+    # cache for server
+    cmd("rm -rf #{settings.dir_server_root}/.chef/local-mode-cache")
+    #cmd("rm -rf ~/.chef/package-cache")
+
+    # cache in gem
+    cmd("rm -rf #{Config.dir_gem_root}/lib/docker_app/.chef/local-mode-cache")
+
+
+  end
+
+  ###
+
+  def self.cmd(s)
+    Command.cmd(s)
+  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.container_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.container_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_app/chef/.chef/knife.rb"
+  end
+
+  def self.chef_recipe_path(p)
+    "#{Config.dir_gem_root}/lib/docker_app/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
+
+
+  ### common helpers
+  def self.assert(expression, string = "Assert failed")
+    unless expression
+      throw Exception.new string
+    end
+  end
+
+end
+end