ruby_yacht 0.1.1 → 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8fe86d0666f935e2212841266623b3f2fc4b0fdc
+  data.tar.gz: 5f5c2ed02c41aaf4f9b98dd3fc79e8110a43d2cc
+SHA512:
+  metadata.gz: f4ad7a074ec77f4e8cfd1716ea69de349d0180125da4f7964420a1890c157c444a61eb7b06682e5dd672008fd55fdf01c4d037744286af4dd423be57cdccaa12
+  data.tar.gz: efc077fdd18c3485ce9f6ff25ad066c55dea2315324087aaa589a1ee6eb003b6bf0feb82c252ff9d4f96a91d335a0eb4a22d9a68cb341605edd3cc3d507d36f0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    ruby_yacht (0.1.0)
+    ruby_yacht (0.1.1)
 
 GEM
   remote: https://rubygems.org/

data/doc/TODO.md

@@ -1,10 +1,20 @@
+See the [GitHub Issue Tracker](https://github.com/brownleej/ruby-yacht/issues)
+for open tickets.
+
 # General
 
-* Testing behavior of the scripts that run on the image.
 * Do more testing with remote databases and non-development environments
 * Consider whether deploy containers are worth including
 * Consider whether using the same web server for multiple projects is the best
   approach
+* Look into issues with running shell command that has its own command-line
+  flags.
+
+# Plugins
+
+* Move more of the hooks to using the include_event helper
+* Add documentation on plugin API
+* Supporting shared databases between apps of different types
 
 # More Command Line Options
 
@@ -16,9 +26,9 @@
 
 * Add customizations for installation
 * Add customization for post-checkout hooks
-* HTTPS access for apps
-* Distinguishing whether we should use local or remote connections for other
-  services
-* Different types of app servers, i.e. non-rails apps
 * Using one of the apps for the bare domain
-* Defining custom commands
+* Defining custom commands
+* Allowing customization points at different levels, like adding hooks to
+  individual apps
+* Customizing how we check out the repositories, so that people can use https
+  instead of SSH.

data/doc/configuration_sample.rb

@@ -23,6 +23,9 @@ RubyYacht.configure do
     # ~/.ssh/id_rsa into the containers.
     repository "github.com"
     
+    # The secret key that we use for session information in the Rails apps.
+    rails_secret_key_base 'abc'
+    
     # The configuration for the database the app uses.
     database do
       # A database host of localhost tells ruby-yacht to build a database
@@ -37,18 +40,15 @@ RubyYacht.configure do
       password "test"
     end
     
-    app :mars do
+    rails_app :mars do
       # This app's repository is at github.com/brownleej/mars
       repository_name 'brownleej/mars'
     end
     
-    app :saturn do
+    rails_app :saturn do
       # This app's repository is at github.com/brownleej/saturn
       repository_name 'brownleej/saturn'
     end
-    
-    # The secret key that we use for session information in the Rails apps.
-    secret_key_base 'abc'
   end
 
   # This is a second project that runs a different set of apps, with different
@@ -57,6 +57,7 @@ RubyYacht.configure do
     system_prefix :jupiter
     domain "jupiter.docker.local"
     repository "github.com"
+    rails_secret_key_base 'abc'
     
     database do
       # Because this host has a real domain, we will not build a database
@@ -71,15 +72,13 @@ RubyYacht.configure do
       password "test"
     end
     
-    app :venus do
+    rails_app :venus do
       repository_name 'brownleej/venus'
     end
     
-    app :saturn do
+    rails_app :saturn do
       repository_name 'brownleej/saturn'
     end
-    
-    secret_key_base 'abc'
   end
 end
 

data/lib/ruby_yacht/dsl/app.rb

@@ -10,6 +10,12 @@ module RubyYacht
     # To the project's repository domain.
     attr_accessor :repository_name
     
+    # The type of app this is, which determines what hooks and scripts we run
+    # when building it.
+    #
+    # For instance, this would be `rails` for a Rails app.
+    attr_accessor :app_type
+    
     # The port that the app listens on.
     attr_accessor :port
 
@@ -37,8 +43,10 @@ module RubyYacht
       # ### Parameters
       #
       # * *name: String* The name of the app.
-      def initialize(name)
+      def initialize(name, app_type = nil)
         @name = name.to_sym
+        @app_type = app_type
+        load_custom_attributes
       end
       
       add_attribute :name
@@ -48,12 +56,32 @@ module RubyYacht
       # You can call `repository_name 'foo/bar'` to set the app's `repository_name`.
       add_attribute :repository_name
       
+      ##
+      # :method: app_type
+      # You can call `app_type :foo` to set the app's `app_type`.
+      add_attribute :app_type
+      
       ##
       # :method: port
       # You can call `port 3000` to set the app's `port`. It defaults to 8080.
       add_attribute :port, 8080
 
       creates_object App
+
+
+      
+      # 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 app type has been defined in the configuration.
+      def check_required_attributes
+        super
+        unless RubyYacht.configuration.find_app_type(@app_type)
+          raise "App has invalid app type `#{@app_type}`"
+        end
+      end
     end
   end
 end

data/lib/ruby_yacht/dsl/app_type.rb

@@ -0,0 +1,112 @@
+module RubyYacht
+  # This class represents a type of app that the user can configure.
+  #
+  # An app type corresponds to a major app framework, like Ruby on Rails. App
+  # types are defined by plugins, which also provide the logic for installing
+  # and running the apps.
+  #
+  # You can configure this with RubyYacht::AppType::DSL
+  class AppType
+    # The name of the type.
+    attr_accessor :name
+
+    # The attributes that we define on the project DSL once this app type has
+    # been loaded.
+    #
+    # Each entry will be a hash with a key for `name`, and optionally a key for
+    # `default` and `required`. These values will be given to the
+    # `add_attribute` method in the project DSL.
+    #
+    # The attribute names will be prefixed with the app type's name. For
+    # instance, if the `rails` app type provides an `environment` attribute,
+    # it will be called `rails_environment` on the project's DSL. This prevents
+    # conflicts with attributes from other plugins.
+    attr_accessor :project_attributes
+    
+    # The attributes that we define on the app DSL once this app type has
+    # been loaded.
+    #
+    # Each entry will be a hash with a key for `name`, and optionally a key for
+    # `default` and `required`. These values will be given to the
+    # `add_attribute` method in the project DSL.
+    #
+    # The attributes will only be defined on apps with this app type.
+    #
+    # The attribute names will be prefixed with the app type's name. For
+    # instance, if the `rails` app type provides an `environment` attribute,
+    # it will be called `rails_environment` on the app's DSL. This prevents
+    # conflicts with attributes from other plugins.
+    attr_accessor :app_attributes
+
+    # The docker image that we use as the source for the app images.
+    attr_accessor :baseline_image
+
+    # The custom environment variables that we set in the images for this app
+    # 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. app
+    #                       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::AppType.
+    class DSL
+      include RubyYacht::DSL::Base
+      extend RubyYacht::DSL::Base::ClassMethods
+
+      # This initiailzer creates the app type DSL.
+      #
+      # ### Parameters
+      #
+      # * **name: Symbol**    The name of the app type.
+      def initialize(name)
+        @name = name
+        @environment_variables = []
+        load_custom_attributes
+      end
+
+      add_attribute :name
+
+      #
+      # :method: baseline_image
+      # You can call `baseline_image 'ubuntu'` to use ubuntu as the source
+      # image for the app containers for this app type.
+      add_attribute :baseline_image
+
+      #
+      # :method: project_attribute
+      # You can call `project_attribute name: :environment, default: 'staging'`
+      # to add an attribute to the project DSL.
+      add_list :project_attribute
+
+      #
+      # :method: app_attribute
+      # You can call `app_attribute name: :environment, default: 'staging'`
+      # to add an attribute to the app DSL.
+      add_list :app_attribute
+
+      creates_object RubyYacht::AppType, [:name, :baseline_image,
+        :project_attributes, :app_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 app (as @app) that we are building the
+      #                       image for.
+      def environment_variable(image, name, &block)
+        @environment_variables << {image: image, name: name, block: block}
+      end
+    end
+  end
+end

data/lib/ruby_yacht/dsl/configuration.rb

@@ -1,4 +1,6 @@
 require_relative 'project'
+require_relative 'hook'
+require_relative 'app_type'
 
 module RubyYacht
   # This class stores the configuration for the system.
@@ -13,16 +15,65 @@ module RubyYacht
     # This method erases all the configuration.
     def clear
       @projects = []
+      @hooks = []
+      @app_types = []
     end
     
     # The projects that are part of this system.
     # Each entry is a RubyYacht::Project
     attr_accessor :projects
+
+    # The hooks to customize the build and run processes.
+    # Each entry is a RubyYacht::Hook
+    attr_accessor :hooks
+
+    # The app types that we can support.
+    # Each entry is a Symbol.
+    attr_accessor :app_types
+
+    # This method pulls up the hooks that we have defined.
+    #
+    # The hooks can be filtered by the attributes on the hook, like `event_type`
+    # and `event_time`.
+    #
+    # ### Parameters
+    #
+    # * **attributes: Hash**    The attributes to look for in the returned
+    #                           hooks.
+    #
+    # ### Returns
+    #
+    # The matching hooks. This will be an Array where each item is a Hook.
+    def fetch_hooks(attributes={})
+      self.hooks.select do |hook|
+        attributes.keys.all? do |key|
+          hook.send(key) == attributes[key]
+        end
+      end
+    end
+
+    # This method finds an app type by name.
+    #
+    # ### Parameters
+    #
+    # * **name: Symbol**    The name of the app type to return.
+    #
+    # ### Returns
+    #
+    # The RubyYacht::AppType with that name.
+    def find_app_type(name)
+      self.app_types.find { |type| type.name == name }
+    end
     
     # This method provides a DSL for top-level configuration.
     class DSL
       include RubyYacht::DSL::Base
       extend RubyYacht::DSL::Base::ClassMethods
+
+      # This initializer creates an empty configuration DSL.
+      def initialize
+        self.load_custom_attributes
+      end
       
       ##
       # :method: project
@@ -33,8 +84,109 @@ module RubyYacht
       # which you can use to configure the project, using
       # RubyYacht::Project::DSL.
       add_object_list :project, RubyYacht::Project::DSL
+
+      ##
+      # :method: hook
+      #
+      # This method adds a hook to the configuration.
+      #
+      # This takes hook's event_time and event_type as its arguments.  It also
+      # takes a block which you can use to configure the hook, using
+      # RubyYacht::Hook::DSL.
+      add_object_list :hook, RubyYacht::Hook::DSL
+
+      ##
+      # :method: app_type
+      #
+      # This method adds an app type to the configuration.
+      #
+      # This takes type's name as its argument. It also takes a block which you
+      # can use to configure the type, using
+      # RubyYacht::AppType::DSL.
+      add_object_list :app_type, RubyYacht::AppType::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_app_type
+
+      # 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.
+      #
+      # ### Parameters
+      #
+      # * **folder: String**    The full path to the script folder.
+      # * **block**             A block for adding the hooks.
+      def add_hooks(options = {}, &block)
+        keys = [:folder, :app_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
+        
+        block.call
+        
+        keys.each do |key|
+          self.send("hook_#{key}=", old_options[key])
+        end
+      end
+
+      # This method adds a before hook.
+      #
+      # ### Parameters
+      #
+      # * **event_type: Symbol**    The event type for the new hook.
+      # * **block**                 A block for configuring the hook. You can 
+      #                             call the RubyYacht::Hook::DSL methods in
+      #                             this block.
+      def before(event_type, &block)
+        add_hook :before, event_type, &block
+      end
+
+      # This method adds an after hook.
+      #
+      # ### Parameters
+      #
+      # * **event_type: Symbol**    The event type for the new hook.
+      # * **block**                 A block for configuring the hook. You can 
+      #                             call the RubyYacht::Hook::DSL methods in
+      #                             this block.
+      def after(event_type, &block)
+        add_hook :after, event_type, &block
+      end
+
+      # This method adds a during hook.
+      #
+      # This hook will be run while event is happening, and provides the core
+      # logic for the event.
+      #
+      # ### Parameters
+      #
+      # * **event_type: Symbol**    The event type for the new hook.
+      # * **block**                 A block for configuring the hook. You can 
+      #                             call the RubyYacht::Hook::DSL methods in
+      #                             this block.
+      def during(event_type, &block)
+        add_hook :during, event_type, &block
+      end
       
-      creates_object Configuration
+      creates_object Configuration, %w(projects hooks app_types)
+
+      private
+
+      def add_hook(event_time, event_type, &block)
+        folder = hook_folder
+        type = hook_app_type
+        hook event_time, event_type do
+          script_folder folder
+          app_type type
+          instance_eval(&block)
+        end
+      end
     end
   end
   
@@ -47,7 +199,16 @@ module RubyYacht
   # of projects.
   def self.configure(&block)
     new_configuration = Configuration::DSL.new.run(block).create_object
-    self.configuration.projects += new_configuration.projects
+    %w(projects hooks).each do |field|
+      self.configuration.send("#{field}=", self.configuration.send(field) + new_configuration.send(field))
+    end
+
+    new_configuration.app_types.each do |type|
+      if self.configuration.app_types.any? { |existing| existing.name == type.name }
+        raise "App type already registered: #{type.name}"
+      end
+      self.configuration.app_types << type
+    end
   end
   
   # This method gets the current configuration for the system.

data/lib/ruby_yacht/dsl/dsl.rb

@@ -130,8 +130,8 @@ module RubyYacht
         #
         # * **name: Symbol**    The name of the method, which will also be the
         #                       name of the attribute.
-        # * **type: String**    The name of the type that provides the DSL when
-        #                       they call this method.
+        # * **type: Class**     The class type that provides the DSL when they
+        #                       call this method.
         # * **options: Hash**   Other options about the DSL. Right now the only
         #                       option is *required*, which indicates whether
         #                       they must define this configuraiton.
@@ -157,14 +157,17 @@ module RubyYacht
         #
         # * **name: Symbol**    The name of the method. The attribute name will
         #                       be this, followed by an "s"
-        # * **type: String**    The name of the type that provides the type when
-        #                       they call this method.
+        # * **type: Class**     The class type that provides the DSL when they
+        #                       call this method.
         def add_object_list(name, type)
           add_generic_attribute name, "#{name}s", [], false do |*args, &config_block|
             variable_name = "@#{name}s"
             list = instance_variable_get(variable_name)
             object_config = type.new(*args)
-            value = object_config.run(config_block).create_object
+            if config_block
+              object_config.run(config_block)
+            end
+            value = object_config.create_object
             list << value
             instance_variable_set(variable_name, list)
           end
@@ -186,6 +189,46 @@ module RubyYacht
           @created_type = type
         end
       end
+
+      # This initializer creates a new DSL instance.
+      def initialize
+        load_custom_attributes
+      end
+
+      # This method adds attributes to this DSL instance's singleton DSL, based
+      # on the attributes defined by the app types that have been loaded.
+      def load_custom_attributes
+        full_class = self.class
+        self.singleton_class.instance_eval do
+          @copied_attributes = (full_class.copied_attributes || []).dup
+          @all_attributes = full_class.all_attributes.dup
+          @required_attributes = full_class.required_attributes.dup
+          @default_values = full_class.default_values.dup
+        end
+
+        if self.class.created_type
+          dsl_type = self.class.created_type.name.split('::').last.downcase
+          copied_attributes = self.class.copied_attributes
+
+          RubyYacht.configuration.app_types.each do |app_type|
+            next if @app_type && app_type.name != @app_type
+            attributes = app_type.send("#{dsl_type}_attributes") || [] rescue []
+            attributes.each do |attribute|
+              if attribute.has_key?(:required)
+                required = attribute[:required]
+              else
+                required = true
+              end
+              name = "#{app_type.name}_#{attribute[:name]}"
+              self.singleton_class.add_attribute name, attribute[:default], required
+              self.singleton_class.copied_attributes << name
+              self.class.created_type.instance_eval do
+                attr_accessor name
+              end
+            end
+          end
+        end
+      end
       
       # This method runs a block with DSL methods.
       #
@@ -199,7 +242,7 @@ module RubyYacht
       #
       # * **block: Proc**   The block to run.
       def run(block)
-        defaults = self.class.default_values || {}
+        defaults = self.singleton_class.default_values || {}
         defaults.each do |name, value|
           copy =
             case value
@@ -219,7 +262,7 @@ module RubyYacht
       #
       # If they haven't, this will raise an exception.
       def check_required_attributes
-        attributes = self.class.required_attributes || []
+        attributes = self.singleton_class.required_attributes || []
         attributes.each do |name|
           value = instance_variable_get("@#{name}")
           if value == nil || value == ''
@@ -241,8 +284,7 @@ module RubyYacht
       def create_object
         check_required_attributes
         object = self.class.created_type.new
-
-        self.class.copied_attributes.each do |name|
+        self.singleton_class.copied_attributes.each do |name|
           object.send("#{name}=", instance_variable_get("@#{name}"))
         end
         object

data/lib/ruby_yacht/dsl/hook.rb

@@ -0,0 +1,105 @@
+module RubyYacht
+  # This class provides a hook that a user or plugin can provide to customize
+  # the app images.
+  #
+  # You can configure this with RubyYacht::Hook::DSL
+  class Hook
+    # The permitted values for the `event_time` attribute.
+    EVENT_TIMES = [:before, :after, :during]
+
+    # The permitted values for the `event_type` attribute.
+    EVENT_TYPES = [:startup, :build_checkout, :install_libraries]
+
+    # When this hook should take effect, relative to the event.
+    attr_accessor :event_time
+
+    # The type of event that this hook is attached to.
+    attr_accessor :event_type
+
+    # The type of app that this hook applies to.
+    attr_accessor :app_type
+
+    # The path to the script that contains the code for this hook.
+    attr_accessor :script_path
+
+    # The command that we should run for this hook.
+    attr_accessor :command
+
+    # The name of the file containing the code for this hook.
+    def script_name
+      return '' unless script_path
+      File.basename(script_path)
+    end
+
+    # This class provides a DSL for configuring hooks.
+    class DSL
+      include RubyYacht::DSL::Base
+      extend RubyYacht::DSL::Base::ClassMethods
+
+      # This initializer creates a new Hook DSL.
+      #
+      # ### Parameters
+      #
+      # * **event_time: Symbol**      The time for the hook, relative to the
+      #                               event.
+      # * **event_type: Symbol**      The type of event the hook is attached to.
+      def initialize(event_time, event_type)
+        @event_time = event_time
+        @event_type = event_type
+        @script_path = nil
+        load_custom_attributes
+      end
+
+      ##
+      # :method: app_type
+      #
+      # You can call `app_type :rails` to signify that this hook applies to
+      # rails apps.
+      add_attribute :app_type
+
+      ##
+      # :method: command
+      #
+      # 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
+
+      ##
+      # :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
+
+      # This method sets the name of the script containing the code for the
+      # hook.
+      #
+      # 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)
+        @script_path = File.join(@script_folder || '.', name)
+        @command = "/var/docker/#{name}"
+      end
+      
+      # This method checks that all of the required attributes have been set on
+      # the object.
+      #
+      # If they haven't, this will raise an exception.
+      #
+      # This will also check that the app type is valid.
+      def check_required_attributes
+        super
+        unless RubyYacht.configuration.find_app_type(@app_type)
+          raise "Hook has invalid app type `#{@app_type}`"
+        end
+      end
+
+      creates_object RubyYacht::Hook, %w(event_time event_type script_path app_type command)
+    end
+  end
+end