vagrant-ec-sandbox 0.1.0.Preview

data/lib/vagrant-ec-sandbox/config/sandbox_config.rb

@@ -0,0 +1,235 @@
+module VagrantPlugins
+  module ECSandbox
+    module Config
+      class SandboxConfig < Vagrant.plugin("2", "config")
+        attr_accessor :default_db_selector_id
+
+        def initialize
+          @__server_configs = {} # hash of {id, config_block}
+          @__servers = {} # hash of {id, name}
+          @__db_selector_configs = {} # hash of {id, config_block}
+          @__db_selectors = {} # hash of {id, name}
+          @__resource_provider_configs = {} # hash of {resource path, config_block}
+          @__resource_provider_paths = {} # hash of {resource path, [paths]}
+
+          @__compiled_server_configs = {}
+          @__compiled_db_selector_configs = {}
+          @__compiled_resource_provider_configs = {} #hash of {resource path, config}
+          @__resource_provider_names = {}
+          @__finalized = false
+        end
+
+        def server(name, &block)
+          name = name.to_sym
+          id = "#{name}_#{@__servers.size + 1}"
+
+          @__server_configs[id] = block
+          @__servers[id] = name
+
+          id
+        end
+
+        def db_selector(name, &block)
+          name = name.to_sym
+          id = "#{name}_#{@__db_selectors.size + 1}"
+
+          @__db_selector_configs[id] = block
+          @__db_selectors[id] = name
+
+          id
+        end
+
+        def artifact(name, &block)
+          internal_name = __get_resource_internal_name(:artifact, name)
+          @__resource_provider_configs[internal_name] = block
+          @__resource_provider_paths[internal_name] = [:artifact, name]
+        end
+
+        def code(name, &block)
+          internal_name = __get_resource_internal_name(:code, name)
+          @__resource_provider_configs[internal_name] = block
+          @__resource_provider_paths[internal_name] = [:code, name]
+        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
+
+        def get_servers
+          raise "Must finalize first." if !@__finalized
+          return @__servers
+        end
+
+        def get_db_selectors
+          raise "Must finalize first." if !@__finalized
+          return @__db_selectors
+        end
+
+        def get_resources
+          raise "Must finalize first." if !@__finalized
+          return @__resource_provider_paths.values
+        end
+
+
+        def get_server_config(id)
+          raise "Must finalize first." if !@__finalized
+          return @__compiled_server_configs[id]
+        end
+
+        def get_db_selector_config(id)
+          raise "Must finalize first." if !@__finalized
+          return @__compiled_db_selector_configs[id]
+        end
+
+        def get_resource_config(category, name)
+          internal_name = __get_resource_internal_name(category, name)
+          return @__compiled_resource_provider_configs[internal_name]
+        end
+
+        def get_resource_provider_name(category, name)
+          internal_name = __get_resource_internal_name(category, name)
+          return @__resource_provider_names[internal_name]
+        end
+
+
+        def merge(other)
+          super.tap do |result|
+            other_resource_provider_configs = other.instance_variable_get(:@__resource_provider_configs) || {}
+            other_resource_provider_paths = other.instance_variable_get(:@__resource_provider_paths) || {}
+            other_server_configs = other.instance_variable_get(:@__server_configs) || {}
+            other_servers = other.instance_variable_get(:@__servers) || {}
+            other_db_selector_configs = other.instance_variable_get(:@__db_selector_configs) || {}
+            other_db_selectors = other.instance_variable_get(:@__db_selectors) || {}
+
+            new_resource_provider_configs = other_resource_provider_configs.dup.merge(@__resource_provider_configs)
+            new_resource_provider_paths = other_resource_provider_paths.dup.merge(@__resource_provider_paths)
+            new_server_configs = other_server_configs.dup.merge(@__server_configs)
+            new_servers = other_servers.dup.merge(@__servers)
+            new_db_selector_configs = other_db_selector_configs.dup.merge(@__db_selector_configs)
+            new_db_selectors = other_db_selectors.dup.merge(@__db_selectors)
+
+            result.instance_variable_set(:@__resource_provider_configs, new_resource_provider_configs)
+            result.instance_variable_set(:@__resource_provider_paths, new_resource_provider_paths)
+            result.instance_variable_set(:@__server_configs, new_server_configs)
+            result.instance_variable_set(:@__servers, new_servers)
+            result.instance_variable_set(:@__db_selector_configs, new_db_selector_configs)
+            result.instance_variable_set(:@__db_selectors, new_db_selectors)
+          end
+        end
+
+        def finalize!
+          @__resource_provider_configs.each do |id, block|
+            paths = @__resource_provider_paths[id]
+            compile_resource_provider_config(paths[0], paths[1], block)
+          end
+
+
+          @__server_configs.each do |id, block|
+            name = @__servers[id]
+            compile_server_config(id, name, block)
+          end
+
+
+          manual_selector_found = false
+          @__db_selector_configs.each do |id, block|
+            name = @__db_selectors[id]
+            if name == :manual
+              manual_selector_found = true
+            end
+            compile_db_selector_config(id, name, block)
+          end
+
+          unless manual_selector_found
+            id = db_selector('manual')
+            compile_db_selector_config(id, :manual, nil)
+          end
+
+          @__finalized = true
+        end
+
+        def compile_server_config(id, name, block)
+          config_class = VagrantPlugins::ECSandbox.server_configs[name]
+          config_class ||= Vagrant::Config::V2::DummyConfig
+
+          # load the config and apply blocks on it
+
+          begin
+            config = config_class.new
+            block.call(config, Vagrant::Config::V2::DummyConfig.new)
+          rescue Exception => e
+            raise Vagrant::Errors::VagrantfileLoadError,
+              path: "<server config: #{name}>",
+              message: e.message
+          end
+
+          config.finalize!
+          @__compiled_server_configs[id] = config
+        end
+
+        def compile_db_selector_config(id, name, block)
+          config_class = VagrantPlugins::ECSandbox.db_selector_configs[name]
+          config_class ||= Vagrant::Config::V2::DummyConfig
+
+          # load the config and apply blocks on it
+          begin
+            config = config_class.new
+            block.call(config, Vagrant::Config::V2::DummyConfig.new) if block
+          rescue Exception => e
+            raise Vagrant::Errors::VagrantfileLoadError,
+              path: "<db_selector config: #{name}>",
+              message: e.message
+          end
+
+          config.finalize!
+          @__compiled_db_selector_configs[id] = config
+          @default_db_selector_id = id if config.is_default == true
+        end
+
+        def compile_resource_provider_config(category, name, block)
+          configurator = ResourceConfigirator.new
+          block.call(configurator) if block
+          internal_name = __get_resource_internal_name(category, name)
+
+          @__compiled_resource_provider_configs[internal_name] = configurator.get_config
+          @__resource_provider_names[internal_name] = configurator.get_provider_name
+        end
+
+        class ResourceConfigirator
+          def use(provider_name)
+            @provider_name = provider_name.chop
+            @provider_name = provider_name.to_sym unless provider_name.is_a?(Symbol)
+            config_class = VagrantPlugins::ECSandbox.resource_provider_configs[@provider_name]
+            config_class ||= Vagrant::Config::V2::DummyConfig
+
+            # load the config and apply blocks on it
+            begin
+              @config = config_class.new
+            rescue Exception => e
+              raise Vagrant::Errors::VagrantfileLoadError,
+                path: "<resource config: #{use}>",
+                message: e.message
+            end
+          end
+
+          def config
+            @config
+          end
+
+          def get_config
+            raise "need to specify a provider with 'use' method first" unless @provider_name
+            config.finalize!
+            config
+          end
+
+          def get_provider_name
+            @provider_name
+          end
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/db_selector/db_info.rb

@@ -0,0 +1,8 @@
+module VagrantPlugins
+   module ECSandbox
+    module DBSelector
+      class DBInfo
+      end
+    end
+  end
+end

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

@@ -0,0 +1,20 @@
+module VagrantPlugins
+   module ECSandbox
+    module DBSelector
+      class DBSelector
+        attr_reader :id
+        attr_reader :config
+        attr_reader :name
+
+        def initialize(id, config)
+          @id = id
+          @config = config
+          @name = config.name if config.name.is_a?(String)
+        end
+
+        def select(env)
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/db_selector/direct_selector.rb

@@ -0,0 +1,30 @@
+require_relative 'db_selector'
+require_relative 'oracle_db_info'
+
+module VagrantPlugins
+   module ECSandbox
+    module DBSelector
+      class DirectSelector < DBSelector
+        def self.name 
+          "direct"
+        end
+
+        def self.source 
+          "Pre-defined"
+        end
+        
+
+        def select(env)
+          info = OracleDBInfo.new
+          info.host = @config.host
+          info.port = @config.port
+          info.service = @config.serv
+          info.user = @config.user
+          info.password = @config.pw
+
+          info
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/db_selector/direct_selector_config.rb

@@ -0,0 +1,37 @@
+require "vagrant"
+require_relative "selector_config"
+
+module VagrantPlugins
+   module ECSandbox
+    module DBSelector
+      class DirectSelectorConfig < SelectorConfig
+        attr_accessor :name
+        attr_accessor :host
+        attr_accessor :port
+        attr_accessor :serv
+        attr_accessor :user
+        attr_accessor :pw
+
+        def initialize
+          super
+          @name             = UNSET_VALUE
+          @host             = UNSET_VALUE
+          @port             = UNSET_VALUE
+          @serv             = UNSET_VALUE
+          @user             = UNSET_VALUE
+          @pw               = UNSET_VALUE
+        end
+
+        def finalize!
+          super
+          @name = nil if @name == UNSET_VALUE
+          @host = nil if @host == UNSET_VALUE
+          @port = '1521' if @port == UNSET_VALUE
+          @serv = nil if @serv == UNSET_VALUE
+          @user = nil if @user == UNSET_VALUE
+          @pw = 'energy' if @pw == UNSET_VALUE
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/db_selector/manual_input_selector.rb

@@ -0,0 +1,32 @@
+require_relative 'db_selector'
+
+module VagrantPlugins
+   module ECSandbox
+    module DBSelector
+      class ManualInputSelector < DBSelector
+        def self.name 
+          "manual"
+        end
+
+        def self.source 
+          "Manual input"
+        end
+        
+
+        def select(env)
+          ui = env[:ui]
+          info = OracleDBInfo.new
+
+          ui.info('Manually input a database connection info:')
+          info.host = ui.ask('Host: ')
+          info.port = ui.ask('Port [1521]: ') || '1521'
+          info.service = ui.ask('Service: ')
+          info.user = ui.ask('User: ')
+          info.password = ui.ask('Password [energy]: ', echo:false) || 'energy'
+
+          info
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/db_selector/oracle_db_info.rb

@@ -0,0 +1,19 @@
+require_relative "db_info"
+
+module VagrantPlugins
+   module ECSandbox
+    module DBSelector
+      class OracleDBInfo < DBInfo
+        attr_accessor :host
+        attr_accessor :port
+        attr_accessor :service
+        attr_accessor :user
+        attr_accessor :password
+
+        def initialize
+          @port = '1521'
+        end
+      end
+    end
+  end
+end

data/lib/vagrant-ec-sandbox/db_selector/selector_config.rb

@@ -0,0 +1,22 @@
+require "vagrant"
+
+module VagrantPlugins
+   module ECSandbox
+    module DBSelector
+      class SelectorConfig < Vagrant.plugin("2", "config")
+        attr_accessor :is_default
+        attr_accessor :name
+
+        def initialize
+          @is_default      = UNSET_VALUE
+          @name            = UNSET_VALUE
+        end
+
+        def finalize!
+          @is_default = false if @is_default == UNSET_VALUE
+          @name = nil if @name == UNSET_VALUE
+        end
+      end
+    end
+  end
+end