vagrant-ec-sandbox 0.1.0.Preview

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

@@ -0,0 +1,306 @@
+module VagrantPlugins
+  module ECSandbox
+    class DirStructure
+      attr_reader :is_sandboxed_dev
+      attr_reader :is_dev
+      attr_reader :project_dir
+
+      def self.of(env_name, opts=nil)
+        # init!
+        new_opts = {
+          dev?:!Vagrant.in_installer?,
+          dev_sandbox?:(!Vagrant.in_installer?)&&File.path(opts[:working_dir]) == "/home/vagrant/repo/.dev-playground",
+          working_dir:opts[:working_dir],
+          dir:[
+            [:project, :vagrantfile, "Vagrantfile"],
+            [:resource, :artifacts, :distribution, "distribution/ec-app-install-distribution.zip"],
+            [:internal, :vagrant, "vagrant"],
+            [:internal, :vagrant, :provision_script, "provision.sh"],
+            [:internal, :tmp, "tmp"],
+            [:internal, :logs, "logs"],
+            [:status, :app_server, :logs, "logs"]
+          ]
+        }.merge({} || opts)
+
+        if env_name == :host
+          result = HostDir.configure(new_opts)
+        elsif env_name == :sandbox
+          result = SandboxDir.configure(new_opts)
+        end
+
+        result
+      end
+
+      # def self.of(env_name)
+      #   init!
+      #   @@dirs[env_name]
+      # end
+
+      def resource(*name)
+        path = _find_path(@dirs, :resource, name)
+        #_prepare_path(path, opts)
+        path
+      end
+
+      def internal(*name)
+        path = _find_path(@dirs, :internal, name)
+        #_prepare_path(path, opts)
+        path
+      end
+
+      def project(*name)
+        path = _find_path(@dirs, :project, name)
+        #_prepare_path(path, opts)
+        path
+      end
+
+      def status(*name)
+        path = _find_path(@dirs, :status, name)
+        #_prepare_path(path, opts)
+        path
+      end
+
+      def using(contents, opts=nil, &block)
+      end
+
+
+      def initialize(opts=nil)
+        @dirs = {}
+        @is_dev = opts[:dev?]
+        @is_sandboxed_dev = opts[:dev_sandbox?]
+        @project_dir = opts[:working_dir]
+
+        for dir in (opts[:dir] || [])
+          current_dir = @dirs
+
+          for d in 0 .. dir.length - 1
+            path_el = dir[d]
+            if d == dir.length - 1
+              current_dir[:__root__] = path_el.to_s
+            else
+              d_symbol = path_el.is_a?(Symbol) ? path_el : path_el.to_sym
+              current_dir[d_symbol] ||= {}
+              current_dir = current_dir[d_symbol]
+            end
+          end
+        end
+      end
+
+      def _find_path(dir, start, names)
+        current_dir = start ? dir[start] : dir
+        current_path = start ? current_dir[:__root__] : @project_dir
+
+        for n in names
+          if n.is_a?(Symbol)
+            raise "cannot find parent dir of #{n.to_s}" unless current_dir
+
+            current_dir = current_dir[n];
+            if current_dir
+              current_path = _expend_path_str(
+                current_dir[:__root__] || n.to_s, current_path)
+            else
+              raise "cannot find dir with symbol :#{n} under path #{current_path}"
+            end
+          elsif n.is_a?(String)
+            current_dir = nil
+            n_str = n.to_s
+            current_path = _expend_path_str(n_str, current_path)
+          else
+            raise "wrong input, does not support class #{n.class}"
+          end
+        end
+
+        Pathname.new(current_path)
+      end
+
+      def expend_path(dir, base)
+        Pathname.new(_expend_path_str(dir, base))
+      end
+
+      def _expend_path_str(dir, base)
+      end
+
+      def _prepare_path(path, opts)
+        path.create if !path.exist? && opts[:create]
+      end
+
+      # def self.init!
+      #   return if defined?(@_init)
+      #   @@dirs = {}
+      #   @_init = true
+      # end
+
+      def make_all
+      end
+
+      # Merge one dir_structure with another and return a completely new
+      # dir_structure.
+      def merge(other)
+        self.class.new.tap do |result|
+          result.merge!(self)
+          result.merge!(other)
+        end
+      end
+
+      # Like #{merge} but merges into self.
+      def merge!(other)
+        @dirs.merge(other.instance_variable_get(:@dirs))
+        @is_dev = other.instance_variable_get(:@is_dev)
+        @is_sandboxed_dev = other.instance_variable_get(:@is_sandboxed_dev)
+        @project_dir = other.instance_variable_get(:@project_dir)
+
+        self
+      end
+    end
+
+    class HostDir < DirStructure
+      def self.configure(opts=nil)
+        new_opts = opts || {}
+        new_opts[:dir] << [:project, opts[:working_dir]]
+        new_opts[:dir] << [:resource, "#{new_opts[:working_dir]}/resources"]
+        new_opts[:dir] << [:internal, "#{new_opts[:working_dir]}/.sandbox-app"]
+        new_opts[:dir] << [:status, "#{new_opts[:working_dir]}/status"]
+        new_opts[:dir] << [:internal, :sandbox_dotvagrant,
+          (new_opts[:dev_sandbox?] ? "/home/vagrant/.dev-playground-dotvagrant" : "#{new_opts[:working_dir]}/.vagrant")]
+        new_opts[:dir] << [:resource, :config, :maven, :settings_file, "settings.xml"]
+        new_opts[:dir] << [:resource, :code, "code"]
+
+        HostDir.new(new_opts)
+      end
+
+      def _expend_path_str(dir, base)
+        File.expand_path(dir, base)
+      end
+
+      def make_all
+        FileUtils.mkdir_p(resource(:artifacts, :distribution).dirname)
+        FileUtils.mkdir_p(status(:app_server, :logs).dirname)
+      end
+
+      def using(contents, opts=nil, &block)
+        new_opts = {
+          file_name_base:nil,
+          category:nil,
+          use_unit_line_ending:nil
+        }.merge(opts || {})
+
+        use_unit_line_ending = new_opts[:use_unit_line_ending] || false
+        category = new_opts[:category] || 'any'
+        file_name_base = new_opts[:file_name_base] || 'sandbox'
+        file_name = File.basename(file_name_base, ".*")
+        ext_name = File.extname(file_name_base)
+
+        final_file_name = VagrantPlugins::ECSandbox::Util::Name.unique(base:file_name, suffix:ext_name)
+        final_path = internal(:tmp, category, final_file_name)
+
+        VagrantPlugins::ECSandbox::Util::Host::FileUtil.create(
+          final_path, contents, make_dir:true, delete_existing:true, use_unit_line_ending:use_unit_line_ending)
+        block.call(final_path)
+        # TODO: windows permission issue when deleting a file
+        #delete(path)
+      end
+
+
+      def tmp(name, opts=nil)
+        internal(:tmp, name)
+      end
+
+      def vagrantfile(opts=nil)
+        project(:vagrantfile)
+      end
+
+      def provision_script(opts=nil)
+        internal(:vagrant, :provision_script)
+      end
+
+      def mvn_settings(opts=nil)
+        resource(:config, :maven, :settings_file)
+      end
+
+      def sandbox_dotvagrant(opts=nil)
+        internal(:sandbox_dotvagrant)
+      end
+    end
+
+    class SandboxDir < DirStructure
+      def self.configure(opts=nil)
+        new_opts = opts || {}
+        new_opts[:dir] << [:project, '/home/vagrant/sandbox']
+        new_opts[:dir] << [:resource, '/home/vagrant/sandbox/resources']
+        new_opts[:dir] << [:internal, '/home/vagrant/.sandbox']
+        new_opts[:dir] << [:status, '/home/vagrant/status']
+        new_opts[:dir] << [:internal, :app, "app"]
+        new_opts[:dir] << [:internal, :app, :as, "as"]
+        new_opts[:dir] << [:resource, :config, :maven, :settings_file, "settings.xml"]
+
+        SandboxDir.new(new_opts)
+      end
+
+      def _expend_path_str(dir, base)
+        path = File.expand_path(dir, base)
+
+        if Vagrant::Util::Platform.windows?
+          path = path.gsub("\\", "/")
+          if (cidx = path.index(':'))
+            path = path[cidx + 1..path.size]
+          end
+        end
+
+        path
+      end
+
+      def using(contents, opts=nil, &block)
+        new_opts = {
+          file_name_base:nil,
+          category:nil,
+          use_unit_line_ending:nil,
+          communicator:nil,
+          permissions:nil,
+          host_dir_structure:nil
+        }.merge(opts || {})
+
+        raise "no communicator provided" unless new_opts[:communicator]
+        communicator = new_opts[:communicator]
+        permissions = '755' || new_opts[:permissions]
+
+        raise "no host dir structure provided" unless new_opts[:host_dir_structure]
+        host_dir_structure = new_opts[:host_dir_structure]
+    
+        use_unit_line_ending = new_opts[:use_unit_line_ending] || false
+        category = new_opts[:category] || 'any'
+        file_name_base = new_opts[:file_name_base] || 'sandbox'
+        file_name = File.basename(file_name_base, ".*")
+        ext_name = File.extname(file_name_base)
+
+        final_file_name = VagrantPlugins::ECSandbox::Util::Name.unique(base:file_name, suffix:ext_name)
+        final_path_p = internal(:tmp, category)
+        final_path = _expend_path_str(final_file_name, final_path_p)
+
+        host_dir_structure.using(contents, opts) do |file|
+          communicator.execute("mkdir -p #{final_path_p}")
+          communicator.upload(file, final_path)
+          block.call(final_path)
+          communicator.execute("sudo rm #{final_path}")
+        end
+      end
+
+
+      def tmp(name, opts=nil)
+        internal(:tmp, name)
+      end
+
+      def vagrantfile(opts=nil)
+        project(:vagrantfile)
+      end
+
+      def provision_script(opts=nil)
+        internal(:vagrant, :provision_script)
+      end
+
+      def mvn_settings(opts=nil)
+        resource(:config, :maven, :settings_file)
+      end
+    end
+
+  end
+end

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

@@ -0,0 +1,33 @@
+require "log4r"
+require "vagrant/plugin/manager"
+require "vagrant/util/platform"
+require "vagrant/errors"
+
+
+module VagrantPlugins
+  module ECSandbox
+    module Errors
+      class Base < Vagrant::Errors::VagrantError
+        def initialize(*args)
+          super(args.first)
+        end
+      end
+
+      class WildflyNotInstalled < Base
+        error_key(:wildfly_not_installed, "ec_sandbox.errors")
+      end
+
+      class WildflyInstallerNotFound < Base
+        error_key(:wildfly_installer_not_found, "ec_sandbox.errors")
+      end
+
+      class DistNotFound < Base
+        error_key(:dist_not_found, "ec_sandbox.errors")
+      end
+
+      class UserNameNotFoundError < Base
+        error_key(:user_name_not_found, "ec_sandbox.errors")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,11 @@
+module VagrantPlugins
+    module ECSandbox
+        
+        # The source root is the path to the root directory of the Vagrant source.
+        #
+        # @return [Pathname]
+        def self.source_root
+            @source_root ||= Pathname.new(File.expand_path('../../../', __FILE__))
+        end
+    end
+end

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

@@ -0,0 +1,29 @@
+require_relative "dir_structure"
+
+module VagrantPlugins
+   module ECSandbox
+    class Ec < Vagrant.plugin("2")
+      name 'EC Sandbox'
+
+      command "ec" do
+        require_relative 'command/root'
+        init!
+        Command::Root
+      end
+
+      config "ec" do
+        require_relative "config/sandbox_config"
+        init!
+        Config::SandboxConfig
+      end
+
+      def self.init!
+        return if defined?(@_init)
+        I18n.load_path << File.expand_path("templates/locales/en.yml", VagrantPlugins::ECSandbox.source_root)
+        I18n.reload!
+
+        @_init = true
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/resource/hg_clone_provider.rb

@@ -0,0 +1,46 @@
+require "vagrant/util/platform"
+require_relative 'resource_provider'
+require_relative "../util/host/hg_clone"
+
+
+module VagrantPlugins
+  module ECSandbox
+    module Resource
+      class HgCloneProvider < ResourceProvider
+        def self.name
+          'hg_clone'
+        end
+        
+        def prepare(env)
+          session = env[:sandbox_session]
+      
+          artifact = @config.repo || @name
+          artifact = artifact.to_s.strip
+          dist_dir = @config.target || session.dir_structures[:host].resource(:code, artifact)
+          default_branch = @config.default_branch || 'default'
+          default_user = @config.default_user
+
+          raise 'artifact cannot be null or empty' unless artifact && artifact.size > 0
+
+          env[:ui].info("Bitbucket login:")
+          user = env[:ui].ask("User name [#{default_user}]: ")
+          password = env[:ui].ask("Password: ", echo:false)
+          branch = env[:ui].ask("Branch to build [#{default_branch}]: ")
+
+          branch = default_branch if branch.size == 0
+          user = default_user if user.size == 0
+
+          clone_url = "https://#{user}:#{URI.escape(password)}@bitbucket.org/energycomponents/#{artifact}"
+          FileUtils.rm_rf(dist_dir) if File.exist?(dist_dir)
+          FileUtils.mkdir_p(dist_dir)
+
+          env[:ui].info("Cloning #{artifact}...")
+          VagrantPlugins::ECSandbox::Util::Host::HgClone.execute(clone_url, dist_dir, branch, env)
+          env[:ui].success("#{artifact} cloned.")
+
+          dist_dir
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/resource/hg_clone_provider_config.rb

@@ -0,0 +1,29 @@
+require "vagrant"
+require_relative 'provider_config'
+
+module VagrantPlugins
+   module ECSandbox
+    module Resource
+      class HgCloneProviderConfig < ProviderConfig
+        attr_accessor :default_branch
+        attr_accessor :default_user
+        attr_accessor :target # the target dir to clone to, if nil, [:resource/:code/:artifact] will be used
+        attr_accessor :repo # the repo to clone, if nil, the artifict name will be used
+
+        def initialize
+          @default_branch = UNSET_VALUE
+          @default_user = UNSET_VALUE
+          @target = UNSET_VALUE
+          @repo = UNSET_VALUE
+        end
+
+        def finalize!
+          @default_branch = nil if @default_branch == UNSET_VALUE
+          @default_user = nil if @default_user == UNSET_VALUE
+          @target = nil if @target == UNSET_VALUE
+          @repo = nil if @repo == UNSET_VALUE
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/resource/local_provider.rb

@@ -0,0 +1,19 @@
+require_relative 'resource_provider'
+
+module VagrantPlugins
+  module ECSandbox
+    module Resource
+      class LocalProvider < ResourceProvider
+        def self.name
+          'local'
+        end
+        
+        def prepare(env)
+          FileUtils.mkdir_p(config.path) unless File.exist?(config.path)
+
+          @config.path
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/resource/local_provider_config.rb

@@ -0,0 +1,20 @@
+require "vagrant"
+require_relative 'provider_config'
+
+module VagrantPlugins
+   module ECSandbox
+    module Resource
+      class LocalProviderConfig < ProviderConfig
+        attr_accessor :path
+
+        def initialize
+          @path = UNSET_VALUE
+        end
+
+        def finalize!
+          @path = nil if @path == UNSET_VALUE
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/resource/maven_provider.rb

@@ -0,0 +1,51 @@
+require_relative 'resource_provider'
+
+module VagrantPlugins
+  module ECSandbox
+    module Resource
+      class MavenProvider < ResourceProvider
+        def self.name
+          'maven_build'
+        end
+        
+        def prepare(env)
+          session = env[:sandbox_session]
+          code_name = @config.code || @name
+          code_provider = session.resource_provider(:code, code_name)
+
+          dist_dir = code_provider.prepare(env)
+
+          env[:ui].info("Building #{name}...")
+          artifact = nil
+          version = nil
+          files = []
+
+          VagrantPlugins::ECSandbox::Util::Host::Mvn.install(dist_dir, env) do |status_type, data|
+            case status_type
+            when :downloading
+              uri = URI.parse(data)
+              file_name = File.basename(uri.path)
+              env[:ui].detail("Downloading #{file_name}...")
+            # when :start_build
+            #   artifact = data[:artifact]
+            #   version = data[:version]
+            when :installing
+              files << data[:repo]
+            when :result
+              case data
+              when :success
+                env[:ui].success("Built.")
+              when :failure
+                env[:ui].error("Build failed.")
+              else
+                env[:ui].error("Unknown build result #{data}.")
+              end
+            end
+          end
+
+          files
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/resource/maven_provider_config.rb

@@ -0,0 +1,20 @@
+require "vagrant"
+require_relative 'provider_config'
+
+module VagrantPlugins
+   module ECSandbox
+    module Resource
+      class MavenProviderConfig < ProviderConfig
+        attr_accessor :code # the name of code set to use, if not given, name of the resource will be used
+
+        def initialize
+          @code = UNSET_VALUE
+        end
+
+        def finalize!
+          @code = nil if @code == UNSET_VALUE
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/resource/provider_config.rb

@@ -0,0 +1,10 @@
+require "vagrant"
+
+module VagrantPlugins
+   module ECSandbox
+    module Resource
+      class ProviderConfig < Vagrant.plugin("2", "config")
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/resource/resource_provider.rb

@@ -0,0 +1,20 @@
+module VagrantPlugins
+  module ECSandbox
+    module Resource
+      class ResourceProvider
+        attr_reader :category
+        attr_reader :name
+        attr_reader :config
+    
+        def initialize(category, name, config)
+          @category = category
+          @name = name
+          @config = config
+        end
+
+        def prepare(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/server/app_server/as.rb

@@ -0,0 +1,18 @@
+require_relative '../server'
+
+module VagrantPlugins
+  module ECSandbox
+    module Server
+      module AppServer
+        class AS < VagrantPlugins::ECSandbox::Server::Server
+          def self.name
+            "app_server"
+          end
+
+          def finalize!
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/server/app_server/as_config.rb

@@ -0,0 +1,38 @@
+module VagrantPlugins
+  module ECSandbox
+    module Server
+      module AppServer
+        class ASConfig < Vagrant.plugin("2", "config")
+          attr_accessor :smtp_host
+          attr_accessor :smtp_port
+          attr_accessor :datasrc_pw_encryption
+          attr_accessor :developer_mode
+          attr_accessor :wildfly_servers
+          attr_accessor :wildfly_server_group
+          attr_accessor :wildfly_profile
+
+
+          def initialize
+            @smtp_host                  = UNSET_VALUE
+            @smtp_port                  = UNSET_VALUE
+            @datasrc_pw_encryption      = UNSET_VALUE
+            @developer_mode             = UNSET_VALUE
+            @wildfly_servers            = UNSET_VALUE
+            @wildfly_server_group       = UNSET_VALUE
+            @wildfly_profile            = UNSET_VALUE
+          end
+
+          def finalize!
+            @smtp_host = nil if @smtp_host == UNSET_VALUE
+            @smtp_port = nil if @smtp_port == UNSET_VALUE
+            @datasrc_pw_encryption = false if @datasrc_pw_encryption == UNSET_VALUE
+            @developer_mode = true if @developer_mode == UNSET_VALUE
+            @wildfly_servers = ['ec-default-server'] if @wildfly_servers == UNSET_VALUE
+            @wildfly_server_group = 'ec-default-group' if @wildfly_server_group == UNSET_VALUE
+            @wildfly_profile = 'full' if @wildfly_profile == UNSET_VALUE
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module VagrantPlugins
+  module ECSandbox
+    module Server
+      class Server
+        attr_reader :id
+        attr_reader :config
+    
+        def initialize(id, config)
+          @id = id
+          @config = config
+        end
+
+        def finalize!
+        end
+      end
+    end
+  end
+end