ruby_yacht 0.5.0 → 0.6.0

data/doc/plugins.md

@@ -29,8 +29,8 @@ You can add the following fields to fill out the server type:
   <tr>
     <td>container_type</td>
     <td>
-      The type of container that this server type applies to. This can be either
-      `app` or `database`.
+      The type of container that this server type applies to. This can be `app`,
+      `database`, or `web`.
     </td>
     <td>
       <code>container_type :app</code>
@@ -45,7 +45,8 @@ You can add the following fields to fill out the server type:
         these servers.
       </p>
       <p>
-        This is currently only used for the app images.
+        This is currently ignored for database images, since those are built off
+        of the app dependencies image.
       </p>
     </td>
     <td>
@@ -91,34 +92,23 @@ You can add the following fields to fill out the server type:
     <td>None; no custom server attributes</td>
   </tr>
   <tr>
-  <td>environment_variable</td>
-  <td>
-    <p>
-      A custom environment variable that is set in an image for this plugin.
-    </p>
-    <p>
-      This accepts two parameters (image and name), as well as a block. The
-      image is the type of image this is set on: app, app_dependencies, or
-      database. The block provides a value for the variable. The block will
-      have access to the context of the image we're building, as 
-      <code>@project</code>, <code>@app</code>, and <code>@database</code>.
-    </p>
-    <p>
-      An app type plugin can also provide custom environment variable for a
-      database server.
-    </p>
-    <p>
-      You can call this multiple times to define multiple environment variables.
-    </p>
-  </td>
-  <td>
-    <code>
-      environment_variable :app_dependencies, 'RAILS_ENV' do
-        @project.rails_environment
-      end
-    </code>
-  </td>
-  <td>None; no custom environment variables.</td>
+    <td>server_default</td>
+    <td>
+      <p>
+        This defines a default value for an existing attribute on servers of
+        this type.
+      </p>
+      <p>
+        This accepts hash of options. The keys in this hash are the names of the
+        attributes, and the values are the default values.
+      </p>
+      <p>
+        You can call this multiple times, and it will add the new defaults to
+        the list.
+      </p>
+    </td>
+    <td><code>server_default port: 3000</code></td>
+    <td>None; no custom default values.</td>
   </tr>
 </table>
 
@@ -151,9 +141,22 @@ These are the event types that you can hook into:
       The code for an app is being checked out when building an app image.
     </td>
   </tr>
+  <tr>
+    <td>build_new_app</td>
+    <td>
+      An app is being created from scratch rather than checked out from a
+      repository.
+    </td>
+  </tr>
   <tr>
     <td>install_libraries</td>
-    <td>The libraries for an app or database server are being installed.</td>
+    <td>The libraries for a server are being installed.</td>
+  </tr>
+  <tr>
+    <td>initialize_app_environment</td>
+    <td>
+      The envrionment variables for the app-dependencies image are being set.
+    </td>
   </tr>
   <tr>
     <td>create_databases</td>
@@ -163,6 +166,17 @@ These are the event types that you can hook into:
     <td>load_database_seeds</td>
     <td>The seed data for the app is being loaded on the database server.</td>
   </tr>
+  <tr>
+    <td>add_project_landing</td>
+    <td>
+      We are adding the configuration for a project's landing page to a web
+      server.
+    </td>
+  </tr>
+  <tr>
+    <td>add_app_config</td>
+    <td>We are adding the configuration for a single app to a web server.</td>
+  </tr>
 </table>
 
 ### Fields
@@ -177,20 +191,29 @@ The hook DSL allows you to set the following fields:
     <th>Default</th>
   </tr>
   <tr>
-    <td>server_type</td>
-    <td>The name of the server type that this hook applies to</td>
-    <td><code>server_type :rails</code></td>
+    <td>container_type</td>
+    <td>The name of the container type that this hook applies to</td>
+    <td><code>container_type :app</code></td>
     <td>None; this is required</td>
   </tr>
   <tr>
-    <td>command</td>
-    <td>The shell command that should be run when the hook executes</td>
-    <td><code>command 'cp /var/docker/database.yml /var/code/config/'</code></td>
-    <td>
-      None; this is required. However, it can also be set by calling
-      `run_script`.
-    </td>
+    <td>app_server_type</td>
+    <td>The name of the app server type that this hook applies to</td>
+    <td><code>app_server_type :rails</code></td>
+    <td>all, meaning all app server types</td>
   </tr>
+  <tr>
+    <td>database_server_type</td>
+    <td>The name of the database server type that this hook applies to</td>
+    <td><code>database_server_type :mysql</code></td>
+    <td>all, meaning all database server types</td>
+  </tr
+  <tr>
+    <td>web_server_type</td>
+    <td>The name of the web server type that this hook applies to</td>
+    <td><code>web_server_type :nginx</code></td>
+    <td>all, meaning all web server types</td>
+  </tr
   <tr>
     <td>script_folder</td>
     <td>
@@ -200,6 +223,30 @@ The hook DSL allows you to set the following fields:
     <td><code>script_folder './scripts'</code></td>
     <td>The working directory</td>
   </tr>
+</table>
+
+You can constrain a hook by multiple types of servers at once.. For instance,
+you can set the app_server_type to :rails and the database_server_type to :mysql
+to specify that the hook only applies to Rails apps backed by a MySQL database.
+By default, hooks apply to all server types. You also have to specify the
+container_type to say whether the hook is triggered by events on app images,
+database images, or web server images. For instance,
+both app images and database images have a `startup` event, and they'll need
+different behaviors defined.
+
+You can define the behaviors for the hooks with these methods:
+
+<table>
+  <tr>
+    <th>Method Name</th>
+    <th>Description</th>
+    <th>Example</th>
+  </tr>
+  <tr>
+    <td>command</td>
+    <td>The shell command that should be run when the hook executes</td>
+    <td><code>command 'cp /var/docker/database.yml /var/code/config/'</code></td>
+  </tr>
   <tr>
     <td>copy_file</td>
     <td>
@@ -207,7 +254,6 @@ The hook DSL allows you to set the following fields:
       image. This is relative to the hook's script folder.
     </td>
     <td><code>copy_file 'setup.rb'</code></td>
-    <td>None, meaning that no files are copied for this hook.</td>
   </tr>
   <tr>
     <td>run_script</td>
@@ -216,7 +262,20 @@ The hook DSL allows you to set the following fields:
       will set the `copy_file` and the `command`.
     </td>
     <td><code>run_script 'setup.rb'</code></td>
-    <td>None; if you are not using this you must call `command` instead.</td>
+  </tr>
+  <tr>
+    <td>set_environment_variable</td>
+    <td>
+      This sets an environment variable in the image. The value can be set in
+      either a block or a literal value passed as the second parameter.
+    </td>
+    <td>
+      <code>
+        set_environment_variable 'RAILS_ENV' do
+          @project.rails_environment
+        end
+      </code>
+    </td>
   </tr>
 </table>
 
@@ -227,4 +286,5 @@ settings, so you can set defaults for them by calling `add_hooks`. This method
 takes a hash containing options for the hooks, and a block for adding them. Any
 hooks added in the block will have those options set.
 
-The supported options are `script_folder` and `server_type`.
+The supported options are `script_folder`, `app_server_type`,
+`database_server_type`, `web_server_type`, and `container_type`.

data/lib/ruby_yacht/dsl/app.rb

@@ -22,13 +22,15 @@ module RubyYacht
     # The name of the database that this app uses as its data store.
     attr_accessor :database_name
 
+    # The project that includes this app.
+    def project
+      RubyYacht.configuration.projects.find { |project| project.apps.include?(self) }
+    end
+
     # This method gets the name of the image / container that this app will run
     # in.
-    #
-    # ### Parameters
-    #
-    # * *project: RubyYacht::Project*  The project the app is running in.
-    def container_name(project)
+    def container_name
+      project = self.project
       if project.system_prefix == self.name
         return "#{project.system_prefix}"
       else
@@ -38,13 +40,9 @@ module RubyYacht
 
     # This method gets the database that the app connects to.
     #
-    # ### Parameters
-    #
-    # * *project: RubyYacht::Project*   The project the app is running in.
-    #
     # ### Returns
     # RubyYacht::Database
-    def database(project)
+    def database
       project.databases.find { |database| database.name == database_name }
     end
     
@@ -61,10 +59,11 @@ module RubyYacht
       #
       # ### Parameters
       #
-      # * *name: String* The name of the app.
-      def initialize(name, server_type = nil)
-        @name = name.to_sym
+      # * **server_type: Symbol**   The type of server this is.
+      # * **name: String**          The name of the app.
+      def initialize(server_type, name)
         @server_type = server_type
+        @name = name.to_sym
         load_custom_attributes
       end
       
@@ -73,7 +72,7 @@ module RubyYacht
       ##
       # :method: repository_name
       # You can call `repository_name 'foo/bar'` to set the app's `repository_name`.
-      add_attribute :repository_name
+      add_attribute :repository_name, nil, false
       
       ##
       # :method: database_name
@@ -102,10 +101,7 @@ module RubyYacht
       # configuration.
       def check_required_attributes
         super
-        server_type = RubyYacht.configuration.find_server_type(@server_type)
-        unless server_type && server_type.container_type == :app
-          raise "App has invalid server type `#{@server_type}`"
-        end
+        check_server_type @server_type, :app
       end
     end
   end

data/lib/ruby_yacht/dsl/configuration.rb

@@ -17,6 +17,7 @@ module RubyYacht
       @projects = []
       @hooks = []
       @server_types = []
+      @avoid_docker_machine = false
     end
     
     # The projects that are part of this system.
@@ -31,24 +32,51 @@ module RubyYacht
     # Each entry is a Symbol.
     attr_accessor :server_types
 
-    # This method pulls up the hooks that we have defined.
+    # Whether we should avoid using docker-machine even if it is installed.
     #
-    # The hooks can be filtered by the attributes on the hook, like `event_type`
-    # and `event_time`.
+    # If docker-machine is not installed, the value of this flag will be
+    # ignored.
+    attr_accessor :disable_docker_machine
+
+    # This method pulls up the hooks that we have defined.
     #
     # ### Parameters
     #
-    # * **attributes: Hash**    The attributes to look for in the returned
-    #                           hooks.
+    # * **server: App/Database**:   The server we are fetching hooks for.
+    # * **event_type: Symbol**:     The event that we are fetching hooks for.
     #
     # ### Returns
     #
     # The matching hooks. This will be an Array where each item is a Hook.
-    def fetch_hooks(attributes={})
+    def fetch_hooks(server, event_type)
+      case server
+      when App
+        app_types = [server.server_type,:all]
+        database_types = [:all]
+        database = server.database
+        database_types << database.server_type if database
+        web_server_types = [:all] + server.project.web_servers.map(&:server_type).uniq
+        container_type = :app
+      when Database
+        database_types = [server.server_type, :all]
+        app_types = [:all]
+        app_types += server.apps.map(&:server_type)
+        web_server_types = [:all] + server.project.web_servers.map(&:server_type).uniq
+        container_type = :database
+      when WebServer
+        app_types = [:all] + server.project.apps.map(&:server_type).uniq
+        database_types = [:all] + server.project.databases.map(&:server_type).uniq
+        web_server_types = [:all, server.server_type]
+        container_type = :web
+      else
+        return []
+      end
       self.hooks.select do |hook|
-        attributes.keys.all? do |key|
-          hook.send(key) == attributes[key]
-        end
+        hook.event_type == event_type &&
+          app_types.include?(hook.app_server_type) &&
+          database_types.include?(hook.database_server_type) &&
+          web_server_types.include?(hook.web_server_type) &&
+          hook.container_type == container_type
       end
     end
 
@@ -73,6 +101,7 @@ module RubyYacht
       # This initializer creates an empty configuration DSL.
       def initialize
         self.load_custom_attributes
+        @hook_options = {}
       end
       
       ##
@@ -105,34 +134,24 @@ module RubyYacht
       # RubyYacht::ServerType::DSL.
       add_object_list :server_type, RubyYacht::ServerType::DSL
 
-      # The path for files and other resources from configuration hooks.
-      attr_accessor :hook_folder
-
-      # The app type for hooks that we are defining in the current block.
-      attr_accessor :hook_server_type
+      # The default options for the hooks we're defining in the current block.
+      attr_accessor :hook_options
 
       # This method sets default attributes for a group of hooks.
       #
-      # Any hooks that you create in the associated block will have their script
-      # folder and app type specified by the attached properties.
+      # Any hooks that you create in the associated block will have the included
+      # options set on them automatically. You will also be able to override
+      # these options in the configuration blocks for individual hooks.
       #
       # ### Parameters
       #
-      # * **folder: String**    The full path to the script folder.
+      # * **options: Hash**     The fields to set on the hooks.
       # * **block**             A block for adding the hooks.
       def add_hooks(options = {}, &block)
-        keys = [:folder, :server_type]
-        old_options = {}
-        keys.each do |key|
-          old_options[key] = self.send("hook_#{key}")
-          self.send("hook_#{key}=", options[key]) if options.has_key?(key)
-        end
-        
+        old_options = hook_options.dup
+        self.hook_options = options
         block.call
-        
-        keys.each do |key|
-          self.send("hook_#{key}=", old_options[key])
-        end
+        self.hook_options = old_options
       end
 
       # This method adds a before hook.
@@ -179,11 +198,11 @@ module RubyYacht
       private
 
       def add_hook(event_time, event_type, &block)
-        folder = hook_folder
-        type = hook_server_type
+        hook_options = self.hook_options
         hook event_time, event_type do
-          script_folder folder
-          server_type type
+          hook_options.each do |key, value|
+            public_send(key, value)
+          end
           instance_eval(&block)
         end
       end

data/lib/ruby_yacht/dsl/database.rb

@@ -17,6 +17,9 @@ module RubyYacht
     
     # The password we use to connect to the database
     attr_accessor :password
+    
+    # The port the database server should listen on.
+    attr_accessor :port
 
     # The database-specific part of the container name for this database.
     attr_accessor :container_label
@@ -26,11 +29,21 @@ module RubyYacht
       host == 'localhost'
     end
 
+    # The project that contains this database.
+    def project
+      RubyYacht.configuration.projects.find { |project| project.databases.include?(self) }
+    end
+
+    # The apps that connect to this database.
+    def apps
+      project.apps.select { |app| app.database_name == self.name }
+    end
+
     # This method gets the name of the container and image for this database.
     #
     # This will be the project's prefix followed by the database's container
     # label.
-    def container_name(project)
+    def container_name
       "#{project.system_prefix}-#{container_label}"
     end
 
@@ -46,11 +59,11 @@ module RubyYacht
       #
       # ### Parameters
       #
+      # * **server_type: Symbol**   The type of database this is.
       # * **name: String**          The name of the database.
-      # * **server_type: Symbol**   The type of database server this is.
-      def initialize(name, server_type = nil)
-        @name = name
+      def initialize(server_type, name)
         @server_type = server_type
+        @name = name.to_sym
         load_custom_attributes
       end
       
@@ -83,6 +96,12 @@ module RubyYacht
       # password `testpass`.
       add_attribute :password
       
+      ##
+      # :method: port
+      # You can call `port 1234` to tell the database server to listen on port
+      # 1234.
+      add_attribute :port
+      
       ##
       # :method: container_label
       # You can call `container_label 'mysql'` to give this database a container
@@ -100,10 +119,7 @@ module RubyYacht
       # configuration.
       def check_required_attributes
         super
-        server_type = RubyYacht.configuration.find_server_type(@server_type)
-        unless server_type && server_type.container_type == :database
-          raise "Database has invalid server type `#{@server_type}`"
-        end
+        check_server_type @server_type, :database
       end
     end
   end

data/lib/ruby_yacht/dsl/dsl.rb

@@ -164,9 +164,7 @@ module RubyYacht
             variable_name = "@#{name}s"
             list = instance_variable_get(variable_name)
             object_config = type.new(*args)
-            if config_block
-              object_config.run(config_block)
-            end
+            object_config.run(config_block)
             value = object_config.create_object
             list << value
             instance_variable_set(variable_name, list)
@@ -276,7 +274,20 @@ module RubyYacht
             end
           instance_variable_set("@#{name}", copy)
         end
-        instance_eval(&block)
+        if block
+          instance_eval(&block)
+        end
+        
+        type = RubyYacht.configuration.find_server_type(@server_type)
+        if type
+          type.server_defaults.each do |server_defaults|
+            server_defaults.each do |key, value|
+              if instance_variable_get("@#{key}") == nil
+                instance_variable_set("@#{key}", value)
+              end
+            end
+          end
+        end
         self
       end
       
@@ -293,6 +304,23 @@ module RubyYacht
           end
         end
       end
+
+      # This method checks that a server type has been registered.
+      #
+      # If it has not, this will raise an exception.
+      #
+      # ### Parameters
+      #
+      # * **server_type: Symbol**     The server type that has been set on this
+      #                               DSL instance.
+      # * **container_type: Symbol**    The container type that the server type
+      #                                 must be registered for.
+      def check_server_type(server_type, container_type)
+        result = RubyYacht.configuration.find_server_type(server_type)
+        unless result && result.container_type == container_type
+          raise "#{self.class.name} has invalid #{container_type} server type `#{server_type}`"
+        end
+      end
       
       # This method creates an object with the attributes from this instance.
       #