ruby_yacht 0.1.0

data/lib/ruby_yacht/dsl/dsl.rb

@@ -0,0 +1,252 @@
+module RubyYacht
+  # This module contains types for defining our configuration DSL.
+  module DSL
+    # This module provides the core functionality for providing configuration
+    # DSLs.
+    #
+    # Classes that provide DSLs should include this module and extend the
+    # ClassMethods module.
+    module Base
+      # This module provides class methods for defining DSLs.
+      module ClassMethods
+        # The attributes that must be provided on this DSL type.
+        def required_attributes
+          @required_attributes ||= []
+        end
+        
+        # The attributes that this DSL type can accept.
+        def all_attributes
+          @all_attributes ||= []
+        end
+        
+        # The default values that should be set on new DSL objects.
+        def default_values
+          @default_values ||= {}
+        end
+
+        # The attributes that we copy from this type to the real type the DSL
+        # creates.        
+        def copied_attributes
+          @copied_attributes
+        end
+        
+        # The real type that this DSL creates.
+        def created_type
+          @created_type
+        end
+        
+        # This method adds an attribute to the DSL.
+        #
+        # This will define a method on the DSL class, and register the attribute
+        # with the class.
+        #
+        # You generally won't need to call this yourself, but it provides a
+        # shared implementation for the rest of the attribute-definition
+        # methods.
+        #
+        # ### Parameters
+        #
+        # * **method_name: Symbol**       The name of the method to create.
+        # * **attribute_name: Symbol**    The name of the instance variable that
+        #                                 the method sets.
+        # * **default: Object**           The default value that should be set
+        #                                 for this attribute.
+        # * **required: Bool**            Whether the user should be required to
+        #                                 provide a value for this attribute.
+        # * **processing_block: Proc**    The block that we should invoke when
+        #                                 the method is called, to set the value
+        #                                 of the attribute.
+        def add_generic_attribute(method_name, attribute_name, default = nil, required = true, &processing_block)
+          define_method(method_name, &processing_block)
+          if default != nil
+            default_values[attribute_name] = default
+          end
+          if required
+            required_attributes << attribute_name
+          end
+          all_attributes << attribute_name
+        end
+        
+        # This method adds a standard attribute to the DSL.
+        #
+        # This will create a method that you can invoke with a single parameter,
+        # which provides the new value for the attribute.
+        #
+        # ### Parameters
+        #
+        # * **name: Symbol**      The name of the attribute, which will also be
+        #                         the name of the method.
+        # * **default: Object**   The default value for the attribute.
+        # * **required: Bool**    Whether we should require the user to provide
+        #                         a value for the attribute.
+        def add_attribute(name, default = nil, required = true)
+          add_generic_attribute name, name, default, required do |value|
+            instance_variable_set("@#{name}", value)
+          end
+        end
+        
+        # This method adds an attribute to the DSL for managing a list.
+        #
+        # This will create a method that you can invoke with a single parameter,
+        # which will be added to the list.
+        #
+        # ### Parameters
+        #
+        # * **name: Symbol**    The name of the method. The name of the
+        #                       attribute will be this name, followed by an s.
+        def add_list(name)
+          add_generic_attribute name, "#{name}s", [], false do |value|
+            variable_name = "@#{name}s"
+            list = instance_variable_get(variable_name)
+            list << value
+            instance_variable_set(variable_name, list)
+          end
+        end
+        
+        # This method adds an attribute to the DSL for managing a Boolean flag.
+        #
+        # This will create a method that you can call to change the value from
+        # true to false.
+        #
+        # The value will always be false by default.
+        #
+        # ### Parameters
+        #
+        # * **name: Symbol**    The name of the method, which will also be the
+        #                       name of the attribute.
+        def add_boolean(name)
+          add_generic_attribute name, name, false, false do
+            instance_variable_set("@#{name}", true)
+          end
+        end
+
+        # This method adds an object from another DSL to this DSL.
+        #
+        # This will create a method that you can call with a block, which will
+        # allow you to use the other DSL object. You can also give it arbitrary
+        # other arguments, which will be given to the initializer for the DSL.
+        #
+        # ### Parameters
+        #
+        # * **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.
+        # * **options: Hash**   Other options about the DSL. Right now the only
+        #                       option is *required*, which indicates whether
+        #                       they must define this configuraiton.
+        def add_object(name, type, options = {})
+          unless options.has_key?(:required)
+            options[:required] = true
+          end
+          add_generic_attribute name, name, nil, options[:required] do |*args, &config_block|
+            variable_name = "@#{name}"
+            object_config = Kernel.const_get(type).new(*args)
+            value = object_config.run(config_block).create_object
+            instance_variable_set(variable_name, value)
+          end
+        end
+        
+        # This method adds a list of objects from another DSL to this DSL.
+        #
+        # This will create a method that you can call with a block to create the
+        # other object and add it to the list. You can also give it arbitrary
+        # other arguments, which will be given to the initializer for the DSL.
+        #
+        # ### Parameters
+        #
+        # * **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.
+        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 = Kernel.const_get(type).new(*args)
+            value = object_config.run(config_block).create_object
+            list << value
+            instance_variable_set(variable_name, list)
+          end
+        end
+        
+        # This method specifies that this DSL class creates a real object of
+        # a certain type.
+        #
+        # ### Parameters
+        #
+        # * **type: Class**         The type that this DSL creates.
+        # * **attributes: Array**   The attributes that we copy from the DSL
+        #                           to the related object. If this is not
+        #                           provided, we will copy all of the
+        #                           attributes that this DSL has defined so far.
+        def creates_object(type, attributes = nil)
+          attributes ||= self.all_attributes
+          @copied_attributes = attributes
+          @created_type = type
+        end
+      end
+      
+      # This method runs a block with DSL methods.
+      #
+      # The block will reun in the instance context of the DSL object, so you
+      # can call the DSL methods directly.
+      #
+      # It will also copy the default values into the attributes on the DSL
+      # object.
+      #
+      # ### Parameters
+      #
+      # * **block: Proc**   The block to run.
+      def run(block)
+        defaults = self.class.default_values || {}
+        defaults.each do |name, value|
+          copy =
+            case value
+            when TrueClass, FalseClass, Fixnum
+              value
+            else
+              value.dup
+            end
+          instance_variable_set("@#{name}", copy)
+        end
+        instance_eval(&block)
+        self
+      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.
+      def check_required_attributes
+        attributes = self.class.required_attributes || []
+        attributes.each do |name|
+          value = instance_variable_get("@#{name}")
+          if value == nil || value == ''
+            raise "Missing required attribute #{name} for #{self.class}"
+          end
+        end
+      end
+      
+      # This method creates an object with the attributes from this instance.
+      #
+      # We will check that all the required attributes have been set first, and
+      # will raise an exception if they haven't.
+      #
+      # The created type, and the attributes we set on it, will be defined by
+      # the call to the class method `creates_object`.
+      #
+      # ### Returns
+      # This will return the newly created object.
+      def create_object
+        check_required_attributes
+        object = self.class.created_type.new
+
+        self.class.copied_attributes.each do |name|
+          object.send("#{name}=", instance_variable_get("@#{name}"))
+        end
+        object
+      end
+    end
+  end
+end

data/lib/ruby_yacht/dsl/project.rb

@@ -0,0 +1,140 @@
+module RubyYacht
+  # This class provides a configuration for a project in our system.
+  #
+  # A project is a family of apps that communicate with each other and
+  # share a database.
+  class Project
+    # The name of the project.
+    attr_accessor :name
+    
+    # The prefix that we use before all of the images and containers for the
+    # 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
+    
+    # The secret key that the apps should use for signing cookies.
+    attr_accessor :secret_key_base
+    
+    # The environment that the apps should run in.
+    attr_accessor :rails_environment
+    
+    # Whether we should check out the code on the host machine, rather than
+    # keeping it entirely inside the container.
+    attr_accessor :check_out_locally
+    
+    # Whether we should create a special container with all the apps for running
+    # deploys.
+    attr_accessor :create_deploy_container
+    
+    # The configuration for the database. This is a RubyYacht::Database.
+    attr_accessor :database
+    
+    # The configuration for the apps. Each entry is a RubyYacht::App.
+    attr_accessor :apps
+    
+    # The configuration for the DNS for the apps. This is a RubyYacht::DnsServer.
+    attr_accessor :dns_server
+    
+    # This class provides a DSL for configuring a project.
+    #
+    # You can access this inside RubyYacht::Configuration::DSL by calling
+    # `project`. It will create a RubyYacht::Project.
+    class DSL
+      include RubyYacht::DSL::Base
+      extend RubyYacht::DSL::Base::ClassMethods
+      
+      # This initializer creates a new project.
+      #
+      # ### Parameters
+      #
+      # * *name: String* The name of the project
+      def initialize(name)
+        @name = name.to_sym
+      end
+      
+      add_attribute :name
+      
+      ##
+      # :method: system_prefix
+      # You can call `system_prefix 'my-apps'` to set the projects
+      # 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: secret_key_base
+      # You can call `secret_key_base '1234kj1234k;lj1234jklh'` to set the
+      # project's `secret_key_base` to `1234kj1234k;lj1234jklh`.
+      add_attribute :secret_key_base
+      
+      ##
+      # :method: repository
+      # You can call `repository 'github.com'` to set the project's `repository`
+      # to `github.com`
+      add_attribute :repository
+      
+      ##
+      # :method: rails_environment
+      #
+      # You can call `rails_environment 'staging'` to set the project's 
+      # `rails_environment` to  `staging`.
+      #
+      # The default is `development`.
+      add_attribute :rails_environment, 'development'
+      
+      ##
+      # :method: check_out_locally
+      #
+      # You can call `check_out_locally` to set the project's
+      # `check_out_locally` flag to `true`. The default is false.
+      add_boolean :check_out_locally
+      
+      ##
+      # :method: create_deploy_container
+      #
+      # You can call `create_deploy_container` to set the project's
+      # `create_deploy_container` flag to `true`. The default is false.
+      add_boolean :create_deploy_container
+      
+      ##
+      # :method: app
+      #
+      # You can call `app 'mars'` to add an app called `mars`. This takes a
+      # block for configuring the app, which allows you to call methods in
+      # RubyYacht::App::DSL
+      add_object_list :app, 'RubyYacht::App::DSL'
+      
+      ##
+      # :method: database
+      #
+      # You can call `database` to configure the database for the project.
+      # This takes a block for configuring the database, which allows you to
+      # call methods in RubyYacht::Database::DSL
+      #
+      # You must call this in your project config.
+      add_object :database, 'RubyYacht::Database::DSL'
+      
+      ##
+      # :method: dns_server
+      #
+      # You can call `dns_server` to configure the DNS for the project.
+      # This takes a block for configuring the DNS , which allows you to
+      # call methods in RubyYacht::DnsServer::DSL
+      #
+      # This is optional.
+      add_object :dns_server, 'RubyYacht::DnsServer::DSL', required: false
+      
+      creates_object Project
+    end
+  end
+end

data/lib/ruby_yacht/dsl.rb

@@ -0,0 +1,6 @@
+require 'ruby_yacht/dsl/dsl'
+require 'ruby_yacht/dsl/project'
+require 'ruby_yacht/dsl/app'
+require 'ruby_yacht/dsl/database'
+require 'ruby_yacht/dsl/dns_server'
+require 'ruby_yacht/dsl/configuration'

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

@@ -0,0 +1,32 @@
+FROM <%= @project.system_prefix %>-app-dependencies
+
+ENV DATABASE_HOST <%= @project.database.host %>
+ENV DATABASE_NAME <%= @project.database.name %>
+ENV DATABASE_PASSWORD <%= @project.database.password %>
+ENV DATABASE_USERNAME <%= @project.database.username %>
+ENV RAILS_ENV <%= @project.rails_environment %>
+ENV RAILS_PORT <%= @app.port %>
+ENV REPOSITORY_HOST <%= @project.repository %>
+ENV SECRET_KEY_BASE <%= @project.secret_key_base %>
+ENV SYSTEM_PREFIX <%= @project.system_prefix %>
+
+RUN rm -r /var/code
+RUN mkdir -p /var/code
+
+COPY startup.rb /var/docker/startup.rb
+COPY checkout.rb /var/docker/checkout.rb
+COPY update_database_config.rb /var/docker/update_database_config.rb
+
+RUN chmod u+x /var/docker/*.rb
+
+ENV REPOSITORY_NAME <%= @app.repository_name %>
+
+RUN /var/docker/checkout.rb
+
+WORKDIR /var/code
+
+RUN bundle install && bundle clean --force
+
+EXPOSE <%= @app.port %>
+
+CMD /var/docker/startup.rb

data/lib/ruby_yacht/images/app/checkout.rb

@@ -0,0 +1,7 @@
+#! /usr/local/bin/ruby
+
+if !File.exist?('/var/code/Gemfile')
+  repository_host = ENV['REPOSITORY_HOST']
+  repository_name = ENV['REPOSITORY_NAME']
+  system "git clone git@#{repository_host}:#{repository_name} /var/code"
+end

data/lib/ruby_yacht/images/app/startup.rb

@@ -0,0 +1,17 @@
+#! /usr/local/bin/ruby
+
+require 'fileutils'
+require_relative 'checkout'
+require_relative 'update_database_config'
+
+FileUtils.cd '/var/code'
+
+system "bundle install"
+system "rake db:migrate"
+
+system "rails r Rails.cache.clear"
+if ENV['RAILS_ENV'] != 'development'
+  system "rake assets:precompile"
+end
+
+exec "rails s -b 0.0.0.0 -p $RAILS_PORT -e $RAILS_ENV"

data/lib/ruby_yacht/images/app/update_database_config.rb

@@ -0,0 +1,45 @@
+#! /usr/local/bin/ruby
+require 'yaml'
+
+database_host = ENV['DATABASE_HOST']
+local_database = (database_host == 'localhost')
+if local_database
+  database_host = ENV['SYSTEM_PREFIX'] + '-database'
+end
+  
+common_config = {
+  'adapter' => 'mysql2',
+  'username' => ENV['DATABASE_USERNAME'],
+  'password' => ENV['DATABASE_PASSWORD'],
+  'reconnect' => true,
+  'host' => database_host,
+  'database' => ENV['DATABASE_NAME']
+}
+
+database_config = {
+  ENV['RAILS_ENV'] => common_config
+}
+
+if ENV['RAILS_ENV'] == 'development' && local_database
+  database_config['test'] = common_config.dup
+  database_config['test']['database'] += '_test'
+  database_config['development']['database'] += '_development'
+end
+
+File.open('/var/code/config/database.yml', 'w') do |file|
+  file.write(database_config.to_yaml)
+end
+
+secret_key_config = {
+  ENV['RAILS_ENV'] => {
+    'secret_key_base' => ENV['SECRET_KEY_BASE']
+  }
+}
+
+if ENV['RAILS_ENV'] == 'development'
+  secret_key_config['test'] = secret_key_config['development'].dup
+end
+
+File.open('/var/code/config/secrets.yml', 'w') do |file|
+  file.write(secret_key_config.to_yaml)
+end

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

@@ -0,0 +1,23 @@
+# This Dockerfile creates an image for installing all of the gem dependencies
+# for all of the apps.
+#
+# This is a slow process, so this should be kept as simple as possible so that
+# it can remain unchanged.
+
+FROM ruby:2.3
+
+RUN mkdir -p /root/.ssh
+COPY id_rsa /root/.ssh
+RUN ssh-keyscan <%= @project.repository %> >> /root/.ssh/known_hosts
+
+RUN mkdir -p /var/docker/
+COPY install_gems.rb /var/docker/install_gems.rb
+
+<% @project.apps.each do |app| %>
+RUN ruby /var/docker/install_gems.rb <%= app.name %> <%= @project.repository %> <%= app.repository_name %>
+<% end %>
+
+RUN rm /var/docker/install_gems.rb
+
+RUN apt-get update && apt-get upgrade -y
+RUN apt-get install -y mysql-client

data/lib/ruby_yacht/images/app-dependencies/install_gems.rb

@@ -0,0 +1,12 @@
+#! /usr/local/bin/ruby
+
+require 'yaml'
+
+app_name = ARGV.shift
+repository_host = ARGV.shift
+repository_name = ARGV.shift
+
+puts "Installing gems for #{app_name}"
+system "mkdir -p /var/code"
+system "git clone git@#{repository_host}:#{repository_name} /var/code/#{app_name}"
+system "cd /var/code/#{app_name} && bundle install"

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

@@ -0,0 +1,26 @@
+FROM <%= @project.system_prefix %>-app-dependencies
+
+<% database = @project.database %>
+
+ENV DEBIAN_FRONTEND noninteractive
+RUN apt-get install -y mysql-server
+
+COPY setup.rb /var/docker/setup.rb
+COPY setup_database.sql.erb /var/docker/setup_database.sql.erb
+COPY load_seeds.rb /var/docker/load_seeds.rb
+
+RUN ruby /var/docker/setup.rb <%= database.name %> <%= database.username %> <%= database.password %> <%= @project.rails_environment %>
+
+<% initialized = false %>
+<% @project.apps.each do |app| %>
+  <% database_name = database.name %>
+  <% database_name += '_development' if @project.rails_environment == 'development' %>
+RUN ruby /var/docker/load_seeds.rb <%= app.name %> <%= database_name %> <%= database.username %> <%= database.password %> <%= initialized %>
+  <% initialized = true %>
+<% end %>
+RUN rm -r /var/docker
+RUN rm -r /var/code
+
+EXPOSE 3306
+
+CMD mysqld_safe --bind-address=0.0.0.0

data/lib/ruby_yacht/images/database/load_seeds.rb

@@ -0,0 +1,42 @@
+#! /usr/local/bin/ruby
+
+require 'yaml'
+require 'fileutils'
+
+puts "Loading seeds"
+
+app_name = ARGV.shift
+name = ARGV.shift
+username = ARGV.shift
+password = ARGV.shift
+initialized_database = (ARGV.shift == 'true')
+
+puts "Creating #{name} database"
+system "service mysql start"
+
+directory = "/var/code/#{app_name}"
+config_path = "#{directory}/config/database.yml"
+
+FileUtils.cd directory
+database_config = {
+  'development' => {
+    'adapter' => 'mysql2',
+    'encoding' => 'utf8',
+    'reconnect' => true,
+    'username' => username,
+    'password' => password,
+    'host' => 'localhost',
+    'database' => name
+  }
+}
+
+File.open(config_path, "w") do |file|
+  file.write(database_config.to_yaml)
+end
+
+if initialized_database
+  rake_command = "bundle exec rake db:migrate; bundle exec rake db:seed"
+else
+  rake_command = "bundle exec rake db:reset"
+end
+system "bundle install; #{rake_command}"

data/lib/ruby_yacht/images/database/setup.rb

@@ -0,0 +1,19 @@
+#! /usr/local/bin/ruby
+
+require 'erb'
+require 'yaml'
+
+@database_name = ARGV.shift
+@database_user = ARGV.shift
+@database_password = ARGV.shift
+@rails_environment = ARGV.shift
+
+system "service mysql start"
+system "mysql -uroot -e \"CREATE USER '#{@database_user}'@'localhost' IDENTIFIED BY '#{@database_password}'\""
+system "mysql -uroot -e \"CREATE USER '#{@database_user}'@'%' IDENTIFIED BY '#{@database_password}'\""
+
+template = ERB.new(File.read('/var/docker/setup_database.sql.erb'))
+File.open('/var/docker/create_database.sql', 'w') do |file|
+  file.write(template.result(binding))
+end
+system "mysql -uroot < /var/docker/create_database.sql"

data/lib/ruby_yacht/images/database/setup_database.sql.erb

@@ -0,0 +1,12 @@
+<%
+if @rails_environment == 'development'
+  database_names = %w(_development _test).map { |suffix| @database_name + suffix }
+else
+  database_names = [@database_name]
+end
+%>
+<% database_names.each do |database_name| %>
+  GRANT ALL ON <%= database_name %>.* to '<%= @database_user %>'@'localhost';
+  GRANT ALL ON <%= database_name %>.* to '<%= @database_user %>'@'%';
+  CREATE DATABASE <%= database_name %>;
+<% end %>

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

@@ -0,0 +1,2 @@
+FROM <%= @project.system_prefix %>-app-dependencies
+CMD bash

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

@@ -0,0 +1,25 @@
+FROM nginx
+
+RUN apt-get update
+RUN apt-get upgrade -y
+RUN apt-get install -y ruby
+
+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| %>
+  <% app_list = project.apps.map(&:name).join(',') %>
+RUN ruby /var/docker/add_project.rb <%= project.system_prefix %> <%= project.domain %> <%= app_list %>
+  <% project.apps.each do |app| %>
+RUN ruby /var/docker/add_app.rb <%= project.system_prefix %> <%= project.domain %> <%= app.name %> <%= app.port %>
+  <% end %>
+<% end %>
+
+RUN rm -r /var/docker
+RUN apt-get remove -y ruby
+RUN apt-get autoremove -y