ruby_yacht 0.5.0 → 0.6.0

data/lib/ruby_yacht/dsl/hook.rb

@@ -16,20 +16,20 @@ module RubyYacht
     # The type of event that this hook is attached to.
     attr_accessor :event_type
 
-    # The type of server that this hook applies to.
-    attr_accessor :server_type
+    # The type of app server that this hook applies to.
+    attr_accessor :app_server_type
 
-    # The path to the file that we should copy into the image for this hook.
-    attr_accessor :copied_file_path
+    # The type of database server that this hook applies to.
+    attr_accessor :database_server_type
 
-    # The command that we should run for this hook.
-    attr_accessor :command
+    # The type of web server that this hook applies to.
+    attr_accessor :web_server_type
 
-    # The name of the file containing the code for this hook.
-    def copied_file_name
-      return '' unless copied_file_path
-      File.basename(copied_file_path)
-    end
+    # The type of container that this hook applies to.
+    attr_accessor :container_type
+
+    # The behaviors that we will run for this hook.
+    attr_accessor :behaviors
 
     # This class provides a DSL for configuring hooks.
     class DSL
@@ -46,59 +46,99 @@ module RubyYacht
       def initialize(event_time, event_type)
         @event_time = event_time
         @event_type = event_type
+        @behaviors = []
         load_custom_attributes
       end
 
       ##
-      # :method: server_type
+      # :method: app_server_type
       #
-      # You can call `server_type :rails` to signify that this hook applies to
-      # rails apps.
-      add_attribute :server_type
+      # You can call `app_server_type :rails` to signify that this hook applies
+      # to rails apps.
+      add_attribute :app_server_type, :all
 
       ##
-      # :method: command
+      # :method: database_server_type
       #
-      # You can call `command 'whoami'` to signify that this hook runs the
-      # command `whoami`. You can also set the command through `run_script`, if
-      # the hook runs a script file included with the plugin.
-      add_attribute :command
-      
+      # You can call `database_server_type :mysql` to signify that this hook
+      # applies to MySQL databases.
+      add_attribute :database_server_type, :all
+
       ##
-      # :method: copy_file
-      #
-      # You can call `copy_file 'foo.txt'` to signify that this hook should
-      # copy a file called `foo.txt` from the hook's script folder to
-      # `/var/docker`.
+      # :method: web_server_type
       #
-      # You can pair this with a command if you want to move it from that
-      # location in /var/docker into a custom location inside your code folder.
-      #
-      # The file copying happens at the time the image has built.
+      # You can call `web_server_type :nginx` to signify that this hook
+      # applies to nginx web servers.
+      add_attribute :web_server_type, :all
+
+      ##
+      # :method: container_type
       #
-      # When setting this attribute, you must provide another command using the
-      # `command` method.
-      add_attribute :copy_file, nil, false
+      # You can call `container_type :app` to signify that this hook applies to
+      # app images.
+      add_attribute :container_type
 
       ##
       # :method: script_folder
       #
       # You can call `script_folder './scripts'` to signify that the scripts for
       # this hook are found in the `./scripts` folder.
-      add_attribute :script_folder, nil, false
+      add_attribute :script_folder, '.'
 
-      # This method sets the name of the script containing the code for the
-      # hook.
+      # This method adds a behavior to run a command when the hook is run.
+      #
+      # ### Parameters
+      #
+      # * **cmd: String**   The command to run.
+      def command(cmd)
+        @behaviors << CommandBehavior.new(cmd)
+      end
+
+      # This method adds a behavior to copy a file to the image when the hook is
+      # run.
+      #
+      # ### Parameters
+      #
+      # * **path: String**    The path to the file, relative to the
+      #                       `script_folder`.
+      def copy_file(path)
+        @behaviors << CopyFileBehavior.new("#{@script_folder}/#{path}")
+      end
+
+      # This method adds a behavior to run a script.
       #
       # The script will be understood to be in the script folder that was given
       # when the DSL was created.
       #
       # ### Parameters
       #
-      # * **name: String**    The filename of the script.
-      def run_script(name)
-        @copy_file = name
-        @command = "/var/docker/#{name}"
+      # * **interpreter: Symbol**     The interpreter that should process the
+      #                               script. e.g. ruby or bash
+      # * **name: String**            The filename of the script.
+      def run_script(interpreter, name)
+        copy_file name
+        destination = "/var/docker/#{name}"
+        command "#{interpreter} #{destination}"
+      end
+
+      # This method adds a behavior to set an environment variable.
+      #
+      # The variable's value can be defined literally, by passing a value as the
+      # second parameter to this method, or at build-time, by passing a block.
+      #
+      # ### Parameters
+      #
+      # * **name: String**    The name of the environment variable.
+      # * **value: String**   A literal value to set for the environment
+      #                       variable.
+      # * **block: Proc**     A block for providing the environment variable.
+      def set_environment_variable(name, value=nil, &block)
+        if value
+          value_proc = Proc.new { value }
+        else
+          value_proc = block
+        end
+        @behaviors << EnvironmentVariableBehavior.new(name, value_proc)
       end
       
       # This method checks that all of the required attributes have been set on
@@ -109,18 +149,112 @@ module RubyYacht
       # This will also check that the app type is valid.
       def check_required_attributes
         super
-        unless RubyYacht.configuration.find_server_type(@server_type)
-          raise "Hook has invalid app type `#{@server_type}`"
+        if @app_server_type != :all
+          check_server_type @app_server_type, :app
+        end
+        if @database_server_type != :all
+          check_server_type @database_server_type, :database
+        end
+        if @web_server_type != :all
+          check_server_type @web_server_type, :web
         end
       end
-      
-      # This method creates a Hook object from the DSL.
-      def create_object
-        @copied_file_path = File.join(@script_folder || '.', @copy_file) if @copy_file
-        super
+
+      creates_object RubyYacht::Hook, %w(event_time event_type app_server_type
+        database_server_type web_server_type container_type behaviors)
+    end
+
+    # This class is the base class for behaviors in hooks.
+    class Behavior
+      # The command that should be run in a Dockerfile for this behavior.
+      def dockerfile_command
+        ''
       end
 
-      creates_object RubyYacht::Hook, %w(event_time event_type copied_file_path server_type command)
+      # The command that should be run in a shell script for this behavior.
+      def shell_command
+        ''
+      end
+
+      # This context in which the command is being generated.
+      attr_accessor :context
+    end
+
+    # This class provides a behavior for running a command in the image.
+    class CommandBehavior < Behavior
+      # This initializer creates the behavior.
+      #
+      # ### Parameters
+      #
+      # * **command: String**   The command to run.
+      def initialize(command)
+        @command = command
+      end
+
+      # The command that should be run in a Dockerfile for this behavior. 
+      def dockerfile_command
+        "RUN #{@command}"
+      end
+
+      # The command that should be run in a shell script for this behavior.
+      def shell_command
+        @command
+      end
+    end
+
+    # This class provides a behavior for copying a file from the host machine
+    # to the image.
+    class CopyFileBehavior < Behavior
+      # This initialize creates the behavior.
+      #
+      # ### Parameters
+      #
+      # * **file_path: String**   The path to the file, relative to the root of
+      #                           the project.
+      def initialize(file_path)
+        @file_path = file_path
+      end
+
+      # The command that should be run in a Dockerfile for this behavior.
+      def dockerfile_command
+        "COPY #{File.basename(file_path)} /var/docker/"
+      end
+
+      # :method: file_path
+      # The path to the file that this behavior copies.
+      attr_reader :file_path
+    end
+
+    # This class provides a behavior for setting an environment variable in the
+    # image.
+    class EnvironmentVariableBehavior < Behavior
+      # This initializer creates the behavior.
+      #
+      # ### Parameters
+      #
+      # * **name: String**    The name of the environment variable to create.
+      # * **proc: Proc**      The proc for generating the value for the
+      #                       environment variable.
+      def initialize(name, proc)
+        @name = name
+        @proc = proc
+        @context = self
+      end
+
+      # The value for the environment variable.
+      def value
+        context.instance_eval(&@proc)
+      end
+
+      # The command that should be run in a Dockerfile for this behavior.
+      def dockerfile_command
+        "ENV #{@name} #{value}"
+      end
+
+      # The command that should be run in a shell script for this behavior.
+      def shell_command
+        "export #{@name}=\"#{value}\""
+      end
     end
   end
 end

data/lib/ruby_yacht/dsl/project.rb

@@ -1,6 +1,7 @@
 require_relative 'dns_server'
 require_relative 'app'
 require_relative 'database'
+require_relative 'web_server'
 
 module RubyYacht
   # This class provides a configuration for a project in our system.
@@ -17,9 +18,6 @@ module RubyYacht
     # project.
     attr_accessor :system_prefix
     
-    # The domain that the apps for this project are accessed under.
-    attr_accessor :domain
-    
     # The hostname for the repository that contains the code for the apps.
     attr_accessor :repository
     
@@ -32,6 +30,10 @@ module RubyYacht
     
     # The configuration for the apps. Each entry is a RubyYacht::App.
     attr_accessor :apps
+
+    # The configuration for the web servers. Each entry is a
+    # RubyYacht::WebServer.
+    attr_accessor :web_servers
     
     # The configuration for the DNS for the apps. This is a
     # RubyYacht::DnsServer.
@@ -73,12 +75,6 @@ module RubyYacht
       # system_prefix` to `my-apps`
       add_attribute :system_prefix
       
-      ##
-      # :method: domain
-      # You can call `domain 'test.com'` to set the project's `domain` to
-      # test.com
-      add_attribute :domain
-      
       ##
       # :method: repository
       # You can call `repository 'github.com'` to set the project's `repository`
@@ -114,6 +110,14 @@ module RubyYacht
       # call methods in RubyYacht::Database::DSL
       add_object_list :database, RubyYacht::Database::DSL
       
+      ##
+      # :method: web_server
+      #
+      # You can call `web_server` to configure a web server for the project.
+      # This takes a block for configuring the server, which allows you to
+      # call methods in RubyYacht::WebServer::DSL
+      add_object_list :web_server, RubyYacht::WebServer::DSL
+      
       ##
       # :method: dns_server
       #
@@ -133,14 +137,16 @@ module RubyYacht
       # method on the DSL that builds an app with the type `foo`.
       def load_app_initializers
         RubyYacht.configuration.server_types.each do |server_type|
-          method_name = "#{server_type.name}_#{server_type.container_type}"
-          define_singleton_method method_name do |name, &block|
+          main_method = server_type.container_type.to_s
+          main_method += "_server" if server_type.container_type == :web
+          method_name = "#{server_type.name}_#{main_method}"
+          define_singleton_method method_name do |*args, &block|
             self.public_send(
-              server_type.container_type,
-              name,
+              main_method,
               server_type.name,
+              *args,
               &block
-            )
+            ) 
           end
         end
       end

data/lib/ruby_yacht/dsl/server_type.rb

@@ -40,23 +40,16 @@ module RubyYacht
     # it will be called `rails_environment` on the server's DSL. This prevents
     # conflicts with attributes from other plugins.
     attr_accessor :server_attributes
+    
+    # The default values for the servers with this server type.
+    #
+    # Each entry will be a hash where the keys are the names of attributes, and
+    # the values are the default values.
+    attr_accessor :server_defaults
 
     # The docker image that we use as the source for the server images.
     attr_accessor :baseline_image
 
-    # The custom environment variables that we set in the images for this server
-    # type.
-    #
-    # Each entry will be a hash with the following keys:
-    #
-    # * **name: String**    The name of the environment variable
-    # * **image: String**   The type of image that this is set in (e.g. server
-    #                       or database).
-    # * **block**           A block that will be called inside the Dockerfile
-    #                       ERB for providing the value of the environment
-    #                       variable.
-    attr_accessor :environment_variables
-
     # This class provides a DSL for configuring a RubyYacht::ServerType.
     class DSL
       include RubyYacht::DSL::Base
@@ -69,7 +62,6 @@ module RubyYacht
       # * **name: Symbol**    The name of the server type.
       def initialize(name)
         @name = name
-        @environment_variables = []
         load_custom_attributes
       end
 
@@ -96,27 +88,18 @@ module RubyYacht
       #
       # :method: server_attribute
       # You can call `server_attribute name: :environment, default: 'staging'`
-      # to add an attribute to the app DSL.
+      # to add an attribute to the server DSL.
       add_list :server_attribute
 
+      #
+      # :method: server_default
+      # You can call `server_default port: 3306` to specify that the servers
+      # should have a default value of 3306 for the `port` attribute.
+      add_list :server_default
+
       creates_object RubyYacht::ServerType, [:name, :baseline_image,
         :container_type, :project_attributes, :server_attributes,
-        :environment_variables]
-
-      # This method defines a new environment variable set for this app type.
-      #
-      # ### Parameters
-      #
-      # * **image: Symbol**   The type of image this environment variable is set
-      #                       for.
-      # * **name: String**    The name of the environment variable.
-      # * **block**           A block for generating the environment variable.
-      #                       This will have access to the project (as @project)
-      #                       and the server (as @server) that we are building
-      #                       the image for.
-      def environment_variable(image, name, &block)
-        @environment_variables << {image: image, name: name, block: block}
-      end
+        :server_defaults]
     end
   end
 end

data/lib/ruby_yacht/dsl/web_server.rb

@@ -0,0 +1,87 @@
+module RubyYacht
+  # This class models a web server that's part of the local system.
+  #
+  # See RubyYacht::WebServer::DSL for information on configuring the server.
+  class WebServer
+    # The name of the server
+    attr_accessor :name
+
+    # The domain that this web server listens on.
+    attr_accessor :domain
+
+    # The port that this web server listens on.
+    attr_accessor :port
+
+    # The name of the web server plugin for this server.
+    attr_accessor :server_type
+
+    # The project that includes this web server.
+    def project
+      RubyYacht.configuration.projects.find { |project| project.web_servers.include?(self) }
+    end
+
+    # This method gets the name of the image / container that this server will
+    # run in.
+    def container_name
+      project = self.project
+      return "#{project.system_prefix}-#{self.name}"
+    end
+    
+    # This class provide's the DSL for configuring a web server.
+    #
+    # Inside of the project configuration, you can call `web_server [name]` to
+    # add a web server, and then pass it a block to configure the server, which
+    # will allow you to call these DSL methods.
+    #
+    # You can also call `web_server` with no argument, which will give it the
+    # name `web`.
+    class DSL
+      include RubyYacht::DSL::Base
+      extend RubyYacht::DSL::Base::ClassMethods
+      
+      # This initializer starts the DSL for the server.
+      #
+      # ### Parameters
+      #
+      # * **server_type: Symbol**   The type of server this is.
+      # * **name: String**          The name of the server.
+      def initialize(server_type, name=:web)
+        @server_type = server_type
+        @name = name.to_sym
+        load_custom_attributes
+      end
+      
+      add_attribute :name
+      
+      ##
+      # :method: domain
+      # You can call `domain 'test.com'` to tell the web server to create
+      # subdomains under test.com.
+      add_attribute :domain
+      
+      ##
+      # :method: server_type
+      # You can call `server_type :foo` to set the app's `server_type`.
+      add_attribute :server_type
+      
+      ##
+      # :method: port
+      # You can call `port 8080` to set the server's `port`. It defaults to 80.
+      add_attribute :port, 80
+
+      creates_object WebServer
+      
+      # This method checks that all of the required attributes have been set on
+      # the object.
+      #
+      # If they haven't, this will raise an exception.
+      #
+      # It also checks that the server type has been defined in the
+      # configuration.
+      def check_required_attributes
+        super
+        check_server_type @server_type, :web
+      end
+    end
+  end
+end

data/lib/ruby_yacht/dsl.rb

@@ -3,6 +3,7 @@ require 'ruby_yacht/dsl/configuration'
 require 'ruby_yacht/dsl/project'
 require 'ruby_yacht/dsl/app'
 require 'ruby_yacht/dsl/database'
+require 'ruby_yacht/dsl/web_server'
 require 'ruby_yacht/dsl/dns_server'
 require 'ruby_yacht/dsl/hook'
 require 'ruby_yacht/dsl/server_type'

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

@@ -1,18 +1,20 @@
 FROM <%= @project.system_prefix %>-<%= @app.server_type %>-app-dependencies
 
-<% database = @app.database(@project) %>
+<% database = @app.database %>
 <% if database %>
-ENV DATABASE_HOST <%= database.local? ? database.container_name(@project) : database.host %>
+ENV DATABASE_HOST <%= database.local? ? database.container_name : database.host %>
 ENV DATABASE_NAME <%= database.name %>
 ENV DATABASE_PASSWORD <%= database.password %>
 ENV DATABASE_USERNAME <%= database.username %>
 ENV DATABASE_TYPE <%= database.server_type %>
+ENV DATABASE_PORT <%= database.port %>
 <% end %>
 ENV APP_PORT <%= @app.port %>
 ENV REPOSITORY_HOST <%= @project.repository %>
-ENV REPOSITORY_NAME <%= @app.repository_name %>
 ENV SYSTEM_PREFIX <%= @project.system_prefix %>
-<%= include_environment_variables :app %>
+<% if @app.repository_name %>
+ENV REPOSITORY_NAME <%= @app.repository_name %>
+<% end %>
 
 RUN rm -r /var/code
 RUN mkdir -p /var/code
@@ -20,11 +22,20 @@ RUN mkdir -p /var/code
 COPY checkout.bash /var/docker/checkout.bash
 COPY before_startup.bash /var/docker/before_startup.bash
 COPY startup.bash /var/docker/startup.bash
-<%= copy_hooks [:startup, :build_checkout] %>
+<%= copy_hooks @app, [:startup] %>
+<% if @app.repository_name == nil %>
+<%= copy_hooks @app, [:build_new_app] %>
+<% end %>
 
 RUN chmod u+x /var/docker/*
 
-<%= include_event(:build_checkout) { "RUN /var/docker/checkout.bash\nWORKDIR /var/code"} %>
+WORKDIR /var/code
+
+<% if @app.repository_name %>
+<%= include_event(@app, :build_checkout) { "RUN /var/docker/checkout.bash" } %>
+<% else %>
+<%= include_event(@app, :build_new_app) %>
+<% end %>
 
 EXPOSE <%= @app.port %>
 

data/lib/ruby_yacht/images/app/before_startup.bash.erb

@@ -1,6 +1,8 @@
 #! /bin/bash
 
-cd /var/code;
-/var/docker/checkout.bash;
+cd /var/code
+<% if @app.repository_name %>
+/var/docker/checkout.bash
+<% end %>
 
-<%= include_event :startup, :before, in_bash: true %>
+<%= include_event @app, :startup, :before, in_bash: true %>

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

@@ -1,3 +1,6 @@
 #! /bin/bash
-/var/docker/before_startup.bash;
-<%= include_event :startup, [:during, :after], in_bash: true %>
+<% if @app.repository_name == nil %>
+<%= include_event @app, :build_new_app, [:before, :during, :after], in_bash: true %>
+<% end %>
+/var/docker/before_startup.bash
+<%= include_event @app, :startup, [:during, :after], in_bash: true %>

data/lib/ruby_yacht/images/app-dependencies/Dockerfile.erb

@@ -6,30 +6,26 @@
 
 FROM <%= @server_type.baseline_image %>
 
-<%= include_environment_variables :app_dependencies %>
+<%= include_event @project.apps, :initialize_app_environment %>
 
 RUN mkdir -p /root/.ssh
 COPY id_rsa /root/.ssh
 RUN ssh-keyscan <%= @project.repository %> >> /root/.ssh/known_hosts
 
 RUN mkdir -p /var/docker/
-RUN touch /var/docker/.keep
+RUN mkdir -p /var/code/
 
-<%= copy_hooks [:install_libraries] %>
-
-RUN chmod u+x /var/docker/*
+RUN apt-get update && apt-get upgrade -y
 
 <% @project.apps.each do |app| %>
 <% next unless app.server_type == @server_type.name %>
+<% next unless app.repository_name %>
 
 RUN git clone git@<%= @project.repository %>:<%= app.repository_name %> /var/code/<%= app.name %>
 WORKDIR /var/code/<%= app.name %>
-<%= include_event :install_libraries %>
+<%= include_event app, :install_libraries %>
 <% end %>
 
-RUN rm /var/docker/*
+RUN rm -f /var/docker/*
 
-WORKDIR /
-
-RUN apt-get update && apt-get upgrade -y
-RUN apt-get install -y mysql-client
+WORKDIR /