vagrant-ec-sandbox 0.1.0.Preview

data/lib/vagrant-ec-sandbox/session.rb

@@ -0,0 +1,146 @@
+require "vagrant/registry"
+require_relative 'resource/local_provider'
+require_relative 'resource/local_provider_config'
+
+module VagrantPlugins
+  module ECSandbox
+    class Session
+      def self.default
+        return @__default
+      end
+
+      def self.init_default(env)
+        config = env.vagrantfile.config.ec
+        config ||= VagrantPlugins::ECSandbox::Config::SandboxConfig.new 
+
+        @__default = new(config, env.cwd)
+      end
+
+      def self.create_machine(machine)
+        raise "default is not initialized" unless default
+
+        config = machine.config.ec
+        config ||= VagrantPlugins::ECSandbox::Config::SandboxConfig.new 
+        session = Session.new(config, default.cwd)
+
+        return default.merge(session) 
+      end
+
+      attr_reader :servers
+      attr_reader :server_ids
+      attr_reader :db_selectors
+      attr_reader :db_selector_ids
+      attr_reader :dir_structures
+      attr_reader :config
+      attr_reader :cwd
+
+      def initialize(config, cwd, opts=nil)
+        opts = {
+          skip_init: false
+        }.merge(opts || {})
+
+        @resource_providers = Vagrant::Registry.new
+        @servers = Vagrant::Registry.new
+        @server_ids = {}
+        @db_selectors = Vagrant::Registry.new
+        @db_selector_ids = {}
+        @cwd = cwd
+        @config = config
+        @dir_structures = {
+          host: DirStructure.of(:host, working_dir:cwd),
+          sandbox: DirStructure.of(:sandbox, working_dir:cwd)
+        }
+
+        return if opts[:skip_init]
+
+        config.get_resources.each do |category, name|
+          internal_name = __get_resource_internal_name(category, name)
+          @resource_providers.register(internal_name) do
+            provider_name = config.get_resource_provider_name(category, name)
+            provider_config = config.get_resource_config(category, name)
+
+            klazz = VagrantPlugins::ECSandbox.resource_provider_defs[provider_name]
+            raise "resource provider for #{provider_name} is not registered" unless klazz
+            new_resource_provider = klazz.new(category, name, provider_config)
+            new_resource_provider
+          end
+        end
+
+        config.get_servers.each do |id, name|
+          # register server
+          @servers.register(id) do
+            server_config = config.get_server_config(id)
+            klazz = VagrantPlugins::ECSandbox.server_defs[name]
+            new_server = klazz.new(id, server_config)
+            new_server
+          end
+
+          # register server id
+          ids = @server_ids[name] || []
+          ids << id
+          @server_ids[name] = ids
+        end
+
+        config.get_db_selectors.each do |id, name|
+          # register db-selector
+          @db_selectors.register(id) do
+            selector_config = config.get_db_selector_config(id)
+            klazz = VagrantPlugins::ECSandbox.db_selector_defs[name]
+            new_db_selector = klazz.new(id, selector_config)
+            new_db_selector
+          end
+
+          # register db-selector id
+          ids = @db_selector_ids[name] || []
+          ids << id
+          @db_selector_ids[name] = ids
+        end
+      end
+
+      def resource_provider(category, name)
+        provider = @resource_providers.get(__get_resource_internal_name(category, name))
+        unless provider
+          config = VagrantPlugins::ECSandbox::Resource::LocalProviderConfig.new
+          config.path = @dir_structures[:host].resource(category, name)
+          provider = VagrantPlugins::ECSandbox::Resource::LocalProvider.new(category, name, config)
+        end
+
+        provider
+      end
+
+      # Merge one session with another and return a completely new
+      # session.
+      def merge(other)
+        self.class.new(other.config, other.cwd, skip_init: true).tap do |result|
+          result.merge!(self)
+          result.merge!(other)
+        end
+      end
+
+      # Like #{merge} but merges into self.
+      def merge!(other)
+        @resource_providers.merge!(other.instance_variable_get(:@resource_providers))
+        @servers.merge!(other.servers)
+        @db_selectors.merge!(other.db_selectors)
+        @dir_structures.merge!(other.dir_structures)
+        @server_ids.merge!(other.server_ids) { |key, old_val, new_val|
+          (old_val || []) | (new_val || [])
+        }
+        @db_selector_ids.merge!(other.db_selector_ids) { |key, old_val, new_val|
+          (old_val || []) | (new_val || [])
+        }
+
+        self
+      end
+
+      def __get_resource_internal_name(category, name)
+        category = category.to_s if category.is_a?(Symbol)
+        name = name.to_s if name.is_a?(Symbol)
+        name = "#{category}_#{name}"
+
+        name.to_sym
+      end
+
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/util/host/dir_util.rb

@@ -0,0 +1,39 @@
+require "fileutils"
+
+
+module VagrantPlugins
+  module ECSandbox
+    module Util
+      module Host
+        class DirUtil
+          def self.create(dir, contents, opts=nil)
+            path.mkdir unless path.exist?
+          end
+
+          def self.delete(path)
+            path.delete if path.exist?
+          end
+
+          def self.using(contents, env, opts=nil, &block)
+            tmpfile_opts = {
+              make_parents: true,
+              delete_existing: true,
+              file_name_base: nil,
+              category: nil
+              }.merge(opts || {}) do |key, oldval, newval|
+              oldval || newval
+            end
+
+            name = ::VagrantPlugins::ECSandbox::Util::Name.unique(base:tmpfile_opts[:file_name_base])
+            dir = ::VagrantPlugins::ECSandbox::Util::DirUtil.tmp(category)
+            path = Pathname.new(File.expand_path(name, dir))
+
+            create(path, contents, tmpfile_opts)
+            block.call(path)
+            delete(path)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/util/host/file_util.rb

@@ -0,0 +1,67 @@
+require "log4r"
+require "vagrant/plugin/manager"
+require "vagrant/util/platform"
+require_relative "../name"
+require_relative "dir_util"
+
+module VagrantPlugins
+  module ECSandbox
+    module Util
+      module Host
+        class FileUtil
+          def self.create(dest, contents, opts=nil)
+            new_opts = {
+              make_dir: true,
+              delete_existing: true,
+              use_unit_line_ending: true
+              }.merge(opts || {}) do |key, oldval, newval|
+              oldval || newval
+            end
+
+            if !dest
+              return
+            end
+
+            if new_opts[:delete_existing] && dest.exist?
+              dest.delete
+            end
+
+            FileUtils.mkdir_p(dest.dirname) if new_opts[:make_dir] && !dest.dirname.exist?
+
+            if new_opts[:use_unit_line_ending] && Vagrant::Util::Platform.windows?
+              contents = contents.gsub(/\r\n?/,"\n")
+            end
+
+            if dest.open("wb+") do |f|
+                f.write(contents)
+              end
+            end
+          end
+
+          def self.delete(path)
+            path.delete if path.exist?
+          end
+
+          # def self.using(contents, tmp_root, opts=nil, &block)
+          #   tmpfile_opts = {
+          #     make_parents: true,
+          #     delete_existing: true,
+          #     file_name_base: nil,
+          #     category: nil
+          #     }.merge(opts || {}) do |key, oldval, newval|
+          #     oldval || newval
+          #   end
+
+          #   name = ::VagrantPlugins::ECSandbox::Util::Name.unique(base:tmpfile_opts[:file_name_base])
+          #   path = Pathname.new(File.expand_path(name, tmp_root))
+
+          #   create(path, contents, tmpfile_opts)
+          #   block.call(path)
+          #   # TODO: windows permission issue when deleting a file
+          #   #delete(path)
+          # end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/util/host/hg_clone.rb

@@ -0,0 +1,32 @@
+require "log4r"
+require "vagrant/plugin/manager"
+require "vagrant/util/platform"
+
+
+module VagrantPlugins
+  module ECSandbox
+    module Util
+      module Host
+        class HgClone
+          def self.execute(source, target, branch, env)
+            new(source, target, branch).execute(env)
+          end
+
+          def initialize(source, target, branch)
+            @source = source
+            @target = target
+            @branch = branch || 'default'
+          end
+
+          def execute(env)
+            Vagrant::Util::Subprocess.execute("hg", "clone", "-b#{@branch}", @source.to_s, @target.to_s, notify:[:stdout, :stderr]) do |type, data|
+              if type == :stderr
+                raise "failed to clone, detailed message - " << data
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/util/host/mvn.rb

@@ -0,0 +1,54 @@
+require "log4r"
+require "vagrant/plugin/manager"
+require "vagrant/util/platform"
+require_relative "../output_buffer"
+
+
+module VagrantPlugins
+  module ECSandbox
+    module Util
+      module Host
+        class Mvn
+          def self.execute(dir, env, *phases, &block)
+            new(dir).execute(env, phases, &block)
+          end
+
+          def self.install(dir, env, &block)
+            new(dir).execute(env, "clean", "install", &block)
+          end
+
+          def self.copy()
+          end
+
+
+          def initialize(dir)
+            @dir = dir.to_s
+          end
+
+          def execute(env, *phases, &block)
+            commands = ["mvn"].concat(phases || [])
+            listener = nil
+
+            if block
+              listener = VagrantPlugins::ECSandbox::Util::OutputBuffer.listen do |io_name, data|
+                if (match=data.match(/(Downloading: )(.*)/i))
+                  block.call(:downloading, match.captures[1].strip)
+                # elsif (match=data.match(/(\[INFO\] )(Building )(.*)( )(.*)/i))
+                #   block.call(:start_build, {artifact:match.captures[2].strip, version:match.captures[4].strip})
+                elsif (match=data.match(/(\[INFO\] )(BUILD SUCCESS)(.*)/i))
+                  block.call(:result, :success)
+                elsif (match=data.match(/(\[INFO\] )(BUILD FAILURE)(.*)/i))
+                  block.call(:result, :failure)
+                elsif (match=data.match(/(\[INFO\] )(Installing )(.*)( )(.*)/i))
+                  block.call(:installing, {local:match.captures[2].strip, repo:match.captures[4].strip})
+                end
+              end
+            end
+
+            Vagrant::Util::Subprocess.execute(*commands, notify:[:stdout, :stderr], workdir:@dir, &listener)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/util/name.rb

@@ -0,0 +1,22 @@
+require "log4r"
+require "vagrant/plugin/manager"
+require "vagrant/util/platform"
+
+module VagrantPlugins
+  module ECSandbox
+    module Util
+      class Name
+        def self.unique(opts=nil)
+          new_opts = {
+            base:nil,
+            suffix:nil
+          }.merge(opts || {}) do |key, oldval, newval|
+            oldval || newval
+          end
+
+          (new_opts[:base] || 'any') << "#" << DateTime.now.strftime('%Q') << "#" << SecureRandom.random_number(1000).to_s << (new_opts[:suffix] || '')
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/util/output_buffer.rb

@@ -0,0 +1,58 @@
+module VagrantPlugins
+  module ECSandbox
+    module Util
+      class OutputBuffer
+        def initialize(opts=nil, &block)
+          opts = {
+            skip_all:false
+          }.merge(opts || {})
+          @block = block;
+          @skip_all = (opts[:skip_all] || false) || !@block
+        end
+
+        def self.listen(opts=nil, &block)
+          new(opts, &block).method(:on_output)
+        end
+
+        def on_output(io_name, data)
+          if @skip_all
+            return
+          end
+
+          @pending ||= {}
+          io_name_sym = io_name.to_sym
+
+          data.lines.map {|l|
+            if l.size == 0
+              return
+            end
+
+            if l[l.size-1].ord != 10 #line feed
+              @pending[io_name_sym] ||= ""
+              @pending[io_name_sym] << l
+              return
+            end
+
+            if @pending[io_name_sym]
+              l = @pending[io_name_sym] << l
+              @pending[io_name_sym] = nil
+            end
+
+            l = l.strip
+            @block.call(io_name_sym, l)
+          }
+        end
+
+        def skip_all
+          @skip_all = true
+        end
+        
+        def reset
+          @result = nil
+          @pending = nil
+          @skip_all = true if @block
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/util/sandbox/get_user_processes.rb

@@ -0,0 +1,85 @@
+require "log4r"
+require "vagrant/plugin/manager"
+require "vagrant/util/platform"
+require_relative "system_command"
+require_relative "../../errors"
+
+
+module VagrantPlugins
+  module ECSandbox
+    module Util
+      module Sandbox
+        class GetUserProcesses < SystemCommand
+          def self.execute(username, env)
+            new(username).execute(env)
+          end
+
+          def initialize(username)
+            @username = username
+            super("ps -u #{username} -o pid,cmd --no-header", {good_exit: [0, 1]})
+          end
+
+          def on_line(type, line)
+            if type == :stderr
+              if line.match(/(user name does not exist)/i)
+                skip_outputs
+                @error = 1
+              end
+            else
+              @result ||= []
+
+              seperator_idx = line.index(' ')
+
+              if !seperator_idx
+                return
+              end
+
+              pid = line[0..seperator_idx-1]
+              command = line[seperator_idx+1..line.size]
+              info = find_info(command)
+
+              @result << {:pid=>pid, :command=>command, :info=>info}
+            end
+          end
+
+
+          def on_end(result_code)
+            if @error == 1
+              raise VagrantPlugins::ECSandbox::Errors::UserNameNotFoundError, username: @username
+            end
+
+            @result ||= []
+          end
+
+          def find_info(command)
+            info = {}
+
+            name = ""
+            type = nil
+
+            if (match=command.match(/(\/bin\/sh .*bin\/domain\.sh)/i))
+              type = :wildfly_domain_sh
+              name = "Wildfly Domain Executable"
+            elsif (match=command.match(/(java -D\[)(.*)(\])/i))
+              name = match.captures[1].strip
+
+              if name.start_with?("Process Controller")
+                type = :wildfly_process_controller
+              elsif name.start_with?("Host Controller")
+                type = :wildfly_host_controller
+              elsif name.start_with?("Server:")
+                type = :wildfly_server
+                info[:server_name] = name[7,name.size]
+              end
+            end
+
+            info[:name] = name
+            info[:type] = type
+
+            info
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/util/sandbox/system_command.rb

@@ -0,0 +1,91 @@
+require "log4r"
+require "vagrant/plugin/manager"
+require "vagrant/util/platform"
+
+
+module VagrantPlugins
+  module ECSandbox
+    module Util
+      module Sandbox
+        class SystemCommand
+          def initialize(command, opts=nil)
+            @command = command
+            @opts = {
+              sudo: false
+              }.merge(opts || {})
+          end
+
+          def execute(env)
+            ext_logger = VagrantPlugins::ECSandbox.logger("parser::base")
+            ext_logger.debug("To run command #{@command} with parser.")
+            communicate = env[:machine].communicate
+
+            if (@opts[:sudo])
+              r = communicate.sudo(@command, @opts.merge(@opts || {})) do |type, data|
+                on_output(type, data)
+              end
+            else
+              r = communicate.execute(@command, @opts.merge(@opts || {})) do |type, data|
+                on_output(type, data)
+              end
+            end
+
+            begin
+              on_end(r)
+              result = @result
+              @result = nil
+            ensure
+              reset
+            end
+
+            result
+          end
+
+          def on_output(type, data)
+            if @skip_outputs
+              return
+            end
+
+            @pending ||= {}
+            type_sym = type.to_sym
+
+            data.lines.map {|l|
+              if l.size == 0
+                return
+              end
+
+              if l[l.size-1].ord != 10 #line feed
+                @pending[type_sym] ||= ""
+                @pending[type_sym] << l
+                return
+              end
+
+              if @pending[type_sym]
+                l = @pending[type_sym] << l
+                @pending[type_sym] = nil
+              end
+
+              l = l.strip
+              on_line(type_sym, l)
+            }
+          end
+
+          def skip_outputs
+            @skip_outputs = true
+          end
+
+          def on_line(type, line)
+          end
+          
+          def on_end(result_code)
+          end
+
+          def reset
+            @result = nil
+            @skip_outputs = nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/util/sandbox/wildfly/add-user.rb

@@ -0,0 +1,48 @@
+require "log4r"
+require "vagrant/plugin/manager"
+require "vagrant/util/platform"
+require_relative "../system_command"
+
+
+module VagrantPlugins
+  module ECSandbox
+    module Util
+      module Sandbox
+        module Wildfly
+          class AddUser < VagrantPlugins::ECSandbox::Util::Sandbox::SystemCommand
+            def self.execute(env, user_name, password, opts=nil)
+              new(env[:sandbox_session], user_name, password, opts).execute(env)
+            end
+
+            def initialize(session, user_name, password, opts=nil)
+              new_opts = {
+                user_type: :management
+              }.merge(opts || {})
+
+              @user_name = user_name
+              @password = password
+              @user_type = opts[:user_type] || :management
+              @adduser_bin = session.dir_structures[:sandbox].internal(:app, :as, "wildfly-8.1.0.Final", "bin", "add-user.sh")
+
+              additional_param = ''
+              case @user_type
+              when :management
+                additional_param = ''
+              when :application
+                additional_param = '-a'
+              else
+                raise "unkonwn user type #{@user_type.to_s}"
+              end
+
+              super("sudo -u wildfly #{@adduser_bin} --user #{user_name} --password #{password} --enable --confirm-warning --silent #{additional_param}", 
+                {good_exit: [0]})
+            end
+
+            def on_line(type, line)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/util/sandbox/wildfly/deploy.rb

@@ -0,0 +1,34 @@
+require "log4r"
+require "vagrant/plugin/manager"
+require "vagrant/util/platform"
+require_relative "../system_command"
+
+
+module VagrantPlugins
+  module ECSandbox
+    module Util
+      module Sandbox
+        module Wildfly
+          class Deploy < VagrantPlugins::ECSandbox::Util::Sandbox::SystemCommand
+            def self.execute(wildfly_home, artifact_path, server_group, env)
+              new(wildfly_home, artifact_path, server_group).execute(env)
+            end
+
+            def initialize(wildfly_home, artifact_path, server_group)
+              super("sudo -u wildfly #{wildfly_home}/bin/jboss-cli.sh --connect --command=\"deploy --server-groups=#{server_group} #{artifact_path}\"")
+            end
+
+            def on_line(type, line)
+              @result ||= []
+              puts line
+            end
+
+            def on_end(result_code)
+              @result ||= []
+            end
+          end
+        end
+      end
+    end
+  end
+end