vagrant-ec-sandbox 0.1.0.Preview

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 18c3ec44ecb7a7ac2933d5fa3149f5741daf401e
+  data.tar.gz: 890b5f3d80b6bc85b8415273e7f9dd932c198920
+SHA512:
+  metadata.gz: c7b8c7dc6fb9fca3190a6693d0c85a978d308009684afd24bfff07289d4cd246f13c20728e8105f902c944a9ae9dd2da8efabea1ab71460ce345b3aff1439154
+  data.tar.gz: 3462611a424e21ee36c5e84358a83c5d12395ba04f5962cc7b08e66991bcbc30e876e6d92c2e7a563bdea8ee9f208c99ecf2de746a3fdd1448b508883b3bd9c8

data/lib/vagrant-ec-sandbox/action/base.rb

@@ -0,0 +1,53 @@
+require "vagrant/plugin/state_file"
+require_relative "../communicator_extender"
+require_relative "../dir_structure"
+require_relative "../util/host/file_util"
+
+module VagrantPlugins
+  module ECSandbox
+    module Action
+      class Base
+        def template(script_name, variables=nil)
+          contents = Vagrant::Util::TemplateRenderer.render(
+            VagrantPlugins::ECSandbox.source_root.join("templates/action/#{script_name}"), variables)
+        end
+
+        def get_session(env)
+          env[:sandbox_session]
+        end
+
+        def choose(env, title, message, choices)
+          choice = nil
+          allowed = choices.keys
+
+          if !choice
+            while true
+              if title
+                env[:ui].info(title)
+                env[:ui].info('-----------------')
+              end
+
+              choices.each do |option, data|
+                env[:ui].info("#{option}. #{data[:text]}")
+              end
+
+              env[:ui].info('')
+              choice = env[:ui].ask(message)
+
+              # If we don't have an allowed set just exit
+              break if !allowed
+              break if allowed.include?(choice)
+
+              env[:ui].info('')
+              env[:ui].info('')
+            end
+          end
+
+          env[:ui].info('')
+          c = choices[choice]
+          c[:id]
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/action/check_dir.rb

@@ -0,0 +1,41 @@
+require "log4r"
+require "vagrant/plugin/manager"
+require "vagrant/util/platform"
+require_relative "base"
+
+
+module VagrantPlugins
+  module ECSandbox
+    module Action
+      # This middleware checks that a dir exists on guest
+      # system.
+      class CheckDir < Base
+        def initialize(app, env, file, exception, *args)
+          @app = app
+          @logger = Wildfly.logger("check_dir")
+          @file = file
+          @exception = exception
+          @args = args.first
+        end
+
+        def call(env)
+          command = "if [ -d #{@file} ]; then echo Y; else echo N; fi;"
+          installed = nil
+
+          env[:machine].communicate.execute(command) do |type, data|
+            result = data.chop
+            if result == "Y"
+              installed = true
+            elsif result == 'N'
+              installed = false
+            end
+          end
+
+          raise @exception, @args unless installed
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/action/check_file.rb

@@ -0,0 +1,41 @@
+require "log4r"
+require "vagrant/plugin/manager"
+require "vagrant/util/platform"
+require_relative "base"
+
+
+module VagrantPlugins
+  module ECSandbox
+    module Action
+      # This middleware checks that a file exists on guest
+      # system.
+      class CheckFile < Base
+        def initialize(app, env, file, exception, *args)
+          @app = app
+          @logger = Wildfly.logger("check_file")
+          @file = file
+          @exception = exception
+          @args = args.first
+        end
+
+        def call(env)
+          command = "if [ -f #{@file} ]; then echo Y; else echo N; fi;"
+          installed = nil
+
+          env[:machine].communicate.execute(command) do |type, data|
+            result = data.chop
+            if result == "Y"
+              installed = true
+            elsif result == 'N'
+              installed = false
+            end
+          end
+
+          raise @exception, @args unless installed
+
+          @app.call(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/action/code/prepare_dist.rb

@@ -0,0 +1,37 @@
+require "log4r"
+require "vagrant/plugin/manager"
+require "vagrant/util/platform"
+require "uri"
+require_relative "../code"
+require_relative "../base"
+require_relative "../../errors"
+require_relative "../../util/host/mvn"
+
+
+module VagrantPlugins
+  module ECSandbox
+    module Action
+      module Code
+        # This middleware checks that the wildfly is created, and raises
+        # an exception if it is not.
+        class PrepareDist < Base
+          def initialize(app, env)
+            @app    = app
+            @logger = Code.logger("build_dist")
+          end
+
+          def call(env)
+            session = get_session(env)
+            artifact_provider = session.resource_provider(:artifact, 'distribution')
+            files = artifact_provider.prepare(env) || []
+            files = [files] unless files.is_a?(Array)
+
+            env[:ui].info("Following files will be used for Sandbox installation: #{files.join(', ')}")
+            env[:build_result] = files
+            @app.call(env)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/action/code.rb

@@ -0,0 +1,15 @@
+module VagrantPlugins
+  module ECSandbox
+    module Action
+      module Code
+        def self.logger(class_name)
+          Log4r::Logger.new("vagrantplugins::ecsandbox::action::code::#{class_name}")
+        end
+
+        def self.code_dir(session, repo_name)
+        	session.dir_structures[:host].resource(:code, 'ec', repo_name)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/action/dist/check_artifact.rb

@@ -0,0 +1,26 @@
+require "log4r"
+require "vagrant/plugin/manager"
+require "vagrant/util/platform"
+require_relative "../base"
+require_relative "../check_file"
+require_relative "../../errors"
+
+
+module VagrantPlugins
+  module ECSandbox
+    module Action
+      module Dist
+        # This middleware checks that the wildfly is created, and raises
+        # an exception if it is not.
+        class CheckArtifact < VagrantPlugins::ECSandbox::Action::CheckFile
+          def initialize(app, env)
+            session = get_session(env)
+            path = Dist.dist_artifact_path(session, :sandbox)
+            path_host = Dist.dist_artifact_path(session, :host)
+            super(app, env, path, VagrantPlugins::ECSandbox::Errors::DistNotFound, path: path_host)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/action/dist/check_wildfly_installer.rb

@@ -0,0 +1,28 @@
+require "log4r"
+require "vagrant/plugin/manager"
+require "vagrant/util/platform"
+require_relative "../../dir_structure"
+require_relative "../base"
+require_relative "../check_file"
+require_relative "../../errors"
+
+
+module VagrantPlugins
+  module ECSandbox
+    module Action
+      module Dist
+        # This middleware checks that the wildfly is created, and raises
+        # an exception if it is not.
+        class CheckWildflyInstaller < VagrantPlugins::ECSandbox::Action::CheckFile
+          def initialize(app, env)
+            session = get_session(env)
+            path = Dist.dist_wildfly_path(session)
+            
+            super(app, env, path, 
+              VagrantPlugins::ECSandbox::Errors::WildflyInstallerNotFound, path: path)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/action/dist/clear_contents.rb

@@ -0,0 +1,34 @@
+require "log4r"
+require "vagrant/plugin/manager"
+require "vagrant/util/platform"
+require_relative "../../dir_structure"
+require_relative "../base"
+require_relative "../check_file"
+require_relative "../../errors"
+
+
+module VagrantPlugins
+  module ECSandbox
+    module Action
+      module Dist
+        # This middleware clears EC distribution contents from 
+        # tmp directory.
+        class ClearContents < Base
+          def initialize(app, env)
+            @app    = app
+            @logger = Dist.logger("clear_contents")
+          end
+
+          def call(env)
+            session = get_session(env)
+            env[:ui].output("Clearing EC distribution contents...")
+            command = "rm -r --force #{Dist.dist_content_path(session)}"
+            env[:machine].communicate.sudo(command)
+
+            @app.call(env)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/action/dist/config_ec.rb

@@ -0,0 +1,92 @@
+require "log4r"
+require "vagrant/plugin/manager"
+require "vagrant/util/platform"
+require_relative "../base"
+require_relative "../check_file"
+require_relative "../../errors"
+require_relative "../../util/sandbox/wildfly/add-user"
+require_relative "../../config/sandbox_config"
+
+
+module VagrantPlugins
+  module ECSandbox
+    module Action
+      module Dist
+        # This middleware places EC distribution contents to the 
+        # tmp directory.
+        class ConfigEC < Base
+          def initialize(app, env)
+            @app    = app
+            @logger = Dist.logger("config_ec")
+          end
+
+          def call(env)
+            env[:ui].output("Configuring wildfly for EC...")
+            sleep 3
+
+            session = get_session(env)
+            db_info = env[:selected_db_info]
+            raise "no database info selected" unless db_info
+            raise "no machine found" unless env[:machine]
+
+            server_id = env[:server_id]
+            raise "no server id found" unless server_id
+            
+
+            server_config = get_session(env).config.get_server_config(server_id)
+            admin_name = 'admin'
+            admin_password = 'admin'
+
+            opts = {
+              jboss_dir: Dist.wildfly_home_path(session),
+              port: 8080,
+              db_host: db_info.host,
+              db_port: db_info.port,
+              db_serv: db_info.service,
+              db_user: db_info.user,
+              db_pw: db_info.password,
+              smtp_host: server_config.smtp_host,
+              smtp_port: server_config.smtp_port,
+              datasrc_pw_encryption: server_config.datasrc_pw_encryption || false,
+              developer_mode: server_config.developer_mode || true
+            }
+
+
+            installer_opts_str = ""
+            installer_opts_str << " -j #{opts[:jboss_dir]}"
+            installer_opts_str << " -o #{opts[:port]}"
+            installer_opts_str << " -h #{opts[:db_host]}"
+            installer_opts_str << " -p #{opts[:db_port] || 1521}"
+            installer_opts_str << " -s #{opts[:db_serv]}"
+            installer_opts_str << " -u #{opts[:db_user]}"
+            installer_opts_str << " -w #{opts[:db_pw]}"
+            installer_opts_str << " -m #{opts[:smtp_host]}" if opts[:smtp_host]
+            installer_opts_str << " -n #{opts[:smtp_port] || 25}" if opts[:smtp_host]
+            #installer_opts_str << " -e #{opts[:datasrc_pw_encryption] || false}"
+            installer_opts_str << " -d #{opts[:developer_mode]}" if opts[:developer_mode]
+
+            variables = {
+              wildfly_user:"wildfly",
+              default_user:"vagrant",
+              dist_contents_dir:Dist.dist_content_installer_path(session),
+              installer_opts:installer_opts_str
+            }
+
+            env[:machine].communicate.sh(session, template("wildfly/config_ec.sh", variables), 
+              file_name_base: "config_ec.sh") do |type, data|
+              # puts "#{type}: #{data}"
+            end
+
+            VagrantPlugins::ECSandbox::Util::Sandbox::Wildfly::AddUser.execute(env, admin_name, admin_password, 
+              user_type: :management)
+
+            env[:ui].detail("Admin user '#{admin_name}' has been created.")
+            env[:ui].success("Wildfly is configured for EC, ready for deploy.")
+
+            @app.call(env)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/action/dist/deploy_ecapp.rb

@@ -0,0 +1,44 @@
+require "log4r"
+require "vagrant/plugin/manager"
+require "vagrant/util/platform"
+require_relative "../../dir_structure"
+require_relative "../base"
+require_relative "../dist"
+require_relative "../../util/sandbox/wildfly/deploy"
+
+
+module VagrantPlugins
+  module ECSandbox
+    module Action
+      module Dist
+        # This middleware checks that the wildfly is created, the 
+        # result is placed in `env[:result]` so that it can be used
+        # with the {Call} class.
+        class DeployEcApp < Base
+          def initialize(app, env)
+            @app    = app
+            @logger = Dist.logger("deploy_ecapp")
+          end
+
+          def call(env)
+            session = get_session(env)
+            server_id = env[:server_id]
+            raise "no server id found" unless server_id
+            
+            server_config = get_session(env).config.get_server_config(server_id)
+
+            env[:ui].info(I18n.t("ec_sandbox.action.dist.deploying_ec_app")) 
+            result = VagrantPlugins::ECSandbox::Util::Sandbox::Wildfly::Deploy.execute(
+              Dist.wildfly_home_path(session), 
+              Dist.dist_ecapp_path(session),
+               server_config.wildfly_server_group, 
+               env)
+            env[:ui].success(I18n.t("ec_sandbox.action.dist.ec_app_deployed")) 
+
+            @app.call(env)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/action/dist/get_vbuild.rb

@@ -0,0 +1,39 @@
+require "log4r"
+require "vagrant/plugin/manager"
+require "vagrant/util/platform"
+require_relative "../base"
+require_relative "../../dir_structure"
+
+
+module VagrantPlugins
+  module ECSandbox
+    module Action
+      module Dist
+       # This middleware installs wildfly to app directory.
+        class GetViaBuild < Base
+          def initialize(app, env)
+            @app    = app
+            @logger = Dist.logger("install")
+          end
+
+          def call(env)
+            session = get_session(env)
+            last_build_result = env[:build_result]
+            raise "no files installed from last build" if last_build_result.empty?
+            
+            for f in last_build_result
+              if f.end_with?('-distribution.zip')
+                path = f if f.end_with?('-distribution.zip')
+              end
+            end
+            raise "cannot find distribution file from last build" unless path
+
+            FileUtils.rm(Dist.dist_artifact_path(session, :host)) if File.exist?(Dist.dist_artifact_path(session, :host))
+            FileUtils.cp(path, Dist.dist_artifact_path(session, :host))
+            @app.call(env)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/action/dist/get_vnexus.rb

@@ -0,0 +1,65 @@
+require "log4r"
+require "vagrant/plugin/manager"
+require "vagrant/util/platform"
+require "vagrant/util/downloader"
+
+require_relative "../../dir_structure"
+require_relative "../base"
+require_relative "../check_file"
+require_relative "../../errors"
+require_relative "../../util/name"
+
+
+module VagrantPlugins
+  module ECSandbox
+    module Action
+      module Dist
+        # This middleware checks that the wildfly is created, and raises
+        # an exception if it is not.
+        class GetViaNexus < Base
+          def initialize(app, env)
+            @app    = app
+            @logger = Dist.logger("get_vnexus")
+          end
+
+          def call(env)
+            session = get_session(env)
+            env[:ui].output("Downloading EC Install package from nexus...")
+
+            url = "http://ws002990.eu.tieto.com:8082/nexus/service/local/repositories/releases/content/com/ec/frmw/ec-app-install/11.0.0/ec-app-install-11.0.0-distribution.zip"
+            tmmp_name = VagrantPlugins::ECSandbox::Util::Name.unique("ec-app-install-11.0.0-distribution") + ".zip"
+            temp_path = session.dir_structures[:host].tmp("action", "Dist_GetViaNexus", tmmp_name)
+            downloader_options = {
+              ui:env[:ui]
+            }
+            # downloader_options[:ca_cert] = env[:box_download_ca_cert]
+            # downloader_options[:ca_path] = env[:box_download_ca_path]
+            # downloader_options[:continue] = true
+            # downloader_options[:insecure] = env[:box_download_insecure]
+            # downloader_options[:client_cert] = env[:box_download_client_cert]
+            # downloader_options[:headers] = ["Accept: application/json"] if opts[:json]
+
+            d = Vagrant::Util::Downloader.new(url, temp_path, downloader_options)
+
+
+
+            begin
+              d.download!
+            rescue Errors::DownloaderInterrupted
+              # The downloader was interrupted, so just return, because that
+              # means we were interrupted as well.
+              @download_interrupted = true
+              env[:ui].info(I18n.t("vagrant.actions.box.download.interrupted"))
+            end
+
+            Pathname.new(d.destination)
+
+
+
+            @app.call(env)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/action/dist/install_wildfly.rb

@@ -0,0 +1,40 @@
+require "log4r"
+require "vagrant/plugin/manager"
+require "vagrant/util/platform"
+require_relative "../base"
+require_relative "../../dir_structure"
+
+
+module VagrantPlugins
+  module ECSandbox
+    module Action
+      module Dist
+       # This middleware installs wildfly to app directory.
+        class InstallWildfly < Base
+          def initialize(app, env)
+            @app    = app
+            @logger = Dist.logger("install")
+          end
+
+          def call(env)
+            session = get_session(env)
+
+            variables = {
+              app_dir: Dist.appserver_root_path(session),
+              wildfly_dist: Dist.dist_wildfly_path(session)
+            }
+
+            env[:ui].output("Installing wildfly...")
+            
+            env[:machine].communicate.sh(session, template("dist/install_wildfly.sh", variables), 
+              file_name_base: "install_wildfly.sh")
+
+            env[:ui].success("Wildfly installed.")
+            
+            @app.call(env)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/action/dist/make_contents.rb

@@ -0,0 +1,36 @@
+require "log4r"
+require "vagrant/plugin/manager"
+require "vagrant/util/platform"
+require_relative "../../dir_structure"
+require_relative "../base"
+require_relative "../check_file"
+require_relative "../../errors"
+
+
+module VagrantPlugins
+  module ECSandbox
+    module Action
+      module Dist
+        # This middleware places EC distribution contents to the 
+        # tmp directory.
+        class MakeContents < Base
+          def initialize(app, env)
+            @app    = app
+            @logger = Dist.logger("make_contents")
+          end
+
+          def call(env)
+            session = get_session(env)
+            env[:ui].output("Making EC distribution contents...")
+            command = "unzip #{Dist.dist_artifact_path(session)} -d #{Dist.dist_content_path(session)}"
+            env[:machine].communicate.execute(command)
+            command = "chmod 775 -R #{Dist.dist_content_path(session)}"
+            env[:machine].communicate.sudo(command)
+
+            @app.call(env)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/action/dist.rb

@@ -0,0 +1,44 @@
+require_relative "../dir_structure"
+
+
+module VagrantPlugins
+  module ECSandbox
+    module Action
+      module Dist
+        def self.logger(class_name)
+          Log4r::Logger.new("vagrantplugins::ecsandbox::action::dist::#{class_name}")
+        end
+
+        def self.dist_artifact_path(session, env_name = :sandbox)
+          session.dir_structures[env_name || :sandbox].resource(:artifacts, :distribution)
+        end
+
+        def self.dist_content_path(session)
+          session.dir_structures[:sandbox].tmp("dist_contents")
+        end
+
+        def self.dist_content_installer_path(session)
+          session.dir_structures[:sandbox].internal(:tmp, "dist_contents", "ec-app-install")
+        end
+
+        def self.appserver_root_path(session)
+          session.dir_structures[:sandbox].internal(:app, :as)
+        end
+
+        def self.wildfly_home_path(session)
+          session.dir_structures[:sandbox].internal(:app, :as, "wildfly-8.1.0.Final")
+        end
+
+        def self.dist_wildfly_path(session)
+          session.dir_structures[:sandbox].internal(
+            :tmp, "dist_contents", "ec-app-install", "bin", "wildfly-dist", "wildfly-dist.zip")
+        end
+
+        def self.dist_ecapp_path(session)
+          session.dir_structures[:sandbox].internal(
+            :tmp, "dist_contents", "ec-app-install", "bin", "ec-app", "ec-app.ear")
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/action/init/env_config_confirm.rb

@@ -0,0 +1,18 @@
+require "vagrant/action/builtin/confirm"
+
+module VagrantPlugins
+  module ECSandbox
+    module Action
+      module Init
+        class EnvConfigConfirm < Vagrant::Action::Builtin::Confirm
+          def initialize(app, env)
+            force_key = :force_env_config_destroy
+            message = I18n.t("ec_sandbox.action.init.configure_system_confirm")
+
+            super(app, env, message, force_key, allowed: ["y", "n", "Y", "N"])
+          end
+        end
+      end
+    end
+  end
+end