nginxtra 1.0.15.0

data/VERSION

@@ -0,0 +1 @@
+1.0.15.0

data/bin/nginxtra

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+require "rubygems"
+gem "nginxtra", "= 1.0.15.0"
+require "nginxtra"
+Nginxtra::CLI.start

data/lib/nginxtra.rb

@@ -0,0 +1,12 @@
+require "nginxtra/action"
+require "nginxtra/actions/compile"
+require "nginxtra/actions/install"
+require "nginxtra/actions/reload"
+require "nginxtra/actions/restart"
+require "nginxtra/actions/start"
+require "nginxtra/actions/status"
+require "nginxtra/actions/stop"
+require "nginxtra/cli"
+require "nginxtra/config"
+require "nginxtra/error"
+require "nginxtra/status"

data/lib/nginxtra/action.rb

@@ -0,0 +1,36 @@
+module Nginxtra
+  module Action
+    def initialize(thor, config)
+      @thor = thor
+      @config = config
+    end
+
+    # Run a daemon command to start or stop the nginx process.
+    def daemon(action, additional_options = nil)
+      action = "#{action} #{additional_options}" if additional_options
+      run! "#{sudo}start-stop-daemon --#{action} --quiet --pidfile #{Nginxtra::Config.nginx_pidfile} --exec #{Nginxtra::Config.nginx_executable}"
+    end
+
+    private
+    def run!(command)
+      @thor.run command
+      raise Nginxtra::Error::RunFailed.new("The last run command failed") unless $?.success?
+    end
+
+    def force?
+      @thor.options["force"]
+    end
+
+    def interactive?
+      !non_interactive?
+    end
+
+    def non_interactive?
+      @thor.options["non-interactive"]
+    end
+
+    def sudo(force = false)
+      "sudo " if (force || @config.require_root?) && Process.uid != 0
+    end
+  end
+end

data/lib/nginxtra/actions/compile.rb

@@ -0,0 +1,60 @@
+module Nginxtra
+  module Actions
+    # The Nginxtra::Actions::Compile class encapsulates compiling
+    # nginx so it is ready with the specified compile options.  An
+    # optional option of :force can be passed with true to make
+    # compilation happen no matter what.
+    class Compile
+      include Nginxtra::Action
+
+      # Run the full compilation of nginx.
+      def compile
+        return up_to_date unless should_compile?
+        copy_to_base
+        configure
+        make
+        make "install"
+        update_last_compile
+      end
+
+      # Copy the nginx source directory to the base directory.
+      def copy_to_base
+        @thor.directory "src/nginx", Nginxtra::Config.src_dir
+      end
+
+      # Configure nginx with the specified compile options.
+      def configure
+        @thor.inside Nginxtra::Config.src_dir do
+          run! "sh configure --prefix=#{Nginxtra::Config.build_dir} --conf-path=#{Nginxtra::Config.nginx_config} --pid-path=#{Nginxtra::Config.nginx_pidfile} #{@config.compile_options}"
+        end
+      end
+
+      # Run make against the configured nginx.
+      def make(*args)
+        @thor.inside Nginxtra::Config.src_dir do
+          run! ["make", *args].join(" ")
+        end
+      end
+
+      # Determine if compiling should happen.  This will return false
+      # if the last compile options equal the current options, or if
+      # the force option was passed in at construction time.
+      def should_compile?
+        return true if force?
+        Nginxtra::Status[:last_compile_options] != @config.compile_options
+      end
+
+      # Update Nginxtra::Status with the last compile time and
+      # options.
+      def update_last_compile
+        Nginxtra::Status[:last_compile_options] = @config.compile_options
+        Nginxtra::Status[:last_compile_time] = Time.now
+      end
+
+      # Notify the user that the compilation is up to date
+      def up_to_date
+        @thor.say "nginx compilation is up to date"
+      end
+    end
+  end
+end

data/lib/nginxtra/actions/install.rb

@@ -0,0 +1,99 @@
+module Nginxtra
+  module Actions
+    # The Nginxtra::Actions::Install class encapsulates installing
+    # nginxtra so that nginx can be started and stopped automatically
+    # when the server is started or stopped.
+    class Install
+      include Nginxtra::Action
+
+      # Run the installation of nginxtra, but only after first
+      # prompting if the user wants the install.  This will do nothing
+      # if run with --non-interactive mode.
+      def optional_install
+        return installation_skipped if non_interactive?
+        return up_to_date unless should_install?
+        return unless requesting_install?
+        install
+      end
+
+      # Run the installation of nginxtra.
+      def install
+        return up_to_date unless should_install?
+        create_etc_script
+        remember_config_location
+        update_last_install
+      end
+
+      # Create a script in the base directory which be symlinked to
+      # /etc/init.d/nginxtra and then used to start and stop nginxtra
+      # via update-rc.d.
+      def create_etc_script
+        filename = "etc.init.d.nginxtra"
+
+        @thor.inside Nginxtra::Config.base_dir do
+          @thor.create_file filename, %{#!/bin/sh
+
+### BEGIN INIT INFO
+# Provides:          nginxtra
+# Required-Start:    $all
+# Required-Stop:     $all
+# Default-Start:     2 3 4 5
+# Default-Stop:      0 1 6
+# Short-Description: starts nginxtra, which is a wrapper around the nginx web server
+# Description:       starts nginxtra which starts nginx using start-stop-daemon
+### END INIT INFO
+
+export GEM_HOME="#{ENV["GEM_HOME"]}"
+export GEM_PATH="#{ENV["GEM_PATH"]}"
+#{Nginxtra::Config.ruby_path} "#{File.join Nginxtra::Config.gem_dir, "bin/nginxtra"}" "$1" --basedir="#{Nginxtra::Config.base_dir}" --config="#{Nginxtra::Config.loaded_config_path}" --non-interactive
+}, :force => true
+          @thor.chmod filename, 0755
+        end
+
+        run! %{#{sudo true}rm /etc/init.d/nginxtra && #{sudo true}ln -s "#{File.join Nginxtra::Config.base_dir, filename}" /etc/init.d/nginxtra}
+        run! %{#{sudo true}update-rc.d nginxtra defaults}
+      end
+
+      # Notify the user that installation should be up to date.
+      def up_to_date
+        @thor.say "nginxtra installation is up to date"
+      end
+
+      # Notify to the user that installation is being skipped.
+      def installation_skipped
+        @thor.say "skipping nginxtra installation"
+      end
+
+      # Remember the last config location, and use it unless the
+      # config is explicitly passed in.
+      def remember_config_location
+        # Absolute path somehow turns the path to a binary string when
+        # output to Yaml... so make it a string so it stays ascii
+        # readable.
+        Nginxtra::Status[:remembered_config] = Nginxtra::Config.loaded_config_path.to_s
+      end
+
+      # Mark the last installed version and last installed time (the
+      # former being used to determine if nginxtra has been installed
+      # yet).
+      def update_last_install
+        Nginxtra::Status[:last_install_version] = Nginxtra::Config.version
+        Nginxtra::Status[:last_install_time] = Time.now
+      end
+
+      # Ask the user if they wish to install.  Return whether the user
+      # requests the install.
+      def requesting_install?
+        @thor.yes? "Would you like to install nginxtra?"
+      end
+
+      # Determine if the install should proceed.  This will be true if
+      # the force option was used, or if this version of nginxtra
+      # differs from the last version installed.
+      def should_install?
+        return true if force?
+        Nginxtra::Status[:last_install_version] != Nginxtra::Config.version
+      end
+    end
+  end
+end

data/lib/nginxtra/actions/reload.rb

@@ -0,0 +1,14 @@
+module Nginxtra
+  module Actions
+    # The Nginxtra::Actions::Reload class encapsulates reloading nginx.
+    class Reload
+      include Nginxtra::Action
+
+      # Reload nginx.
+      def reload
+        daemon :stop, "--signal HUP"
+        Nginxtra::Status[:last_reload_time] = Time.now
+      end
+    end
+  end
+end

data/lib/nginxtra/actions/restart.rb

@@ -0,0 +1,15 @@
+module Nginxtra
+  module Actions
+    # The Nginxtra::Actions::Restart class encapsulates restarting nginx.
+    class Restart
+      include Nginxtra::Action
+
+      # Restart nginx by stopping and starting.
+      def restart
+        Nginxtra::Actions::Stop.new(@thor, @config).stop
+        sleep 1
+        Nginxtra::Actions::Start.new(@thor, @config).start
+      end
+    end
+  end
+end

data/lib/nginxtra/actions/start.rb

@@ -0,0 +1,53 @@
+module Nginxtra
+  module Actions
+    # The Nginxtra::Actions::Compile class encapsulates starting nginx
+    # with the specified configuration file.  It also makes sure that
+    # nginx has been compiled with the correct options.
+    class Start
+      include Nginxtra::Action
+
+      # First, ensure nginx has been compiled, then make sure
+      # configuration is correct, and finally start nginx and note the
+      # start time.
+      def start
+        compile
+        install
+        save_config_files
+        start_nginx
+        update_last_start
+      end
+
+      # Invoke nginx compilation, to ensure it is up to date.
+      def compile
+        Nginxtra::Actions::Compile.new(@thor, @config).compile
+      end
+
+      # Invoke nginxtra installation, but only if the user allows it.
+      def install
+        Nginxtra::Actions::Install.new(@thor, @config).optional_install
+      end
+
+      # Save nginx config files to the proper config file path.
+      def save_config_files
+        files = @config.files
+        raise Nginxtra::Error::InvalidConfig.new("Missing definition for nginx.conf") unless files.include? "nginx.conf"
+
+        @thor.inside Nginxtra::Config.config_dir do
+          files.each do |filename|
+            @thor.create_file filename, @config.file_contents(filename), :force => true
+          end
+        end
+      end
+
+      # Start nginx as a daemon.
+      def start_nginx
+        daemon :start
+      end
+
+      # Update the last nginx start time.
+      def update_last_start
+        Nginxtra::Status[:last_start_time] = Time.now
+      end
+    end
+  end
+end

data/lib/nginxtra/actions/status.rb

@@ -0,0 +1,31 @@
+module Nginxtra
+  module Actions
+    # The Nginxtra::Actions::Status class encapsulates checking on the
+    # status of nginx (whether or not it is running based on the pid
+    # file).
+    class Status
+      include Nginxtra::Action
+
+      def status
+        @thor.say "The nginx server status: #{colored_message}"
+      end
+
+      def colored_message
+        if running?
+          @thor.set_color "running", :green, true
+        else
+          @thor.set_color "stopped", :red, true
+        end
+      end
+
+      def running?
+        return false unless File.exists? Nginxtra::Config.nginx_pidfile
+        pid = File.read(Nginxtra::Config.nginx_pidfile).strip
+        Process.getpgid pid.to_i
+        true
+      rescue Errno::ESRCH
+        false
+      end
+    end
+  end
+end

data/lib/nginxtra/actions/stop.rb

@@ -0,0 +1,14 @@
+module Nginxtra
+  module Actions
+    # The Nginxtra::Actions::Stop class encapsulates stopping nginx.
+    class Stop
+      include Nginxtra::Action
+
+      # Stop nginx and note the new last stop time.
+      def stop
+        daemon :stop
+        Nginxtra::Status[:last_stop_time] = Time.now
+      end
+    end
+  end
+end

data/lib/nginxtra/cli.rb

@@ -0,0 +1,77 @@
+require "thor"
+
+module Nginxtra
+  class CLI < Thor
+    include Thor::Actions
+
+    class_option "force", :type => :boolean, :banner => "Force a task to happen, regardless of what nginxtra thinks", :aliases => "-f"
+    class_option "non-interactive", :type => :boolean, :banner => "If nginxtra would ask a question, it instead proceeds as if 'no' were the answer", :aliases => "-I"
+    class_option "config", :type => :string, :banner => "Specify the configuration file to use", :aliases => "-c"
+    class_option "basedir", :type => :string, :banner => "Specify the directory to store nginx files", :aliases => "-b"
+
+    desc "compile", "Compiles nginx based on nginxtra.conf.rb"
+    long_desc "
+      Compile nginx with the compilation options specified in nginxtra.conf.rb.  If it
+      has already been compiled with those options, compilation will be skipped.  Note
+      that start will already run compilation, so compilation is not really needed to
+      be executed directly.  However, you can force recompilation by running this task
+      with the --force option."
+    def compile
+      Nginxtra::Actions::Compile.new(self, prepare_config!).compile
+    end
+
+    desc "install", "Installs nginxtra"
+    long_desc "
+      Install nginxtra so nginx will start at system startup time, and stop when the
+      system is shut down.  Before installing, it will be checked if it had been
+      already installed with this version of nginxtra.  If it was already installed,
+      installation will be skipped unless the --force option is given."
+    def install
+      Nginxtra::Actions::Install.new(self, prepare_config!).install
+    end
+
+    desc "start", "Start nginx with configuration defined in nginxtra.conf.rb"
+    long_desc "
+      Start nginx based on nginxtra.conf.rb.  If nginx has not yet been compiled, it
+      will be compiled.  The configuration for nginx will automatically be handled by
+      nginxtra so it matches what is defined in nginxtra.conf.rb."
+    def start
+      Nginxtra::Actions::Start.new(self, prepare_config!).start
+    end
+
+    desc "stop", "Stop nginx"
+    def stop
+      Nginxtra::Actions::Stop.new(self, prepare_config!).stop
+    end
+
+    desc "restart", "Restart nginx"
+    def restart
+      Nginxtra::Actions::Restart.new(self, prepare_config!).restart
+    end
+    map "force-reload" => "restart"
+
+    desc "reload", "Reload nginx"
+    def reload
+      Nginxtra::Actions::Reload.new(self, prepare_config!).reload
+    end
+
+    desc "status", "Check if nginx is running"
+    def status
+      Nginxtra::Actions::Status.new(self, prepare_config!).status
+    end
+
+    private
+    def prepare_config!
+      Nginxtra::Config.base_dir = options["basedir"]
+      result = Nginxtra::Config.require! options["config"]
+      say "Using config #{Nginxtra::Config.loaded_config_path}"
+      result
+    end
+
+    class << self
+      def source_root
+        File.absolute_path File.expand_path("../../..", __FILE__)
+      end
+    end
+  end
+end

data/lib/nginxtra/config.rb

@@ -0,0 +1,339 @@
+module Nginxtra
+  # The Nginxtra::Config class is the central class for configuring
+  # nginxtra.  It provides the DSL for defining the compilation
+  # options of nginx and the config file contents.
+  class Config
+    FILENAME = "nginxtra.conf.rb".freeze
+    NGINX_CONF_FILENAME = "nginx.conf".freeze
+    NGINX_PIDFILE_FILENAME = ".nginx_pid".freeze
+    @@last_config = nil
+
+    def initialize
+      @requires_root = false
+      @compile_options = []
+      @files = {}
+      @@last_config = self
+    end
+
+    # This method is used to configure nginx via nginxtra.  Inside
+    # your nginxtra.conf.rb config file, you should use it like:
+    #   nginxtra.config do
+    #     ...
+    #   end
+    def config(&block)
+      instance_eval &block
+      self
+    end
+
+    # Notify nginxtra that root access is needed to run the daemon
+    # commands.  Sudo will automatically be used if the current user
+    # isn't root.
+    def require_root!
+      @requires_root = true
+    end
+
+    # Retrieve whether root is required to run the daemon.  This will
+    # return true only if require_root! was invoked from the config
+    # file.
+    def require_root?
+      @requires_root
+    end
+
+    # Require passenger.  This will include http_ssl_module,
+    # http_gzip_static_module, add a Wno-error compilation option, and
+    # add the passenger module to the proper passenger path.
+    def require_passenger!
+      compile_option %{--with-http_ssl_module}
+      compile_option %{--with-http_gzip_static_module}
+      compile_option %{--with-cc-opt=-Wno-error}
+      compile_option %{--add-module="#{File.join Nginxtra::Config.passenger_spec.gem_dir, "ext/nginx"}"}
+    end
+
+    # Obtain the compile options that have been configured.
+    def compile_options
+      @compile_options.join " "
+    end
+
+    # Specify a compile time option for nginx.  The leading "--" is
+    # optional and will be added if missing.  The following options
+    # are not allowed and will cause an exception: --prefix,
+    # --sbin-path, --conf-path and --pid-path.  The order the options
+    # are specified will be the order they are used when configuring
+    # nginx.
+    #
+    # Example usage:
+    #   nginxtra.config do
+    #     compile_option "--with-http_gzip_static_module"
+    #     compile_option "--with-cc-opt=-Wno-error"
+    #   end
+    def compile_option(opt)
+      opt = "--#{opt}" unless opt =~ /^--/
+      raise Nginxtra::Error::InvalidConfig.new("The --prefix compile option is not allowed with nginxtra.  It is reserved so nginxtra can control where nginx is compiled and run from.") if opt =~ /--prefix=/
+      raise Nginxtra::Error::InvalidConfig.new("The --sbin-path compile option is not allowed with nginxtra.  It is reserved so nginxtra can control what binary is used to run nginx.") if opt =~ /--sbin-path=/
+      raise Nginxtra::Error::InvalidConfig.new("The --conf-path compile option is not allowed with nginxtra.  It is reserved so nginxtra can control the configuration entirely via #{Nginxtra::Config::FILENAME}.") if opt =~ /--conf-path=/
+      raise Nginxtra::Error::InvalidConfig.new("The --pid-path compile option is not allowed with nginxtra.  It is reserved so nginxtra can control where the pid file is created.") if opt =~ /--pid-path=/
+      @compile_options << opt
+    end
+
+    # Obtain the config file contents that will be used for
+    # nginx.conf.
+    def file_contents(filename)
+      @files[filename].config_file_contents
+    end
+
+    # Define a new config file with the given filename and the block
+    # to define it with.
+    def file(filename, &block)
+      @files[filename] = Nginxtra::Config::ConfigFile.new(&block)
+    end
+
+    # Retrieve the files that have been defined.
+    def files
+      @files.keys
+    end
+
+    class << self
+      # Obtain the last Nginxtra::Config object that was created.
+      def last_config
+        @@last_config
+      end
+
+      # Obtain the config file path based on the current directory.
+      # This will be the path to the first nginxtra.conf.rb found
+      # starting at the current directory and working up until it is
+      # found or the filesystem boundary is hit (so /nginxtra.conf.rb
+      # is the last possible tested file).  If none is found, nil is
+      # returned.
+      def path
+        path = File.absolute_path "."
+
+        begin
+          config = File.join path, FILENAME
+          return config if File.exists? config
+          path = File.dirname path
+        end until path == "/"
+
+        config = File.join path, FILENAME
+        config if File.exists? config
+      end
+
+      # Retrieve the path to the config file that was loaded.
+      def loaded_config_path
+        @loaded_config_path
+      end
+
+      # Determine where the config file is and require it.  Return the
+      # resulting config loaded by the path.
+      # Nginxtra::Error::MissingConfig will be raised if the config
+      # file cannot be found.
+      def require!(config_path = nil)
+        if config_path
+          config_path = File.absolute_path config_path
+        elsif Nginxtra::Status[:remembered_config]
+          config_path = File.absolute_path Nginxtra::Status[:remembered_config]
+        else
+          config_path = path
+        end
+
+        raise Nginxtra::Error::MissingConfig.new("Cannot find #{FILENAME} to configure nginxtra!") unless config_path
+        raise Nginxtra::Error::MissingConfig.new("Missing file #{config_path} to configure nginxtra!") unless File.exists?(config_path)
+        require config_path
+        raise Nginxtra::Error::InvalidConfig.new("No configuration is specified in #{config_path}!") unless last_config
+        @loaded_config_path = config_path
+        last_config
+      end
+
+      # The path to the VERSION file in the gem.
+      def version_file
+        File.join gem_dir, "VERSION"
+      end
+
+      # The current version of nginxtra.
+      def version
+        @version ||= File.read(version_file).strip
+      end
+
+      # The corresponding nginx version (based on the nginxtra
+      # version).
+      def nginx_version
+        @nginx_version ||= version.split(".").take(3).join(".")
+      end
+
+      # Retrieve the base dir of nginxtra (located just above lib,
+      # probably in your gems/nginxtra-xxx directory).
+      def gem_dir
+        File.absolute_path File.expand_path("../../..", __FILE__)
+      end
+
+      # Set the base directory (retrieved from base_dir).  If this is
+      # not called, it will default to the ~/.nginxtra directory.
+      # This will do nothing if the value is nil.
+      def base_dir=(value)
+        @base_dir = value if value
+      end
+
+      # Retrieve the base dir of nginxtra stored files (located in
+      # ~/.nginxtra, unless overridden via the --basedir option).
+      def base_dir
+        @base_dir ||= File.absolute_path File.expand_path("~/.nginxtra")
+      end
+
+      # The base nginx dir versioned to the current version inside the
+      # base dir.
+      def base_nginx_dir
+        File.join base_dir, "nginx-#{nginx_version}"
+      end
+
+      # Retrieve the directory where nginx source is located.
+      def src_dir
+        File.join base_nginx_dir, "src"
+      end
+
+      # Retrieve the directory where nginx is built into.
+      def build_dir
+        File.join base_nginx_dir, "build"
+      end
+
+      # The path to the config directory where nginx config files are
+      # stored (including nginx.conf).
+      def config_dir
+        File.join base_dir, "conf"
+      end
+
+      # The full path to the nginx.conf file that is fed to nginx,
+      # based on nginxtra.conf.rb.
+      def nginx_config
+        File.join config_dir, NGINX_CONF_FILENAME
+      end
+
+      # The full path to the nginx pidfile that is used for running
+      # nginx.
+      def nginx_pidfile
+        File.join base_dir, NGINX_PIDFILE_FILENAME
+      end
+
+      # Retrieve the full path to the nginx executable.
+      def nginx_executable
+        File.join build_dir, "sbin/nginx"
+      end
+
+      # Retrieve the path to ruby.
+      def ruby_path
+        `which ruby`.strip
+      end
+
+      # Cache and retrieve the gemspec for passenger, if it exists.
+      # An InvalidConfig exception will be raised if passenger cannot
+      # be found.
+      def passenger_spec
+        @passenger_spec ||= Gem::Specification.find_by_name("passenger").tap do |spec|
+          raise InvalidConfig.new("You cannot reference passenger unless the passenger gem is installed!") if spec.nil?
+        end
+      end
+    end
+
+    # Represents a config file being defined by nginxtra.conf.rb.
+    class ConfigFile
+      def initialize(&block)
+        @file_contents = []
+        instance_eval &block
+      end
+
+      # The file contents that were defined for this config file.
+      def config_file_contents
+        @file_contents.join "\n"
+      end
+
+      # Add a new line to the config.  A semicolon is added
+      # automatically.
+      #
+      # Example usage:
+      #   nginxtra.config do
+      #     config_line "user my_user"
+      #     config_line "worker_processes 42"
+      #   end
+      def config_line(contents)
+        @file_contents << "#{contents};"
+      end
+
+      # Add a new line to the config, but without a semicolon at the
+      # end.
+      #
+      # Example usage:
+      #   nginxtra.config do
+      #     bare_config_line "a line with no semicolon"
+      #   end
+      def bare_config_line(contents)
+        @file_contents << contents
+      end
+
+      # Add a new block to the config.  This will result in outputting
+      # something in the config like a server block, wrapped in { }.  A
+      # block should be passed in to this method, which will represent
+      # the contents of the block (if no block is given, the resulting
+      # config will have an empty block).
+      #
+      # Example usage:
+      #   nginxtra.config do
+      #     config_block "events" do
+      #       config_line "worker_connections 512"
+      #     end
+      #   end
+      def config_block(name)
+        @file_contents << "#{name} {"
+        yield if block_given?
+        @file_contents << "}"
+      end
+
+      # Arbitrary config can be specified as long as the name doesn't
+      # clash with one of the Config instance methods.
+      #
+      # Example usage:
+      #   nginxtra.config do
+      #     user "my_user"
+      #     worker_processes 42
+      #     events do
+      #       worker_connections 512
+      #     end
+      #   end
+      #
+      # Any arguments the the method will be joined with the method name
+      # with a space to produce the output.
+      def method_missing(method, *args, &block)
+        values = [method, *args].join " "
+
+        if block
+          config_block values, &block
+        else
+          config_line values
+        end
+      end
+
+      # Output the passenger_root line, including the proper passenger
+      # gem path.
+      def passenger_root!
+        config_line %{passenger_root #{Nginxtra::Config.passenger_spec.gem_dir}}
+      end
+
+      # Output the passenger_ruby, including the proper ruby path.
+      def passenger_ruby!
+        config_line %{passenger_ruby #{Nginxtra::Config.ruby_path}}
+      end
+
+      # Output that passenger is enabled in this block.
+      def passenger_on!
+        config_line %{passenger_enabled on}
+      end
+    end
+  end
+end
+
+# This is an alias for constructing a new Nginxtra::Config object.  It
+# is used for readability of the nginxtra.conf.rb config file.
+# Example usage:
+#   nginxtra.config do
+#     ...
+#   end
+def nginxtra
+  Nginxtra::Config.new
+end