ruby_yacht 0.5.0 → 0.6.0

data/lib/ruby_yacht/images/database/Dockerfile.erb

@@ -4,36 +4,25 @@ ENV DATABASE_USERNAME <%= @database.username %>
 ENV DATABASE_PASSWORD <%= @database.password %>
 ENV DATABASE_NAME <%= @database.name %>
 ENV DATABASE_TYPE <%= @database.server_type %>
-<%= include_environment_variables :database %>
-<% with_each_app_type do %>
-<%= include_environment_variables :database %>
-<% end %>
 
 COPY checkout.bash /var/docker/checkout.bash
 COPY startup.bash /var/docker/startup.bash
-<%= copy_hooks [:install_libraries, :create_databases, :startup] %>
-<% with_each_app_type do %>
-<%= copy_hooks [:load_database_seeds] %>
-<% end %>
+<%= copy_hooks @database, [:startup] %>
 
 RUN chmod u+x /var/docker/*
 
-<%= include_event :install_libraries %>
+<%= include_event @database, :install_libraries %>
 
-<%= include_event :create_databases %>
+<%= include_event @database, :create_databases %>
 
-<% original_server_type = @server_type %>
-<% apps = @project.apps.select { |app| app.database_name == @database.name } %>
-<% apps.each do |app| %>
-<% @server_type = RubyYacht.configuration.find_server_type(app.server_type) %>
+<% @database.apps.each do |app| %>
 
+<% next unless app.repository_name %>
 RUN /var/docker/checkout.bash <%= @project.repository %> <%= app.name %> <%= app.repository_name %>
 WORKDIR /var/code/<%= app.name %>
-<%= include_event :load_database_seeds %>
+<%= include_event @database, :load_database_seeds %>
 <% end %>
 
-<% @server_type = original_server_type %>
-
 RUN rm -r /var/code
 WORKDIR /
 
@@ -41,6 +30,6 @@ ENV DATABASE_USERNAME ''
 ENV DATABASE_PASSWORD ''
 ENV DATABASE_NAME ''
 
-EXPOSE 3306
+EXPOSE <%= @database.port %>
 
 CMD /var/docker/startup.bash

data/lib/ruby_yacht/images/database/startup.bash.erb

@@ -1,3 +1,3 @@
 #! /bin/bash
 
-<%= include_event :startup, [:before, :during], in_bash: true %>
+<%= include_event @database, :startup, [:before, :during], in_bash: true %>

data/lib/ruby_yacht/images/web/Dockerfile.erb

@@ -2,31 +2,37 @@ FROM nginx
 
 RUN apt-get update
 RUN apt-get upgrade -y
-RUN apt-get install -y ruby
+<%= include_event @server, :install_libraries %>
 
 RUN mkdir -p /var/docker
 
-COPY add_project.rb /var/docker/add_project.rb
-COPY add_app.rb /var/docker/add_app.rb
-COPY index.html.erb /var/docker/index.html.erb
-COPY index_config.erb /var/docker/index_config.erb
-COPY app_config.erb /var/docker/app_config.erb
-
-<% @projects.each do |project| %>
-<% primary_app = project.primary_app %>
-<% if project.apps.any? { |app| app.name == project.system_prefix } %>
-<% primary_app = project.system_prefix %>
+<% primary_app = @project.primary_app %>
+<% if @project.apps.any? { |app| app.name == @project.system_prefix } %>
+<% primary_app = @project.system_prefix %>
 <% end %>
-<% if primary_app == nil %>
-<% app_list = project.apps.map(&:name).join(',') %>
 
-RUN ruby /var/docker/add_project.rb <%= project.system_prefix %> <%= project.domain %> <%= app_list %>
-<% end %>
-<% project.apps.each do |app| %>
-RUN ruby /var/docker/add_app.rb <%= project.system_prefix %> <%= project.domain %> <%= app.name %> <%= app.port %> <%= app.name == primary_app %>
+ENV PROJECT <%= @project.system_prefix %>
+ENV DOMAIN <%= @server.domain %>
+
+<% if primary_app == nil %>
+<% app_list = @project.apps.map(&:name).join(',') %>
+ENV APP_LIST <%= app_list %>
+<%= include_event @server, :add_project_landing %>
 <% end %>
+
+<% @project.apps.each do |app| %>
+
+ENV APP_NAME <%= app.name %>
+ENV APP_PORT <%= app.port %>
+ENV APP_PRIMARY <%= app.name == primary_app %>
+<%= include_event @server, :add_app_config %>
 <% end %>
 
 RUN rm -r /var/docker
-RUN apt-get remove -y ruby
-RUN apt-get autoremove -y
+
+ENV PROJECT ""
+ENV DOMAIN ""
+ENV APP_LIST ""
+ENV APP_NAME ""
+ENV APP_PORT ""
+ENV APP_PRIMARY ""

data/lib/ruby_yacht/plugins/mysql.rb

@@ -7,18 +7,28 @@ module RubyYacht::Plugins
         server_type :mysql do
           container_type :database
           baseline_image 'mysql'
-
-          environment_variable :database, 'DEBIAN_FRONTEND' do
-            'noninteractive'
-          end
+          server_default port: 3306
         end
       end
 
       RubyYacht.configure do
-        add_hooks(server_type: :mysql, folder: File.join(File.dirname(__FILE__), 'mysql', 'scripts')) do
-          during(:install_libraries) { command 'apt-get install -y mysql-server' }
-          during(:create_databases) { run_script 'setup.bash' }
-          during(:startup) { command 'mysqld_safe --bind-address=0.0.0.0' }
+        add_hooks(database_server_type: :mysql, container_type: :database, script_folder: File.join(File.dirname(__FILE__), 'mysql', 'scripts')) do
+          during(:install_libraries) do
+            set_environment_variable 'DEBIAN_FRONTEND', 'noninteractive'
+            command 'apt-get install -y mysql-server'
+          end
+          during(:create_databases) { run_script :bash, 'setup.bash' }
+
+          before(:startup) do
+            set_environment_variable('MYSQL_PORT') { @database.port }
+          end
+          
+          during(:startup) { command 'mysqld_safe --bind-address=0.0.0.0 --port=$MYSQL_PORT' }
+
+          during :install_libraries do
+            container_type :app
+            command 'apt-get install -y mysql-client'
+          end
         end
       end
     end

data/lib/ruby_yacht/{images/web → plugins/nginx/scripts}/add_app.rb

@@ -1,10 +1,10 @@
 #! /usr/local/bin/ruby
 require 'erb'
 
-@project = ARGV.shift
-@domain = ARGV.shift
-@app = ARGV.shift
-@port = ARGV.shift
+@project = ENV['PROJECT']
+@domain = ENV['DOMAIN']
+@app = ENV['APP_NAME']
+@port = ENV['APP_PORT']
 
 if @project == @app
   @container_name = @project
@@ -12,7 +12,7 @@ else
   @container_name = "#{@project}-#{@app}"
 end
 
-@is_primary_app = ARGV.shift == 'true'
+@is_primary_app = ENV['APP_PRIMARY'] == 'true'
 
 File.open(File.join("/etc/nginx/conf.d/#{@container_name}.conf"), 'w') do |file|
   file.write(ERB.new(File.read('/var/docker/app_config.erb')).result(binding))

data/lib/ruby_yacht/{images/web → plugins/nginx/scripts}/add_project.rb

@@ -1,9 +1,9 @@
 #! /usr/local/bin/ruby
 require 'erb'
 
-@project = ARGV.shift
-@domain = ARGV.shift
-@app_names = ARGV.shift.split(',')
+@project = ENV['PROJECT']
+@domain = ENV['DOMAIN']
+@app_names = ENV['APP_LIST'].split(',')
 
 File.open(File.join("/usr/share/nginx/html/#{@project}.html"), 'w') do |file|
   file.write(ERB.new(File.read('/var/docker/index.html.erb')).result(binding))

data/lib/ruby_yacht/plugins/nginx.rb

@@ -0,0 +1,28 @@
+module RubyYacht::Plugins
+  # This module provides the plugin for managing nginx web servers.
+  module Nginx
+    # This method loads the configuration for the nginx plugin.
+    def self.load
+      RubyYacht.configure do
+        server_type :nginx do
+          container_type :web
+          baseline_image 'nginx'
+        end
+      end
+
+      RubyYacht.configure do
+        add_hooks container_type: :web, web_server_type: :nginx, script_folder: File.join(File.dirname(__FILE__), 'nginx', 'scripts') do
+          during(:install_libraries) { command 'apt-get install -y ruby' }
+          during(:install_libraries) { copy_file 'index.html.erb' }
+          during(:install_libraries) { copy_file 'index_config.erb' }
+          during(:install_libraries) { copy_file 'app_config.erb' }
+
+          during(:add_project_landing) { run_script :ruby, 'add_project.rb' }
+          during(:add_app_config) { run_script :ruby, 'add_app.rb' }
+        end
+      end
+    end
+  end
+end
+
+RubyYacht::Plugins::Nginx.load

data/lib/ruby_yacht/plugins/rails/scripts/build_new_app.rb

@@ -0,0 +1,10 @@
+#! /usr/local/bin/ruby
+
+if `which rails` == ''
+  system "gem install rails"
+end
+
+unless File.exist?('/var/code/Gemfile')
+  system "rails new /var/code"
+  system "sed -e \"s/# gem 'therubyracer'/gem 'therubyracer'/\" -i Gemfile"
+end

data/lib/ruby_yacht/plugins/rails/scripts/update_rails_config.rb

@@ -2,6 +2,10 @@
 require 'yaml'
 
 database_host = ENV['DATABASE_HOST']
+
+if database_host == nil
+  exit(0)
+end
   
 common_config = {
   'adapter' => 'mysql2',
@@ -9,7 +13,8 @@ common_config = {
   'password' => ENV['DATABASE_PASSWORD'],
   'reconnect' => true,
   'host' => database_host,
-  'database' => ENV['DATABASE_NAME']
+  'database' => ENV['DATABASE_NAME'],
+  'port' => ENV['DATABASE_PORT']
 }
 
 database_config = {

data/lib/ruby_yacht/plugins/rails.rb

@@ -3,6 +3,12 @@ module RubyYacht::Plugins
   module Rails
     # This method loads the configuration for the Rails plugin.
     def self.load
+      load_server_type
+      load_hooks
+    end
+
+    # This method loads the configuration for the Rails server type.
+    def self.load_server_type
       RubyYacht.configure do
         server_type :rails do
           container_type :app
@@ -10,33 +16,42 @@ module RubyYacht::Plugins
           project_attribute name: :environment, default: 'development'
           project_attribute name: :excluded_gem_groups, default: []
           project_attribute name: :secret_key_base
-
-          environment_variable :app_dependencies, 'RAILS_ENV' do
-            @project.rails_environment
-          end
-
-          environment_variable :app, 'SECRET_KEY_BASE' do
-            @project.rails_secret_key_base
-          end
-          
-          environment_variable :app_dependencies, 'EXCLUDED_GEM_GROUPS' do
-            groups = @project.rails_excluded_gem_groups.join(' ')
-            groups = '""' if groups == ''
-            groups
-          end
         end
       end
+    end
 
+    # This method loads the configuration for the Rails hooks.
+    def self.load_hooks
       RubyYacht.configure do
-        add_hooks(server_type: :rails, folder: File.join(File.dirname(__FILE__), 'rails', 'scripts')) do
-          during(:install_libraries) { run_script 'install_gems.rb' }
+        add_hooks(app_server_type: :rails, container_type: :app, script_folder: File.join(File.dirname(__FILE__), 'rails', 'scripts')) do
+          during :initialize_app_environment do
+            set_environment_variable 'RAILS_ENV' do
+              @project.rails_environment
+            end
+            set_environment_variable 'SECRET_KEY_BASE' do
+              @project.rails_secret_key_base
+            end
+            set_environment_variable 'EXCLUDED_GEM_GROUPS' do
+              groups = @project.rails_excluded_gem_groups.join(' ')
+              groups = '""' if groups == ''
+              groups
+            end
+          end
+          during(:install_libraries) { run_script :ruby, 'install_gems.rb' }
           
           after(:build_checkout) { command 'bundle install --clean' }
           
-          during(:load_database_seeds) { run_script 'load_seeds.rb' }
+          during :load_database_seeds do
+            container_type :database
+            run_script :ruby, 'load_seeds.rb'
+          end
+          
+          during :build_new_app do
+            run_script :ruby, 'build_new_app.rb'
+          end
 
-          before(:startup) { run_script 'update_rails_config.rb' }
-          before(:startup) { run_script 'prepare_rails_for_launch.rb' }
+          before(:startup) { run_script :ruby, 'update_rails_config.rb' }
+          before(:startup) { run_script :ruby, 'prepare_rails_for_launch.rb' }
 
           during(:startup) { command 'rails s -b 0.0.0.0 -p $APP_PORT -e $RAILS_ENV' }
         end

data/lib/ruby_yacht/plugins.rb

@@ -4,4 +4,5 @@ module RubyYacht
   end
 end
 require 'ruby_yacht/plugins/rails'
-require 'ruby_yacht/plugins/mysql'
+require 'ruby_yacht/plugins/mysql'
+require 'ruby_yacht/plugins/nginx'

data/lib/ruby_yacht/runner/build_images.rb

@@ -20,36 +20,48 @@ module RubyYacht::Runner
       
       projects.each do |project|
         log "Building images for #{project.name}"
-        @project = project
         
         id_path = File.join(ENV['HOME'], '.ssh', 'id_rsa')
         tmp_id_path = File.join('tmp', 'id_rsa')
         FileUtils.cp(id_path, tmp_id_path) if File.exist?(id_path)
+
+        build_images(project)
+      end
       
-        project.apps.map(&:server_type).uniq.each do |type_name|
-          @server_type = RubyYacht.configuration.find_server_type(type_name)
-          build_image 'app-dependencies', "#{@project.system_prefix}-#{@server_type.name}-app-dependencies"
-        end
-        
-        @app_server_type = RubyYacht.configuration.find_server_type(project.apps.first.server_type)
-        project.databases.select(&:local?).each do |database|
-          @database = database
-          @server_type = RubyYacht.configuration.find_server_type(@database.server_type)
-          build_image 'database', @database.container_name(@project)
-        end
-        
-        @project.apps.each do |app|
-          @app = app
-          @server_type = RubyYacht.configuration.find_server_type(@app.server_type)
-          build_image 'app', @app.container_name(@project)
-        end
-        @app = nil
+      true
+    end
+
+    # This method builds the images for a project.
+    #
+    # ### Parameters
+    #
+    # * **project: Project**    The project we are building.
+    def build_images(project)
+      @project = project
+      project.apps.map(&:server_type).uniq.each do |type_name|
+        @server_type = RubyYacht.configuration.find_server_type(type_name)
+        build_image 'app-dependencies', "#{@project.system_prefix}-#{@server_type.name}-app-dependencies"
       end
       
-      @projects = projects
-      build_image 'web', "#{default_system_prefix}-web"
+      @app_server_type = RubyYacht.configuration.find_server_type(project.apps.first.server_type)
+      project.databases.select(&:local?).each do |database|
+        @database = database
+        @server_type = RubyYacht.configuration.find_server_type(@database.server_type)
+        build_image 'database', @database.container_name
+      end
+      @database = nil
       
-      true
+      @project.apps.each do |app|
+        @app = app
+        @server_type = RubyYacht.configuration.find_server_type(@app.server_type)
+        build_image 'app', @app.container_name
+      end
+      @app = nil
+
+      project.web_servers.each do |server|
+        @server = server
+        build_image 'web', @server.container_name
+      end
     end
     
     # This method builds an image.
@@ -79,13 +91,9 @@ module RubyYacht::Runner
 
       set_image_settings(folder_name)
 
-      @hook_events.each do |event|
-        @server_types.each do |server_type|
-          RubyYacht.configuration.fetch_hooks(server_type: server_type, event_type: event).each do |hook|
-            next unless hook.copied_file_path
-            FileUtils.cp hook.copied_file_path, "tmp"
-          end
-        end
+      fetch_behaviors(@hook_servers, @hook_events).each do |behavior|
+        next unless behavior.is_a?(RubyYacht::Hook::CopyFileBehavior)
+        FileUtils.cp behavior.file_path, "tmp"
       end
 
       @templates.each do |template_name|
@@ -107,7 +115,7 @@ module RubyYacht::Runner
 
     # This method establishes settings for building an image.
     #
-    # This will set the `@templates`, `@hook_events`, and `@server_types`
+    # This will set the `@templates`, `@hook_events`, and `@hook_servers`
     # instance variables.
     #
     # ### Parameters
@@ -119,21 +127,26 @@ module RubyYacht::Runner
         case folder_name
         when 'app' then ['Dockerfile', 'before_startup.bash', 'startup.bash']
         when 'database' then ['Dockerfile', 'startup.bash']
+        when 'web' then ['Dockerfile']
         else ['Dockerfile']
         end
 
       @hook_events =
         case folder_name
-        when 'app' then [:startup, :build_checkout]
-        when 'app-dependencies' then [:install_libraries]
+        when 'app' then [:startup, :build_checkout, :build_new_app]
+        when 'app-dependencies' then [:initialize_app_environment, :install_libraries]
         when 'database' then [:create_databases, :install_libraries, :load_database_seeds]
+        when 'web' then [:install_libraries, :add_project_landing, :add_app_config]
         else []
         end
         
-      @server_types =
+      @hook_servers =
         case folder_name
-        when 'database' then [@server_type.name] + @project.apps.map(&:server_type).uniq
-        else [@server_type.name]
+        when 'database' then [@database]
+        when 'app' then [@app]
+        when 'app-dependencies' then @project.apps
+        when 'web' then [@server]
+        else []
         end
     end
 
@@ -145,6 +158,8 @@ module RubyYacht::Runner
     #
     # ### Parameters
     #
+    # * **servers: Database/App/Array**:    The server or servers whose hooks we
+    #                                       are running.
     # * **event_type: Symbol**      The event whose hooks we are running.
     # * **times: [Symbol]**         The event times whose hooks we want to
     #                               include. You can also pass a symbol to this
@@ -161,7 +176,7 @@ module RubyYacht::Runner
     # ### Returns
     #
     # A String with the contents of the Dockerfile for running the hooks.
-    def include_event(event_type, times = [:before, :during, :after], options = {})
+    def include_event(servers, event_type, times = [:before, :during, :after], options = {})
       result = ""
       if times.is_a?(Symbol)
         times = [times]
@@ -172,11 +187,13 @@ module RubyYacht::Runner
           result += "\n"
           next
         end
-        RubyYacht.configuration.fetch_hooks(server_type: @server_type.name, event_type: event_type, event_time: time).each do |hook|
+        
+        fetch_behaviors(servers, [event_type], time).each do |behavior|
+          behavior.context = self
           if options[:in_bash]
-            result += "#{hook.command};\n"
+            result += "#{behavior.shell_command}\n"
           else
-            result += "RUN #{hook.command}\n"
+            result += "#{behavior.dockerfile_command}\n"
           end
         end
       end
@@ -184,56 +201,53 @@ module RubyYacht::Runner
       result
     end
 
-    # This method includes the app environment variables for the current app
-    # type.
-    #
-    # ### Parameters
-    #
-    # * **image_type: Symbol**    The image type that we're building. This can
-    #                             be `app_dependencies`, `app`, or `database`.
-    #
-    # ### Returns
-    #
-    # A String with the contents of the Dockerfile for adding the environment
-    # variables.
-    def include_environment_variables(image_type)
-      result = ""
-      @server_type.environment_variables.select { |variable| variable[:image] == image_type }.each do |variable|
-        result += "ENV #{variable[:name]} #{instance_eval(&variable[:block])}\n"
-      end
-      result
-    end
-
     # This method includes commands for copying script files for the hooks for
     # the current app type.
     #
     # ### Parameters
     #
+    #
+    # * **servers: Database/App/Array**:    The server or servers whose hooks we
+    #                                       are running.
     # * **event_types: [Symbol]**     The events whose hooks we should include.
     #
     # ### Returns
     #
     # A String with the contents of the Dockerfile for copying the script.
-    def copy_hooks(event_types)
+    def copy_hooks(servers, event_types)
       result = ""
-      RubyYacht.configuration.fetch_hooks(server_type: @server_type.name).each do |hook|
-        next if hook.copied_file_name == ''
-        next unless event_types.include?(hook.event_type)
-        result += "COPY #{hook.copied_file_name} /var/docker/#{hook.copied_file_name}\n"
+      
+      fetch_behaviors(servers, event_types).each do |behavior|
+        next unless behavior.is_a?(RubyYacht::Hook::CopyFileBehavior)
+        result += behavior.dockerfile_command + "\n"
       end
       result
     end
 
-    # This method goes through all the app types for the apps in the project,
-    # sets each one as the `@server_type` instance variable, and then yields to the
-    # block passed to the method.
-    def with_each_app_type
-      original_server_type = @server_type
-      @project.apps.map(&:server_type).uniq.each do |server_type|
-        @server_type = RubyYacht.configuration.find_server_type(server_type)
-        yield
+    private
+
+    # This method fetches the behaviors for the hooks for an event.
+    #
+    #
+    # * **servers: Database/App/Array**:    The server or servers whose hooks we
+    #                                       are running.
+    # * **event_types: Array**:     The events for the hooks we are running.
+    # * **event_time: Symbol**:     The time relative to the event for the hooks
+    #                               we are running. If this is nil, it will
+    #                               include all event times.
+    def fetch_behaviors(servers, event_types, event_time = nil)
+      unless servers.is_a?(Array)
+        servers = [servers]
+      end
+      hooks = servers.collect do |server|
+        event_types.collect do |type|
+          RubyYacht.configuration.fetch_hooks(server, type)
+        end
+      end.flatten.uniq
+      hooks = hooks.select do |hook|
+        event_time.nil? || event_time == hook.event_time
       end
-      @server_type = original_server_type
+      hooks.map(&:behaviors).flatten
     end
   end
 end

data/lib/ruby_yacht/runner/checkout.rb

@@ -57,7 +57,7 @@ module RubyYacht::Runner
       return false unless project
 
       app = project.apps.find { |a| a.name == app_name.to_sym }
-      container_name = app.container_name(project)
+      container_name = app.container_name
       
       docker "exec #{container_name} bash -c 'cd /var/code; git fetch; git checkout .; git checkout #{branch}; git pull'"
       docker "exec #{container_name} /var/docker/before_startup.bash"

data/lib/ruby_yacht/runner/command.rb

@@ -111,7 +111,19 @@ module RubyYacht::Runner
     # ### Returns
     # The response from docker-machine.
     def get_machine_info(property)
-      backtick("docker-machine inspect default -f {{#{property}}}").strip
+      return '' if docker_machine == ''
+      backtick("#{docker_machine} inspect default -f {{#{property}}}").strip
+    end
+
+    # This method gets the path to the docker-machine binary.
+    #
+    # If docker-machine is not installed or is disabled, this will be blank.
+    #
+    # ### Returns
+    # String
+    def docker_machine
+      return '' if RubyYacht.configuration.disable_docker_machine
+      backtick('which docker-machine').strip
     end
     
     # Stubbing