docker-app 0.2.1

data/lib/docker_app/manager_image.rb

@@ -0,0 +1,119 @@
+module DockerApp
+  class ManagerImage
+
+    ###
+    def self.build_image(server_name, settings=nil)
+      puts "building image for #{server_name}..."
+      #puts "settings: #{settings}"
+      #puts "debug: #{settings['properties']}"
+
+      #settings = load_settings(server_name)
+
+      t = settings['build']['build_type']
+      if t=='' || t=='none'
+        #
+        puts "no build needed..."
+
+      elsif t.downcase=='dockerfile'
+        return build_image_with_dockerfile(settings)
+      elsif t.downcase=='github'
+        return build_image_with_dockerfile_github(settings)
+
+      elsif t=='chef'
+        return build_image_with_chef(settings)
+      elsif t=='packer'
+        return build_image_with_packer(settings)
+      end
+    end
+
+    def self.build_image_with_dockerfile(settings)
+      puts "build image with Dockerfile"
+
+      #cmd %Q(cd #{name} && docker build -t #{settings.image_name} . )
+      cmd %Q(docker build -t #{settings.image_name} #{settings.dir_server_root} )
+
+    end
+
+    def self.build_image_with_dockerfile_github(settings)
+      puts "build image with Dockerfile from github"
+
+      cmd %Q(docker build -t #{settings.image_name} #{settings.properties['build']['base_image']['repository']} )
+
+    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
+
+
+    def self.build_image_with_packer(settings)
+      require_relative '../../lib/docker_app/builder/packer'
+
+      puts "build image with packer"
+
+      builder = DockerApp::Builder::Packer.new(settings)
+      builder.build
+    end
+
+
+    def self.destroy_image(server_name, settings={})
+      puts "destroying image for server #{server_name}"
+
+      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})
+
+      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.image_exist?(settings)
+
+    end
+
+    ###
+    def self.cmd(s)
+      Command.cmd(s)
+    end
+
+  end
+end

data/lib/docker_app/manager_swarm.rb

@@ -0,0 +1,66 @@
+module DockerApp
+  class ManagerSwarm
+
+    def self.destroy_service(server_name, settings)
+      puts "destroying service #{server_name}..."
+
+      #
+      cmd %Q(docker service rm #{settings.service_name} )
+
+      #
+      return true
+    end
+
+
+    def self.create_service(server_name, settings={})
+      puts "create swarm service.."
+
+      # destroy
+      destroy_service(server_name, settings)
+
+
+      # prepare
+      create_volumes_dirs(settings)
+
+      # create service
+      docker_opts = settings.properties['docker']
+
+      run_opts = []
+      run_opts << "--network #{docker_opts['swarm_network']}" if docker_opts['swarm_network']
+      run_opts << settings.docker_ports_string
+      run_opts << settings.run_env_variables_string
+
+      # volumes
+      #--mount type=bind,source=/path/on/host,destination=/path/in/container
+      run_opts << settings.docker_volumes.map{|r| "--mount type=bind,source=#{r[0]},destination=#{r[1]}" }.join(' ')
+
+      #
+      run_opts << docker_opts['swarm_options']
+
+      cmd %Q(docker service create \
+--name #{settings.service_name} \
+#{run_opts.join(' ')} \
+#{settings.image_name} #{settings['docker']['command']}
+)
+    end
+
+
+    # volumes
+    def self.create_volumes_dirs(settings)
+      settings.docker_volumes.each do |r|
+        dirpath = "#{r[0]}"
+        if !Dir.exists?(dirpath)
+          FileUtils.mkdir_p(dirpath) rescue nil
+        end
+      end
+    end
+
+    # helpers
+
+    def self.cmd(s)
+      Command.cmd(s)
+    end
+
+
+  end
+end

data/lib/docker_app/provisioner/base.rb

@@ -0,0 +1,179 @@
+module DockerApp
+  module Provisioner
+  class Base
+
+    def self.run_provision_scripts_setup(settings)
+      #
+      setup_scripts = (settings['provision']['setup'] rescue [])
+      if setup_scripts
+        setup_scripts.each do |script|
+          _run_setup_script(settings, script)
+        end
+      end
+
+    end
+
+
+    def self.run_provision_scripts_bootstrap(settings)
+      #
+      bootstrap_scripts = (settings['provision']['bootstrap'] rescue [])
+      if bootstrap_scripts
+        bootstrap_scripts.each do |script|
+          _run_bootstrap_script(settings, script)
+        end
+      end
+
+
+=begin
+# commented - 2017-02-22
+
+    #
+    install_node_script_type = (settings['install']['node']['script_type'] rescue nil)
+    install_bootstrap_script = (settings['install']['bootstrap']['script'] rescue nil)
+
+    if install_node_script_type && install_node_script_type=='chef_recipe'
+      # run container and provision with chef
+      #_run_container_chef(settings)
+
+      # ???
+      #_provision_container_chef_recipe(settings)
+
+    elsif install_node_script_type && install_node_script_type=='shell'
+      # docker run
+      #create_and_run_container(settings)
+
+      # provision with shell script
+      run_shell_script_in_container(settings, "install.sh")
+
+    else
+      # no script for provision
+      #_run_container_docker(settings)
+
+      # docker run
+      #create_and_run_container(settings)
+
+    end
+
+    # bootstrap
+    if install_bootstrap_script
+      #script = settings['install']['bootstrap']['script'] || '/opt/bootstrap/bootstrap.sh'
+
+      # bootstsrap with shell script
+      run_bootstrap_shell_script_in_container(settings, install_bootstrap_script)
+    end
+=end
+
+    end
+
+
+
+
+    ### provision - setup
+
+    def self._run_setup_script(settings, script)
+      puts "run script #{script}"
+
+      if script['type']=='shell'
+        return _run_setup_script_on_host_shell(settings, script)
+      elsif script['type']=='chef'
+        return _run_setup_script_on_host_chef(settings, script)
+      end
+
+      return nil
+    end
+
+    def self._run_setup_script_on_host_shell(settings, script)
+      cmd %Q(cd #{settings.dir_server_root} && #{script['script']} )
+    end
+
+    def self._run_setup_script_on_host_chef(settings, script)
+      raise 'NOT implemented'
+
+      # 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
+
+      #
+
+      return true
+    end
+
+
+
+
+    ### provision - bootstrap
+
+    def self._run_bootstrap_script(settings, script)
+      puts "run BS script #{script}"
+
+      if script['type']=='shell' && script['run_from']=='host'
+        return _run_bootstrap_script_on_host_shell(settings, script)
+      elsif script['type']=='shell' && (script['run_from'].nil? || script['run_from']=='')
+        _run_bootstrap_script_in_container_shell(settings, script)
+      elsif script['type']=='chef'
+        _run_bootstrap_script_in_container_chef(settings, script)
+      end
+
+      return nil
+    end
+
+
+    def self._run_bootstrap_script_on_host_shell(settings, script)
+      cmd %Q(cd #{settings.dir_server_root} && #{script['script']} )
+
+    end
+
+
+    def self._run_bootstrap_script_in_container_shell(settings, script)
+      script_path = script['script']
+
+      # exec
+      cmd %Q(docker exec #{settings.container_name} #{script_path} )
+    end
+
+    def self._run_bootstrap_script_in_container_chef(settings, script)
+      req = DockerApp::Provisioner::Chef.new(settings)
+      return req.run_recipe_in_container script['dir_base'], script['recipe_name']
+    end
+
+
+
+    ### helpers - shell
+
+    def self.run_script_in_container_shell(settings, script_name)
+      script_path = settings.make_path_full("scripts/#{script_name}")
+
+      # copy
+      cmd %Q(cd #{Config.root_path} && docker cp #{script_path} #{settings.container_name}:/tmp/#{script_name} )
+
+      # exec
+      cmd %Q(docker exec #{settings.container_name} chmod +x /tmp/#{script_name} )
+      cmd %Q(docker exec #{settings.container_name} /tmp/#{script_name} )
+    end
+
+
+
+
+
+    ###
+    def self.cmd(s)
+      Command.cmd(s)
+    end
+
+
+  end
+  end
+end
+

data/lib/docker_app/provisioner/chef.rb

@@ -0,0 +1,93 @@
+module DockerApp
+  module Provisioner
+    class Chef
+
+      attr_accessor :server
+
+      def server=(v)
+        @server = v
+        @server
+      end
+
+      def server
+        @server
+      end
+
+      def settings
+        server
+      end
+
+
+      def initialize(_settings)
+        self.server = _settings
+
+      end
+
+      ###
+
+      def copy_config_file
+        # config json
+        save_config
+
+        # copy to container
+        DockerApp::Command.cmd %Q(docker cp #{filename_config} #{settings.container_name}:#{docker_filename_config})
+
+      end
+
+      def save_config
+        require 'json'
+        filename = filename_config
+        FileUtils.mkdir_p(File.dirname(filename))
+        File.open(filename,"w+") do |f|
+          f.write(build_config.to_json)
+        end
+
+        true
+      end
+
+      def filename_config
+        File.join(Config.root_path, 'temp', "bootstrap-#{settings.name}.json")
+      end
+
+      def docker_filename_config
+        "/opt/bootstrap/config.json"
+      end
+
+      def build_config
+        res = {}
+
+        attr = settings.properties['attributes']
+        res = attr
+
+        #res = settings.all_attributes
+
+        res
+      end
+
+
+      ### run recipes
+      def run_recipe_in_container(dir_base, recipe_name)
+
+        recipe_name ||= "server::bootstrap"
+
+        # generate config
+        copy_config_file
+
+
+        #
+        q = %Q(cd #{dir_base} && chef-client -z -j #{docker_filename_config} --override-runlist "recipe[#{recipe_name}]" )
+
+        # exec
+        docker_run_cmd q
+      end
+
+      ###
+      def docker_run_cmd(s)
+        DockerApp::Command.cmd %Q(docker exec #{settings.container_name} bash -c '#{s}')
+      end
+
+    end
+  end
+end
+
+