ruby_yacht 0.3.0 → 0.4.0

data/lib/ruby_yacht/runner/shell.rb

@@ -13,7 +13,7 @@ module RubyYacht::Runner
     attr_accessor :project_name
 
     # The name of the app that we are opening a shell in.
-    attr_accessor :app
+    attr_accessor :app_name
 
     # The name of the command that we are invoking in the shell.
     attr_accessor :command
@@ -39,7 +39,7 @@ module RubyYacht::Runner
     #
     # * **arguments: Array**    The command-line arguments.
     def parse_positional_arguments(arguments)
-      self.app = arguments.shift
+      self.app_name = arguments.shift
       self.command = arguments.join(' ')
       if self.command == ''
         self.command = 'bash'
@@ -48,7 +48,7 @@ module RubyYacht::Runner
 
     # This method runs the logic for the command.
     def run
-      if app.nil?
+      if app_name.nil?
         log "You must provide an app name"
         log "Run #{Command.short_script_name} help shell for more information"
         return false
@@ -57,7 +57,8 @@ module RubyYacht::Runner
       project = self.project_named(project_name)
       return false unless project
 
-      container = "#{project.system_prefix}-#{app}"
+      app = project.apps.find { |a| a.name == app_name.to_sym }
+      container = app.container_name(project)
       exec("docker exec -it #{container} bash -c 'cd /var/code; TERM=xterm #{command}'")
       true
     end

data/lib/ruby_yacht/runner/update_hosts.rb

@@ -60,7 +60,8 @@ module RubyYacht::Runner
       main_domain = project.domain
     
       domains = [main_domain]
-      domains += project.apps.map { |app| "#{app.name}.#{main_domain}" }
+      apps = project.apps.select { |app| app.name != system_prefix }
+      domains += apps.map { |app| "#{app.name}.#{main_domain}" }
     
       header = "# #{system_prefix} docker containers"
       new_hosts = ["", header]

data/ruby_yacht.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name         = 'ruby_yacht'
-  spec.version      = '0.3.0'
+  spec.version      = '0.4.0'
   spec.date         = '2016-04-19'
   spec.description  = "A DSL for building docker containers for a family of Rails apps"
   spec.summary      = "A DSL for building docker containers for a family of Rails apps"

data/spec/dsl/app_spec.rb

@@ -8,7 +8,8 @@ RSpec.describe RubyYacht::App do
     before do
       RubyYacht.configuration.clear
       RubyYacht.configure do
-        app_type :test do
+        server_type :test do
+          container_type :app
           baseline_image 'ubuntu'
         end
       end
@@ -17,50 +18,84 @@ RSpec.describe RubyYacht::App do
     it "creates an app with all fields" do
       @builder = Proc.new do
         repository_name 'brownleej/test-app'
-        app_type :test
+        database_name :database
+        server_type :test
         port 3000
       end
       expect(app.name).to eq :test_app
       expect(app.repository_name).to eq 'brownleej/test-app'
-      expect(app.app_type).to eq :test
+      expect(app.database_name).to eq :database
+      expect(app.server_type).to eq :test
       expect(app.port).to eq 3000
     end
 
     it "requires the repository name" do
       @builder = Proc.new do
         port 3000
-        app_type :test
+        server_type :test
+        database_name :database
       end
       expect do
         self.app
       end.to raise_exception("Missing required attribute repository_name for RubyYacht::App::DSL")
     end
 
-    it "requires the app type" do
+    it "requires the server type" do
       @builder = Proc.new do
         repository_name 'brownleej/test-app'
         port 3000
+        database_name :database
       end
       expect do
         self.app
-      end.to raise_exception("Missing required attribute app_type for RubyYacht::App::DSL")
+      end.to raise_exception("Missing required attribute server_type for RubyYacht::App::DSL")
     end
 
-    it "requires a defined app type" do
+    it "does not require the database name" do
       @builder = Proc.new do
-        app_type :invalid
         repository_name 'brownleej/test-app'
+        server_type :test
         port 3000
       end
+      expect(app.database_name).to be_nil
+    end
+
+    it "requires a defined server type" do
+      @builder = Proc.new do
+        server_type :invalid
+        repository_name 'brownleej/test-app'
+        port 3000
+        database_name :database
+      end
+      expect do
+        self.app
+      end.to raise_exception("App has invalid server type `invalid`")
+    end
+
+    it "requires a defined server type for apps" do
+      RubyYacht.configure do
+        server_type :sqlite do
+          container_type :database
+          baseline_image 'ubuntu'
+        end
+      end
+
+      @builder = Proc.new do
+        server_type :sqlite
+        repository_name 'brownleej/test-app'
+        port 3000
+        database_name :database
+      end
       expect do
         self.app
-      end.to raise_exception("App has invalid app type `invalid`")
+      end.to raise_exception("App has invalid server type `sqlite`")
     end
 
     it "defaults the port to 8080" do
       @builder = Proc.new do
         repository_name 'brownleej/test-app'
-        app_type :test
+        server_type :test
+        database_name :database
       end
       expect(app.port).to eq 8080
     end
@@ -77,5 +112,56 @@ RSpec.describe RubyYacht::App do
 
       expect(app.container_name(project)).to eq 'tests-app1'
     end
+
+    context "with the same name as the project's system_prefix" do
+      it "is just the project's system prefix" do
+        project = RubyYacht::Project.new
+        project.name = :test_project
+        project.system_prefix = :tests
+
+        app = RubyYacht::App.new
+        app.name = :tests
+
+        expect(app.container_name(project)).to eq 'tests'
+      end
+    end
+  end
+
+  describe "database" do
+    before do
+      @project = RubyYacht::Project.new
+      @project.name = :test_project
+      @project.system_prefix = :tests
+
+      database1 = RubyYacht::Database.new
+      database1.name = 'main_db'
+      database1.host = 'localhost'
+
+      database2 = RubyYacht::Database.new
+      database2.name = 'second_db'
+      database2.host = 'db2.test.com'
+
+      @project.databases = [database1, database2]
+
+      @app = RubyYacht::App.new
+      @app.name = 'app1'
+      @app.database_name = 'second_db'
+    end
+
+    it "is the database with the app's database_name" do
+      database = @app.database(@project)
+      expect(database).not_to be_nil
+      expect(database.host).to eq 'db2.test.com'
+    end
+
+    context "with no matching database" do
+      before do
+        @project.databases.pop
+      end
+
+      it "is nil" do
+        expect(@app.database(@project)).to be_nil
+      end
+    end
   end
 end

data/spec/dsl/configuration_spec.rb

@@ -10,26 +10,28 @@ describe RubyYacht::Configuration do
     describe "fetch_hooks" do
       before do
         RubyYacht.configure do
-          app_type :test do
+          server_type :test do
+            container_type :app
             baseline_image 'ubuntu'
           end
-          app_type :php do
+          server_type :php do
+            container_type :app
             baseline_image 'ubuntu'
           end
         end
 
         RubyYacht.configure do
-          add_hooks app_type: :test, folder: '.' do
+          add_hooks server_type: :test, folder: '.' do
             before(:startup) { run_script 'a.rb' }
             before(:install_libraries) { run_script 'a.rb' }
             
             before :startup do
-              app_type :php
+              server_type :php
               run_script 'c.rb'
             end
 
             before :startup do
-              app_type :test
+              server_type :test
               run_script 'd.rb'
             end
           end
@@ -37,23 +39,30 @@ describe RubyYacht::Configuration do
       end
 
       it "returns hooks with the matching attributes" do
-        hooks = RubyYacht.configuration.fetch_hooks(app_type: :test, event_type: :startup)
+        hooks = RubyYacht.configuration.fetch_hooks(server_type: :test, event_type: :startup)
         expect(hooks.count).to eq 2
-        expect(hooks[0].script_path).to eq './a.rb'
-        expect(hooks[1].script_path).to eq './d.rb'
+        expect(hooks[0].copied_file_path).to eq './a.rb'
+        expect(hooks[1].copied_file_path).to eq './d.rb'
       end
     end
 
-    describe "find_app_type" do
+    describe "find_server_type" do
       before do
         RubyYacht.configure do
-          app_type(:generic) { baseline_image 'ubuntu' }
-          app_type(:debian) { baseline_image 'debian' }
+          server_type :generic do
+            container_type :app
+            baseline_image 'ubuntu'
+          end
+
+          server_type :debian do
+            container_type :app
+            baseline_image 'debian'
+          end
         end
       end
 
       it "returns the app type with that name" do
-        type = RubyYacht.configuration.find_app_type(:debian)
+        type = RubyYacht.configuration.find_server_type(:debian)
         expect(type.baseline_image).to eq 'debian'
       end
     end
@@ -66,33 +75,19 @@ describe RubyYacht::Configuration do
           system_prefix :a
           domain "a.test.com"
           repository "github.com"
-
-          database do
-            host "localhost"
-            name "project1"
-            username "test"
-            password "test"
-          end
         end
 
         project :project2 do
           system_prefix :b
           domain "b.test.com"
           repository "github.com"
-
-          database do
-            host "localhost"
-            name "project2"
-            username "test"
-            password "test"
-          end
         end
       end
     end
 
     let(:hook_creation_block) do
       Proc.new do
-        add_hooks app_type: :configuration_test, folder: './scripts' do
+        add_hooks server_type: :configuration_test, folder: './scripts' do
           before :startup do
             run_script 'update_config.rb'
           end
@@ -100,18 +95,20 @@ describe RubyYacht::Configuration do
       end
     end
 
-    let(:app_type_creation_block) do
+    let(:server_type_creation_block) do
       Proc.new do
-        app_type :second_configuration_test do
+        server_type :second_configuration_test do
+          container_type :app
           baseline_image 'debian'
-          app_attribute :test_attribute
+          server_attribute :test_attribute
         end
       end
     end
 
     before do
       RubyYacht.configure do
-        app_type :configuration_test do
+        server_type :configuration_test do
+          container_type :app
           baseline_image 'ubuntu'
         end
       end
@@ -129,20 +126,20 @@ describe RubyYacht::Configuration do
       expect(configuration.hooks.count).to eq 1
       expect(configuration.hooks[0].event_time).to eq :before
       expect(configuration.hooks[0].event_type).to eq :startup
-      expect(configuration.hooks[0].script_path).to eq './scripts/update_config.rb'
+      expect(configuration.hooks[0].copied_file_path).to eq './scripts/update_config.rb'
     end
 
-    it "can add types" do
-      configuration = RubyYacht::Configuration::DSL.new.run(app_type_creation_block).create_object
-      expect(configuration.app_types.count).to eq 1
-      expect(configuration.app_types[0].name).to eq :second_configuration_test
-      expect(configuration.app_types[0].project_attributes.count).to eq 0
-      expect(configuration.app_types[0].app_attributes.count).to eq 1
+    it "can server types" do
+      configuration = RubyYacht::Configuration::DSL.new.run(server_type_creation_block).create_object
+      expect(configuration.server_types.count).to eq 1
+      expect(configuration.server_types[0].name).to eq :second_configuration_test
+      expect(configuration.server_types[0].project_attributes.count).to eq 0
+      expect(configuration.server_types[0].server_attributes.count).to eq 1
     end
 
     it "can add `during` hooks" do
       configuration = RubyYacht::Configuration::DSL.new.run(Proc.new do
-        add_hooks app_type: :configuration_test, folder: './scripts' do
+        add_hooks server_type: :configuration_test, folder: './scripts' do
           during :startup do
             run_script 'start_app.rb'
           end
@@ -151,12 +148,12 @@ describe RubyYacht::Configuration do
       expect(configuration.hooks.count).to eq 1
       expect(configuration.hooks[0].event_time).to eq :during
       expect(configuration.hooks[0].event_type).to eq :startup
-      expect(configuration.hooks[0].script_path).to eq './scripts/start_app.rb'
+      expect(configuration.hooks[0].copied_file_path).to eq './scripts/start_app.rb'
     end
 
     it "can add `after` hooks" do
       configuration = RubyYacht::Configuration::DSL.new.run(Proc.new do
-        add_hooks app_type: :configuration_test, folder: './scripts' do
+        add_hooks server_type: :configuration_test, folder: './scripts' do
           after :startup do
             run_script 'start_app.rb'
           end
@@ -165,7 +162,7 @@ describe RubyYacht::Configuration do
       expect(configuration.hooks.count).to eq 1
       expect(configuration.hooks[0].event_time).to eq :after
       expect(configuration.hooks[0].event_type).to eq :startup
-      expect(configuration.hooks[0].script_path).to eq './scripts/start_app.rb'
+      expect(configuration.hooks[0].copied_file_path).to eq './scripts/start_app.rb'
     end
 
     describe "configure method" do
@@ -186,36 +183,37 @@ describe RubyYacht::Configuration do
         hook = RubyYacht::Hook.new
         hook.event_time = :after
         hook.event_type = :restart_application
-        hook.script_path = './scripts/log_success.rb'
+        hook.copied_file_path = './scripts/log_success.rb'
         RubyYacht.configuration.hooks << hook
         RubyYacht.configure(&hook_creation_block)
 
         configuration = RubyYacht.configuration
         expect(configuration.hooks.count).to eq 2
-        expect(configuration.hooks[0].script_path).to eq './scripts/log_success.rb'
-        expect(configuration.hooks[1].script_path).to eq './scripts/update_config.rb'
+        expect(configuration.hooks[0].copied_file_path).to eq './scripts/log_success.rb'
+        expect(configuration.hooks[1].copied_file_path).to eq './scripts/update_config.rb'
       end
 
-      it "adds to the list of app types" do
-        RubyYacht.configure(&app_type_creation_block)
+      it "adds to the list of server types" do
+        RubyYacht.configure(&server_type_creation_block)
 
         configuration = RubyYacht.configuration
-        expect(configuration.app_types.count).to eq 2
-        expect(configuration.app_types[0].name).to eq :configuration_test
-        expect(configuration.app_types[1].name).to eq :second_configuration_test
+        expect(configuration.server_types.count).to eq 2
+        expect(configuration.server_types[0].name).to eq :configuration_test
+        expect(configuration.server_types[1].name).to eq :second_configuration_test
       end
 
-      context "with an app type that is already registered" do
+      context "with a server type that is already registered" do
         before do
-          type = RubyYacht::AppType.new
+          type = RubyYacht::ServerType.new
           type.name = :second_configuration_test
-          RubyYacht.configuration.app_types << type
+          type.server_attributes = []
+          RubyYacht.configuration.server_types << type
         end
 
         it "raises an exception" do
           expect(lambda do
-            RubyYacht.configure(&app_type_creation_block)
-          end).to raise_exception "App type already registered: second_configuration_test"
+            RubyYacht.configure(&server_type_creation_block)
+          end).to raise_exception "Server type already registered: second_configuration_test"
         end
       end
     end

data/spec/dsl/database_spec.rb

@@ -1,61 +1,104 @@
 require 'spec_helper'
 
 describe RubyYacht::Database do
+  before do
+    RubyYacht.configuration.clear
+    RubyYacht.configure do
+      server_type :sqlite do
+        container_type :database
+        baseline_image 'ubuntu'
+      end
+    end
+  end
+
   describe "dsl" do
-    let(:database) { RubyYacht::Database::DSL.new.run(@builder).create_object }
+    let(:database) { RubyYacht::Database::DSL.new(:apps, :sqlite).run(@builder).create_object }
 
     it "creates a database with all the fields" do
       @builder = Proc.new do
         host 'db1.test.com'
-        name 'apps'
         username 'test-user'
         password 'test-pass'
+        container_label :database
       end
 
       expect(database.host).to eq 'db1.test.com'
-      expect(database.name).to eq 'apps'
+      expect(database.name).to eq :apps
+      expect(database.server_type).to eq :sqlite
       expect(database.username).to eq 'test-user'
       expect(database.password).to eq 'test-pass'
+      expect(database.container_label).to eq :database
     end
 
     it "requires the host" do
       @builder = Proc.new do
-        name 'apps'
         username 'test-user'
         password 'test-pass'
+        container_label :database
       end
 
       expect { database }.to raise_exception "Missing required attribute host for RubyYacht::Database::DSL"
     end
 
-    it "requires the name" do
+    it "requires the username" do
+      @builder = Proc.new do
+        host 'db1.test.com'
+        password 'test-pass'
+        container_label :database
+      end
+
+      expect { database }.to raise_exception "Missing required attribute username for RubyYacht::Database::DSL"
+    end
+
+    it "requires the password" do
+      @builder = Proc.new do
+        host 'db1.test.com'
+        username 'test-user'
+        container_label :database
+      end
+
+      expect { database }.to raise_exception "Missing required attribute password for RubyYacht::Database::DSL"
+    end
+
+    it "uses 'database' as the default container label" do
       @builder = Proc.new do
         host 'db1.test.com'
         username 'test-user'
         password 'test-pass'
       end
 
-      expect { database }.to raise_exception "Missing required attribute name for RubyYacht::Database::DSL"
+      expect(database.container_label).to eq :database
     end
 
-    it "requires the username" do
+    it "requires a defined server type" do
       @builder = Proc.new do
         host 'db1.test.com'
-        name 'apps'
+        username 'test-user'
         password 'test-pass'
+        container_label :database
+        server_type :invalid
       end
 
-      expect { database }.to raise_exception "Missing required attribute username for RubyYacht::Database::DSL"
+      expect { database }.to raise_exception "Database has invalid server type `invalid`"
     end
 
-    it "requires the password" do
+    it "requires a defined server type for a database" do
+      RubyYacht.configure do
+        server_type :generic do
+          container_type :app
+          baseline_image 'ruby:2.3'
+        end
+      end
+
       @builder = Proc.new do
         host 'db1.test.com'
-        name 'apps'
         username 'test-user'
+        password 'test-pass'
+        container_label :database
+        server_type :generic
       end
 
-      expect { database }.to raise_exception "Missing required attribute password for RubyYacht::Database::DSL"
+      expect { database }.to raise_exception "Database has invalid server type `generic`"
     end
   end
 
@@ -72,4 +115,19 @@ describe RubyYacht::Database do
       expect(database).not_to be_local
     end
   end
+
+  describe "container_name" do
+    before do
+      @project = RubyYacht::Project.new
+      @project.name = :test_project
+      @project.system_prefix = :tests
+
+      @database = RubyYacht::Database.new
+      @database.container_label = 'mysql'
+    end
+
+    it "combines the project's prefix with the database's container label" do
+      expect(@database.container_name(@project)).to eq 'tests-mysql'
+    end
+  end
 end