apache-config-generator 0.1

data/CHANGELOG

@@ -0,0 +1 @@
+v0.1. Initial release, support for many of the Apache config basics.

data/Manifest

@@ -0,0 +1,20 @@
+CHANGELOG
+Manifest
+README.md
+Rakefile
+bin/apache-configurator
+lib/apache.rb
+lib/apache/config.rb
+lib/apache/directory.rb
+lib/apache/logging.rb
+lib/apache/master.rb
+lib/apache/modules.rb
+lib/apache/mpm_prefork.rb
+lib/apache/performance.rb
+lib/apache/permissions.rb
+lib/apache/quoteize.rb
+lib/apache/rake/create.rb
+lib/apache/rewrites.rb
+lib/apache/ssl.rb
+skel/Rakefile
+skel/config.yml

data/README.md

@@ -0,0 +1,33 @@
+# Apache Config Generator
+
+Programmatically construct your Apache configuration using a powerful DSL built in Ruby.
+
+## Installation
+
+`gem install apache-config-generator`
+
+## Usage
+
+Run `apache-configurator <directory>` to create a new directory to hold your config files.
+A Rakefile and config.yml file will also be generated.
+
+## Building a config file
+
+Configs center around the Apache::Config.build method:
+
+		Apache::Config.build('sites-available/my-site.conf') do
+			server_name 'my-cool-website.cool.wow'
+			document_root '/var/www/my-cool-website'
+
+			directory '/' do
+				options :follow_sym_links, :indexes
+				allow_from_all
+			end
+
+			location_match %r{^/secret} do
+				deny_from_all
+
+				basic_authentication "My secret", '/etc/apache2/users/global.users', :user => :john
+				satisfy :any
+			end
+		end

data/Rakefile

@@ -0,0 +1,39 @@
+$LOAD_PATH << 'lib'
+
+require 'apache'
+require 'spec/rake/spectask'
+require 'sdoc'
+require 'sdoc_helpers/markdown'
+require 'echoe'
+
+namespace :apache do
+  desc "Generate the configs"
+  task :generate, :path do |t, args|
+    Dir[File.join(args[:path], '**', '*.rb')].each do |file|
+      require file
+    end
+  end
+end
+
+Echoe.new('apache-config-generator') do |p|
+  p.author = "John Bintz"
+  p.summary = "A Ruby DSL for programmatically generating Apache configs"
+  p.ignore_pattern = [ 'spec/**/*', 'test/**/*', 'docs/**/*' ]
+  p.executable_pattern = [ 'bin/**/*' ]
+end
+
+namespace :spec do
+  desc "Run RCov tests"
+  Spec::Rake::SpecTask.new('rcov') do |t|
+    t.spec_files = FileList['spec/*.rb']
+    t.rcov = true
+    t.rcov_opts = ['--exclude', 'spec', '--exclude', 'gems']
+    t.spec_opts = ['-b']
+  end
+end
+
+Rake::RDocTask.new do |rdoc|
+  rdoc.template = 'direct'
+  rdoc.rdoc_files.add('lib')
+  rdoc.rdoc_dir = 'docs'
+end

data/apache-config-generator.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{apache-config-generator}
+  s.version = "0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["John Bintz"]
+  s.date = %q{2010-05-10}
+  s.default_executable = %q{apache-configurator}
+  s.description = %q{A Ruby DSL for programmatically generating Apache configs}
+  s.email = %q{}
+  s.executables = ["apache-configurator"]
+  s.extra_rdoc_files = ["CHANGELOG", "README.md", "bin/apache-configurator", "lib/apache.rb", "lib/apache/config.rb", "lib/apache/directory.rb", "lib/apache/logging.rb", "lib/apache/master.rb", "lib/apache/modules.rb", "lib/apache/mpm_prefork.rb", "lib/apache/performance.rb", "lib/apache/permissions.rb", "lib/apache/quoteize.rb", "lib/apache/rake/create.rb", "lib/apache/rewrites.rb", "lib/apache/ssl.rb"]
+  s.files = ["CHANGELOG", "Manifest", "README.md", "Rakefile", "bin/apache-configurator", "lib/apache.rb", "lib/apache/config.rb", "lib/apache/directory.rb", "lib/apache/logging.rb", "lib/apache/master.rb", "lib/apache/modules.rb", "lib/apache/mpm_prefork.rb", "lib/apache/performance.rb", "lib/apache/permissions.rb", "lib/apache/quoteize.rb", "lib/apache/rake/create.rb", "lib/apache/rewrites.rb", "lib/apache/ssl.rb", "skel/Rakefile", "skel/config.yml", "apache-config-generator.gemspec"]
+  s.homepage = %q{}
+  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Apache-config-generator", "--main", "README.md"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{apache-config-generator}
+  s.rubygems_version = %q{1.3.6}
+  s.summary = %q{A Ruby DSL for programmatically generating Apache configs}
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/bin/apache-configurator

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+
+require 'fileutils'
+
+if File.directory? ARGV[0]
+	puts "You can't overwrite an existing directory."
+	exit 1
+end
+
+FileUtils.cp_r File.expand_path(File.join(File.dirname(__FILE__), '..', 'skel')), ARGV[0]
+FileUtils.mkdir_p File.join(ARGV[0], 'source')
+FileUtils.mkdir_p File.join(ARGV[0], 'conf.d')

data/lib/apache.rb

@@ -0,0 +1 @@
+require 'apache/config'

data/lib/apache/config.rb

@@ -0,0 +1,248 @@
+require 'fileutils'
+
+Dir[File.join(File.dirname(__FILE__), '*.rb')].each { |f| require f }
+
+module Apache
+  # The core class of Apache Config Generator.
+  #
+  # Configuration is built by calling either build or build_if:
+  #
+  # Ex: Build a config file regardless of current environment:
+  #
+  #  Apache::Config.build('my-config.conf') do
+  #    document_root '/my/document/root'
+  #    ...
+  #  end
+  #
+  # Ex: Build a config file only if you're in the development environment:
+  #
+  #  Apache::Config.build_if('my-config.conf', :development) do
+  #    document_root '/my/document/root'
+  #    ...
+  #  end
+  #
+  # By default, methods called within the block are NerdCapsed to match the Apache config directive format:
+  #
+  #  document_root #=> DocumentRoot
+  #  options #=> Options
+  #  allow_override #=> AllowOverride
+  #
+  # Parameters passed into the methods are quoted if they're Strings or Integers, and not quoted if they're Symbols:
+  #
+  #  document_root '/my/document/root' #=> DocumentRoot "/my/document/root"
+  #  document_root '/my/document/root'.to_sym #=> DocumentRoot /my/document/root
+  #  accept_path_info :off #=> AcceptPathInfo off
+  #
+  # Suffixing the method name with an exclamation point turns off quoting for all parameters:
+  #
+  #  document_root! '/my/document/root' #=> DocumentRoot /my/document/root
+  #
+  # Block-level directives work the same as the top-level build method:
+  #
+  #  directory '/my/site' do
+  #    allow_from_all
+  #    satisfy :any
+  #  end
+  #
+  # Directives that require a regular expression take a Regexp:
+  #
+  #  location_match %r{^/my/site} do
+  #     set_env 'this_is_my_site', 'yes'
+  #  end
+
+  class Config
+    class << self
+      attr_accessor :line_indent, :rotate_logs_path
+
+      include Apache::Master
+      include Apache::Quoteize
+      include Apache::Permissions
+      include Apache::Directories
+      include Apache::Logging
+      include Apache::Performance
+      include Apache::Rewrites
+      include Apache::MPM
+
+      # Build the provided configuration only if the current environment matches one of the conditions
+      def build_if(target, *conditions, &block)
+        build(target, &block) if conditions.include? APACHE_ENV
+      end
+
+      # Build the provided configuration
+      def build(target = nil, &block)
+        reset!
+
+        self.instance_eval(&block)
+
+        if target
+          FileUtils.mkdir_p File.split(target).first
+          File.open(target, 'w') { |f| f.puts [ "# Generated by apache-config-generator #{Time.now.to_s}", @config ].flatten * "\n" }
+        end
+
+        @config
+      end
+
+      # Reset the current settings
+      def reset!
+        @config = []
+        @line_indent = 0
+      end
+
+      # Indent the string by the current @line_indent level
+      def indent(string_or_array)
+        case string_or_array
+          when Array
+            string_or_array.collect { |s| indent(s) }
+          else
+            " " * (@line_indent * 2) + string_or_array.to_s
+        end
+      end
+
+      # Add the string to the current config
+      def <<(string)
+        @config << indent(string)
+      end
+
+      # Append the array to the current config
+      def +(other)
+        @config += other
+      end
+
+      # Get the config
+      def to_a
+        @config
+      end
+
+      # Apachify a string
+      #
+      # Split the provided name on underscores and capitalize the individual parts
+      # Certain character strings are capitalized to match Apache directive names:
+      # * Cgi => CGI
+      # * Ssl => SSL
+      # * Ldap => LDAP
+      def apachify(name)
+        case name
+          when String, Symbol
+            name.to_s.split("_").collect(&:capitalize).join.gsub('Ssl', 'SSL').gsub('Cgi', 'CGI').gsub('Ldap', 'LDAP').gsub('Url', 'URL')
+          when Array
+            name.collect { |n| apachify(n) }
+        end
+      end
+
+      # Handle options that aren't specially handled
+      #
+      # Method names are NerdCapsed and paramters are quoted, unless the method ends with !
+      def method_missing(method, *args)
+        if method.to_s[-1..-1] == "!"
+          method = method.to_s[0..-2].to_sym
+        else
+          args = *quoteize(*args)
+        end
+
+        self << [ apachify(method), *args ].compact * ' '
+      end
+
+      # Handle creating block methods
+      #
+      # Methods created this way are:
+      # * virtual_host
+      # * location
+      # * files
+      def block_methods(*methods)
+        methods.each do |method|
+          self.class.class_eval <<-EOT
+            def #{method}(*name, &block)
+              blockify(apachify("#{method}"), name, &block)
+            end
+          EOT
+        end
+      end
+
+      # If the given module is loaded, process the directives within.
+      #
+      # The provided module name is converted into Apache module name format:
+      #  if_module(:php5) do #=> <IfModule mod_php5>
+      def if_module(mod, &block)
+        blockify(apachify('if_module'), "#{mod}_module".to_sym, &block)
+      end
+
+      # Create a directory block, checking to see if the source directory exists.
+      def directory(dir, &block)
+        directory? dir
+        blockify(apachify('directory'), dir, &block)
+      end
+
+      # Create a LocationMatch block with the provided Regexp:
+      #  location_match %r{^/my/location/[a-z0-9]+\.html} do #=> <LocationMatch "^/my/location/[a-z0-9]+\.html">
+      def location_match(regexp, &block)
+        blockify(apachify('location_match'), regexp.source, &block)
+      end
+
+      # Create a FilesMatch block with the provied Regexp:
+      #  files_match %r{\.html$} do #=> FilesMatch "\.html$">
+      def files_match(regexp, &block)
+        blockify(apachify('files_match'), regexp.source, &block)
+      end
+
+      # Only execute the provided block if APACHE_ENV matches one of the provided enviroment symbols:
+      #  if_environment(:production) do
+      def if_environment(*env, &block)
+        self.instance_eval(&block) if env.include?(APACHE_ENV)
+      end
+
+      # Blockify the second parameter of a block
+      #
+      # The name is processed differently based on input object type:
+      # * String - the name is quoteized
+      # * Array - all of the array members are quoteized
+      # * Symbol - the name is to_s
+      def blockify_name(name)
+        case name
+          when String
+            quoteize(name).first
+          when Array
+            (quoteize(*name) * " ")
+          when Symbol
+            name.to_s
+        end
+      end
+
+      # Handle the blockification of a provided block
+      def blockify(tag_name, name, &block)
+        self << ""
+        self << "<#{[ tag_name, blockify_name(name) ].compact * ' '}>"
+        @line_indent += 1
+        self.instance_eval(&block)
+        @line_indent -= 1
+        self << "</#{tag_name}>"
+        self << ""
+      end
+
+      # Build a string that invokes Apache's rotatelogs command
+      def rotatelogs(path, time)
+        begin
+          time = time.to_i
+        rescue
+          raise "Time should be an integer: #{path} #{time}"
+        end
+
+        "|#{@rotate_logs_path} #{path} #{time}"
+      end
+
+      private
+        def writable?(path)
+          puts "[warn] #{path} may not be writable!" if !File.directory? File.split(path).first
+        end
+
+        def directory?(path)
+          puts "[warn] #{path} does not exist!" if !File.directory? path
+        end
+
+        def exist?(path)
+          puts "[warn] #{path} does not exist!" if !File.exist?(path)
+        end
+    end
+
+    block_methods :virtual_host, :location, :files
+  end
+end

data/lib/apache/directory.rb

@@ -0,0 +1,25 @@
+module Apache
+  # Methods to handle directory settings
+  module Directories
+    # Create an Options directive
+    #
+    # The options passed into this method are Apachified:
+    #  options :exec_cgi, :follow_sym_links #=> Options ExecCGI FollowSymLinks
+    def options(*opt)
+      create_options_list('Options', *opt)
+    end
+
+    # Create an IndexOptions directive
+    #
+    # The options passed into this method are Apachified:
+    #  index_options :fancy_indexing, :suppress_description #=> IndexOptions FancyIndexing SuppressDescription
+    def index_options(*opt)
+      create_options_list('IndexOptions', *opt)
+    end
+
+    private
+      def create_options_list(tag, *opt)
+        self << "#{tag} #{apachify(opt) * " "}"
+      end
+  end
+end

data/lib/apache/logging.rb

@@ -0,0 +1,45 @@
+module Apache
+  # Methods to handle logging configuration are defined here.
+  #
+  # For each of the four main log types (Custom, Error, Script, and Rewrite), the following two methods are created:
+  #
+  # * (type)_log: A non-rotated log file
+  # * rotate_(type)_log: A rotated log file
+  #
+  # Non-rotated logs work as such:
+  #  custom_log "/path/to/log/file.log", :common #=> CustomLog "/path/to/log/file.log" common
+  #
+  # Rotated logs work as such:
+  #  rotate_custom_log "/path/to/log/file-%Y%m%d.log", 86400, :common
+  #    #=> CustomLog "|/path/to/rotatelogs /path/to/log/file-%Y%m%d.jpg 86400" common
+  #
+  # Both variations check to make sure the log file diretory exists during generation.
+  # The rotate_ variations need @rotate_logs_path set to work.
+  module Logging
+    [ :custom, :error, :script, :rewrite ].each do |type|
+      class_eval <<-EOT
+        def #{type}_log(*opts)
+          handle_log '#{type.to_s.capitalize}Log', opts.first, quoteize(opts.first), opts[1..-1]
+        end
+
+        def rotate_#{type}_log(*opts)
+          handle_log '#{type.to_s.capitalize}Log', opts.first, quoteize(rotatelogs(*opts[0..1])), opts[2..-1]
+        end
+      EOT
+    end
+
+    def combined_log_format(name = 'combined')
+      log_format '%h %l %u %t \"%r\" %>s %b \"%{Referer}i\" \"%{User-Agent}i\"', name.to_sym
+    end
+
+    def common_log_format(name = 'common')
+      log_format '%h %l %u %t \"%r\" %>s %b', name.to_sym
+    end
+
+    private
+      def handle_log(tag, path, real_path, *opts)
+        writable? path
+        self << "#{tag} #{[real_path, opts].flatten * " "}"
+      end
+  end
+end

data/lib/apache/master.rb

@@ -0,0 +1,105 @@
+module Apache
+  # Options that aren't specific to a particular purpose go here. Once enough like methods for a
+  # particular purpose exist, break them out into a separate module.
+  module Master
+    # Build a module list.
+    # Wraps around Modules.build
+    def modules(*modules, &block)
+      @config += Modules.build(*modules, &block)
+    end
+
+    # Add a User/Group block
+    #  runner('www', 'www-data') #=>
+    #    User www
+    #    Group www-data
+    def runner(user, group = nil)
+      user! user
+      group! group if group
+    end
+
+    # Enable Passenger on this server
+    #
+    # This assumes that Passenger was installed via the gem. This may or may not work for you, but it works for me.
+    def passenger(ruby_root, ruby_version, passenger_version)
+      load_module 'passenger_module', "#{ruby_root}/lib/ruby/gems/#{ruby_version}/gems/passenger-#{passenger_version}/ext/apache2/mod_passenger.so"
+      passenger_root "#{ruby_root}/lib/ruby/gems/#{ruby_version}/gems/passenger-#{passenger_version}"
+      passenger_ruby "#{ruby_root}/bin/ruby"
+    end
+
+    # Enable gzip compression server-wide on pretty much everything that can be gzip compressed
+    def enable_gzip!
+      directory '/' do
+        add_output_filter_by_type! :DEFLATE, 'text/html', 'text/plain', 'text/css', 'text/javascript', 'application/javascript'
+        browser_match! '^Mozilla/4', "gzip-only-text/html"
+        browser_match! '^Mozilla/4\.0[678]', "no-gzip"
+        browser_match! '\bMSIE', '!no-gzip', '!gzip-only-text/html'
+      end
+    end
+
+    # Set the TCP timeout. Defined here to get around various other timeout methods.
+    def timeout(t)
+      self << "Timeout #{t}"
+    end
+
+    # Add a comment to the Apache config. Can pass in either a String or Array of comment lines.
+    def comment(c)
+      out = [ '' ]
+      case c
+        when String
+          out += c.split("\n")
+        when Array
+          out += c
+      end
+      out << ''
+      self + out.collect { |line| "# #{line.strip}".strip }
+    end
+
+    # Create a ScriptAlias, checking to make sure the filesystem path exists.
+    def script_alias(uri, path)
+      directory? path
+      self << %{ScriptAlias #{quoteize(uri, path) * ' '}}
+    end
+
+    alias :script_alias! :script_alias
+
+    # Add a MIME type, potentially also adding handlers and encodings
+    #  add_type! 'text/html', '.shtml', :handler => 'server-parsed'
+    #  add_type! 'text/html', '.gz', :encoding => 'gzip'
+    def add_type!(mime, extension, options = {})
+      self << "AddType #{mime} #{extension}"
+      options.each do |type, value|
+        self << "Add#{type.to_s.capitalize} #{value} #{extension}"
+      end
+    end
+
+    # Include other config files or directories.
+    # Used to get around reserved Ruby keyword.
+    def apache_include(*opts)
+      self << "Include #{opts * " "}"
+    end
+
+    # Alias a URL to a directory in the filesystem.
+    # Used to get around reserved Ruby keyword.
+    def apache_alias(*opts)
+      self << "Alias #{quoteize(*opts) * " "}"
+    end
+
+    # Set multiple headers to be delivered for a particular section
+    #  set_header 'Content-type' => 'application/octet-stream',
+    #             'Content-disposition' => [ 'attachment', 'env=only-for-downloads' ] #=>
+    #  Header set "Content-type" "application/octet-stream"
+    #  Header set "Content-dispoaition" "attachment" env=only-for-downloads
+    def set_header(hash)
+      hash.each do |key, value|
+        output = "Header set #{quoteize(key)}"
+        case value
+          when String, Symbol
+            output += " #{quoteize(value)}"
+          when Array
+            output += " #{quoteize(value.first)} #{value.last}"
+        end
+        self << output
+      end
+    end
+  end
+end

data/lib/apache/modules.rb

@@ -0,0 +1,44 @@
+require 'apache/quoteize'
+
+module Apache
+  # Create lists of modules to load in the Apache 2.2 style (with LoadModule only)
+  class Modules
+    class << self
+      include Apache::Quoteize
+
+      attr_accessor :modules
+
+      # Reset the list of modules to output
+      def reset!
+        @modules = []
+      end
+
+      # Build a block of LoadModule commands
+      #
+      #  Apache::Modules.build(:expires, :headers) do
+      #    funky "/path/to/funky/module.so"
+      #  end
+      #
+      # becomes:
+      #
+      #  LoadModule "expires_module" "modules/mod_expires.so"
+      #  LoadModule "headers_module" "modules/mod_headers.so"
+      #  LoadModule "funky_module" "/path/to/funky/module.so"
+      def build(*modules, &block)
+        reset!
+
+        modules.each { |m| self.send(m) }
+        self.instance_eval(&block) if block
+
+        [ '' ] + @modules + [ '' ]
+      end
+
+      # The method name becomes the module core name
+      def method_missing(method, *args)
+        module_name = "#{method}_module"
+        module_path = args[0] || "modules/mod_#{method}.so"
+        @modules << [ 'LoadModule', *quoteize(module_name, module_path) ] * " "
+      end
+    end
+  end
+end

data/lib/apache/mpm_prefork.rb

@@ -0,0 +1,59 @@
+module Apache
+  module MPM
+    # Set up the Prefork MPM
+    #
+    #  prefork_config do
+    #    start 5
+    #    spares 5, 20
+    #    limit 100
+    #    clients 100
+    #    max_requests 1000
+    #  end
+    #
+    # becomes:
+    #
+    #  StartServers 5
+    #  MinSpareServers 5
+    #  MaxSpareServers 20
+    #  ServerLimit 100
+    #  MaxClients 100
+    #  MaxRequestsPerChild 1000
+    #
+    def prefork_config(&block)
+      self + Apache::MPM::Prefork.build(&block)
+    end
+
+    # Builder for Prefork MPM
+    # See Apache::MPM::prefork_config for usage.
+    class Prefork
+      class << self
+        def build(&block)
+          @config = ['', '# Prefork config', '']
+
+          self.instance_eval(&block)
+
+          @config
+        end
+
+        def method_missing(method, *opts)
+          if which = {
+            :start => 'StartServers',
+            :spares => [ 'MinSpareServers', 'MaxSpareServers' ],
+            :limit => 'ServerLimit',
+            :clients => 'MaxClients',
+            :max_requests => 'MaxRequestsPerChild'
+          }[method]
+            case which
+              when String
+                @config << "#{which} #{opts * " "}"
+              when Array
+                which.each do |w|
+                  @config << "#{w} #{opts.shift}"
+                end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/apache/performance.rb

@@ -0,0 +1,22 @@
+module Apache
+  # Options to adjust server performance beyond MPM settings
+  module Performance
+    # Activate KeepAlive, optionally tweaking max requests and timeout
+    #
+    #  activate_keepalive :requests => 100, :timeout => 5 #=>
+    #    KeepAlive on
+    #    MaxKeepAliveRequests 100
+    #    KeepAliveTimeout 5
+    def activate_keepalive(options)
+      self << "KeepAlive On"
+      options.each do |option, value|
+        case option
+          when :requests
+            self << "MaxKeepAliveRequests #{value}"
+          when :timeout
+            self << "KeepAliveTimeout #{value}"
+        end
+      end
+    end
+  end
+end

data/lib/apache/permissions.rb

@@ -0,0 +1,91 @@
+module Apache
+  # Configure server access permissions
+  module Permissions
+    # Shortcut for denying all access to a block
+    def deny_from_all
+      order :deny, :allow
+      deny :from_all
+    end
+
+    alias :deny_from_all! :deny_from_all
+
+    # Shortcut for allowing all access to a block
+    def allow_from_all
+      order :allow, :deny
+      allow :from_all
+    end
+
+    alias :allow_from_all! :allow_from_all
+
+    # Define IP block restrictions
+    #
+    #  allow_from '127.0.0.1' #=> Allow from "127.0.0.1"
+    def allow_from(*where)
+      self << "Allow from #{quoteize(*where) * " "}"
+    end
+
+    # Specify default access order
+    #
+    #  order :allow, :deny #=> Order allow,deny
+    def order(*args)
+      self << "Order #{args * ','}"
+    end
+
+    alias :order! :order
+
+    # Set up default restrictive permissions
+    def default_restrictive!
+      directory '/' do
+        options :follow_sym_links
+        allow_override :none
+        deny_from_all
+      end
+    end
+
+    # Block all .ht* files
+    def no_htfiles!
+      files_match %{^\.ht} do
+        deny_from_all
+        satisfy :all
+      end
+    end
+
+    # Set up basic authentication
+    #
+    # Check to make sure the defined users_file exists
+    #
+    #  basic_authentication "My secret", '/my.users', 'valid-user' => true
+    #  basic_authentication "My other secret", '/my.users', :user => [ :john ]
+    def basic_authentication(zone, users_file, requires = {})
+      exist? users_file
+      auth_type :basic
+      auth_name zone
+      auth_user_file users_file
+      requires.each do |type, values|
+        apache_require type, *values
+      end
+    end
+
+    alias :basic_authentication! :basic_authentication
+
+    # Set up LDAP authentication
+    def ldap_authentication(zone, url, requires = {})
+      auth_type :basic
+      auth_name zone
+      auth_basic_provider :ldap
+      authz_ldap_authoritative :on
+      auth_ldap_url url
+      requires.each do |type, values|
+        apache_require type, *values
+      end
+    end
+
+    alias :ldap_authentication! :ldap_authentication
+
+    # Create an Apache require directive.
+    # Used to get around Ruby reserved word.
+    def apache_require(*opts)
+      self << "Require #{opts * " "}"
+    end
+  end
+end

data/lib/apache/quoteize.rb

@@ -0,0 +1,16 @@
+module Apache
+  # Add quotes around parameters as needed
+  module Quoteize
+    # Add quotes around most parameters, and don't add quotes around Symbols
+    def quoteize(*args)
+      args.collect do |arg|
+        case arg
+          when Symbol
+            arg.to_s.gsub('_', ' ')
+          else
+            %{"#{arg}"}
+        end
+      end
+    end
+  end
+end

data/lib/apache/rake/create.rb

@@ -0,0 +1,26 @@
+require 'fileutils'
+require 'apache/config'
+require 'apache/rake/create'
+require 'yaml'
+
+namespace :apache do
+  desc "Create all defined configs for the specified environment"
+  task :create, :environment do |t, args|
+    APACHE_ENV = (args[:environment] || 'production').to_sym
+
+    CONFIG = Hash[YAML.load_file('config.yml').collect { |k,v| [ k.to_sym, v ] }]
+
+    CONFIG[:source_path] = File.expand_path(CONFIG[:source])
+    CONFIG[:dest_path] = File.expand_path(CONFIG[:destination])
+
+    Apache::Config.rotate_logs_path = CONFIG[:rotate_logs_path]
+
+    FileUtils.mkdir_p CONFIG[:dest_path]
+    Dir.chdir CONFIG[:dest_path]
+
+    Dir[File.join(CONFIG[:source_path], '**', '*.rb')].each do |file|
+      puts file
+      require file
+    end
+  end
+end

data/lib/apache/rewrites.rb

@@ -0,0 +1,297 @@
+module Apache
+  # Handle the creation of RewriteRules, RewriteConds, Redirects, and RedirectMatches
+  module Rewrites
+    # Enable the rewrite engine, optionally setting the logging level
+    #
+    #  enable_rewrite_engine :log_level => 1 #=>
+    #    RewriteEngine on
+    #    RewriteLogLevel 1
+    def enable_rewrite_engine(options)
+      self << ''
+      rewrite_engine! :on
+      options.each do |option, value|
+        case option
+          when :log_level
+            rewrite_log_level! value
+        end
+      end
+      self << ''
+    end
+
+    # Pass the block to RewriteManager.build
+    def rewrites(&block)
+      self + indent(RewriteManager.build(&block))
+      self << ''
+    end
+
+    # Create a permanent Redirect
+    #
+    #  r301 '/here', '/there' #=> Redirect permanent "/here" "/there"
+    def r301(*opt)
+      self << "Redirect permanent #{quoteize(*opt) * " "}"
+    end
+  end
+
+  # Handle the creation of Rewritable things
+  class RewriteManager
+    class << self
+      attr_accessor :rewrites
+
+      # Reset the current list of rewrites
+      def reset!
+        @rewrites = []
+      end
+
+      # Build rewritable things from the provided block
+      def build(&block)
+        reset!
+
+        self.instance_eval(&block)
+
+        @rewrites.collect(&:to_a).flatten
+      end
+
+      # Commit the latest rewritable thing to the list of rewrites
+      def commit!
+        @rewrites << @rewrite
+        @rewrite = nil
+      end
+
+      # Ensure that there's a RewriteRule to be worked with
+      def ensure_rewrite!
+        @rewrite = RewriteRule.new if !@rewrite
+      end
+
+      # Create a RewriteRule with the given options
+      #
+      #  rewrite %r{/here(.*)}, '/there$1', :last => true #=>
+      #    RewriteRule "/here(.*)" "/there$1" [L]
+      def rewrite(*opts)
+        ensure_rewrite!
+        @rewrite.rule(*opts)
+        commit!
+      end
+
+      alias :rule :rewrite
+
+      # Create a RewriteCond with the given options
+      #
+      #  cond "%{REQUEST_FILENAME}", "^/here" #=>
+      #    RewriteCond "%{REQUEST_FILENAME}", "^/here"
+      def cond(*opts)
+        ensure_rewrite!
+        @rewrite.cond(*opts)
+      end
+
+      # Create a permanent RedirectMatch
+      #
+      #  r301 %r{/here(.*)}, "/there$1" #=>
+      #    RedirectMatch permanent "/here(.*)" "/there$1"
+      def r301(*opts)
+        redirect = RedirectMatchPermanent.new
+        redirect.rule(*opts)
+
+        @rewrites << redirect
+      end
+
+      # Test the rewritable things defined in this block
+      def rewrite_test(from, to, opts = {})
+        orig_from = from.dup
+        @rewrites.each do |r|
+          from = r.test(from, opts)
+        end
+
+        if from != to
+          puts "[warn] #{orig_from} >> #{to} failed!"
+          puts "[warn] Result: #{from}"
+        end
+      end
+    end
+  end
+
+  # Common methods for testing rewritable things that use regular expressions
+  module RegularExpressionMatcher
+    # Test this rewritable thing
+    def test(from, opts = {})
+      from = from.gsub(@from, @to.gsub(/\$([0-9])/) { |m| '\\' + $1 })
+      replace_placeholders(from, opts)
+    end
+
+    # Replace the placeholders in this rewritable thing
+    def replace_placeholders(s, opts)
+      opts.each do |opt, value|
+        case value
+          when String
+            s = s.gsub('%{' + opt.to_s.upcase + '}', value)
+        end
+      end
+      s
+    end
+  end
+
+  # A matchable thing to be extended
+  class MatchableThing
+    include Apache::Quoteize
+
+    # The Apache directive tag for this thing
+    def tag; raise 'Override this method'; end
+
+    def initialize
+      @from = nil
+      @to = nil
+    end
+
+    def rule(from, to)
+      @from = from
+      @to = to
+    end
+
+    def to_s
+      "#{tag} #{[quoteize(@from), quoteize(@to)].compact.flatten * " "}"
+    end
+
+    def to_a
+      [ to_s ]
+    end
+  end
+
+  # A RewriteRule definition
+  class RewriteRule < MatchableThing
+    include RegularExpressionMatcher
+
+    def tag; 'RewriteRule'; end
+
+    def initialize
+      super
+      @conditions = []
+      @options = nil
+    end
+
+    # Define the rule, passing in additional options
+    #
+    # rule %r{^/here}, '/there', { :last => true, :preserve_query_string => true }
+    def rule(from, to,options = {})
+      super(from, to)
+
+      raise "from must be a Regexp" if !from.kind_of?(Regexp)
+
+      options = options.collect do |key, value|
+        case key
+          when :last
+            'L'
+          when :preserve_query_string
+            'QSA'
+        end
+      end.sort
+
+      @options = !options.empty? ? "[#{options * ','}]" : nil
+    end
+
+    # Add a RewriteCondition to this RewriteRule
+    def cond(from, to, *opts)
+      rewrite_cond = RewriteCondition.new
+      rewrite_cond.cond(from, to, *opts)
+
+      @conditions << rewrite_cond
+    end
+
+    def to_s
+      "#{tag} #{[quoteize(@from.source), quoteize(@to), @options].compact.flatten * " "}"
+    end
+
+    def to_a
+      [ @conditions.collect(&:to_s), super ].flatten
+    end
+
+    # Test this RewriteRule, ensuring the RewriteConds also match
+    def test(from, opts = {})
+      ok = true
+      @conditions.each do |c|
+        ok = false if !c.test(from, opts)
+      end
+
+      if ok
+        super(from, opts)
+      else
+        replace_placeholders(from, opts)
+      end
+    end
+  end
+
+  # A permanent RedirectMatch
+  class RedirectMatchPermanent < MatchableThing
+    include RegularExpressionMatcher
+
+    def tag; 'RedirectMatch permanent'; end
+
+    def rule(from, to)
+      super(from, to)
+
+      raise "from must be a Regexp" if !from.kind_of?(Regexp)
+    end
+
+    def to_s
+      "#{tag} #{[quoteize(@from.source), quoteize(@to)].compact.flatten * " "}"
+    end
+  end
+
+  # A RewriteCond
+  class RewriteCondition < MatchableThing
+    include RegularExpressionMatcher
+
+    def tag; 'RewriteCond'; end
+
+    # Define a RewriteCond
+    #
+    #  rule "%{REQUEST_FILENAME}", "^/here", :case_insensitive #=>
+    #    RewriteCond "%{REQUEST_FILENAME}" "^/here" [NC]
+    def rule(from, to, *opts)
+      super(from, to)
+
+      options = opts.collect do |opt|
+        case opt
+          when :or
+            'OR'
+          when :case_insensitive
+            'NC'
+          when :no_vary
+            'NV'
+        end
+      end
+
+      @options = (!options.empty?) ? "[#{options * ','}]" : nil
+    end
+
+    alias :cond :rule
+
+    def initialize
+      super
+      @options = nil
+    end
+
+    def to_s
+      "#{tag} #{[quoteize(@from), quoteize(@to), @options].compact.flatten * " "}"
+    end
+
+    # Test this RewriteCond
+    def test(from, opts = {})
+      super(from, opts)
+      source = replace_placeholders(@from, opts)
+
+      result = false
+      case @to[0..0]
+        when '!'
+          result = !source[Regexp.new(@to[1..-1])]
+        when '-'
+          case @to
+            when '-f'
+              result = opts[:files].include? source if opts[:files]
+          end
+        else
+          result = source[Regexp.new(@to)]
+      end
+
+      result
+    end
+  end
+end

data/skel/Rakefile

@@ -0,0 +1,3 @@
+require 'rubygems'
+
+require 'apache/rake/create'

data/skel/config.yml

@@ -0,0 +1,3 @@
+source:       "source"
+destination:  "conf.d"
+rotate_logs_path: '/path/to/apache/bin/rotatelogs'

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification 
+name: apache-config-generator
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  version: "0.1"
+platform: ruby
+authors: 
+- John Bintz
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-05-10 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: A Ruby DSL for programmatically generating Apache configs
+email: ""
+executables: 
+- apache-configurator
+extensions: []
+
+extra_rdoc_files: 
+- CHANGELOG
+- README.md
+- bin/apache-configurator
+- lib/apache.rb
+- lib/apache/config.rb
+- lib/apache/directory.rb
+- lib/apache/logging.rb
+- lib/apache/master.rb
+- lib/apache/modules.rb
+- lib/apache/mpm_prefork.rb
+- lib/apache/performance.rb
+- lib/apache/permissions.rb
+- lib/apache/quoteize.rb
+- lib/apache/rake/create.rb
+- lib/apache/rewrites.rb
+- lib/apache/ssl.rb
+files: 
+- CHANGELOG
+- Manifest
+- README.md
+- Rakefile
+- bin/apache-configurator
+- lib/apache.rb
+- lib/apache/config.rb
+- lib/apache/directory.rb
+- lib/apache/logging.rb
+- lib/apache/master.rb
+- lib/apache/modules.rb
+- lib/apache/mpm_prefork.rb
+- lib/apache/performance.rb
+- lib/apache/permissions.rb
+- lib/apache/quoteize.rb
+- lib/apache/rake/create.rb
+- lib/apache/rewrites.rb
+- lib/apache/ssl.rb
+- skel/Rakefile
+- skel/config.yml
+- apache-config-generator.gemspec
+has_rdoc: true
+homepage: ""
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --line-numbers
+- --inline-source
+- --title
+- Apache-config-generator
+- --main
+- README.md
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 2
+      version: "1.2"
+requirements: []
+
+rubyforge_project: apache-config-generator
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: A Ruby DSL for programmatically generating Apache configs
+test_files: []
+