nginxbrew 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b2f5664ba79c8666cfbbe84bc5439cc5927479fd
+  data.tar.gz: 5a6ecb595b467736b8bdc30950e1ec5516dbb36d
+SHA512:
+  metadata.gz: 053144c4e831fa606289cbd9482c136d15d69ae8de4c4b803f2738bb41c411cb6561b81bb428b4c8ba0c8988aba223ae834267b2e386bc0de3e7c6e2a4b525c8
+  data.tar.gz: e1927c314e0373385570ba85d582e458990e6b7c0f65337a4fd3d87c532289e997226c7ae94eb805f2c8fe4caf74fad4e2d979598cb510f8ebdadf7897c35279

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in nginxbrew.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 takumakanari@nerima_fedora
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,113 @@
+# Nginxbrew
+
+Nginxbrew is a tool to install multi-version of nginx/nginxopenresty into your machine.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'nginxbrew'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install nginxbrew
+
+## Quick start Guide
+
+You can install new nginx build by specifying the version as follows
+
+    $ nginxbrew install 1.7.6
+
+"1.7.6" is the version of nginx.
+
+If you need to install openresty,
+
+    $ nginxbrew install openresty-1.7.0.1
+
+
+After the command execution, ~/nginxbrew will be created into your machine and nginx is installed as follows
+
+    ~/nginxbrew/bin/nginx -- current sbin
+    ~/nginxbrew/logs/<version> -- logfiles
+    ~/nginxbrew/versions/ngx-<version>/nginx.conf -- root config file
+    ~/nginxbrew/versions/ngx-<version> -- configs, sbin|pid of each version
+    ~/nginxbrew/versions/ngx-<version>/user/share -- $prefix directory of each version
+
+Then you can start up nginx by command which same as original nginx as follows
+
+    $ ~/nginxbrew/bin/nginx
+    $ ~/nginxbrew/bin/nginx -s reload
+
+
+If you want to use this nginx for default, add new line to .bashrc like as follows.
+
+    $ echo "export PATH=$PATH:~/nginxbrew/bin" >> ~/.bashrc
+    $ source ~/.bashrc
+
+Then there are 2 nginxes are activated in your machine, you can confirm it by the command
+
+    $ nginxbrew list
+
+You can switch to other version of nginx as follows
+
+    $ nginxbrew use <version>
+
+If you want to use openresty-1.7.0.1 from other version of nginx, you can do this as follows,
+
+    $ nginxbrew use openresty-1.7.0.1
+
+## Customize configuration
+
+You can customize Nginxbrew behavior by changing ENV.
+
+    NGINXBREW_HOME   # change nginxbrew root directory from ~/nginxbrew to somewhere
+    NGINXBREW_USER   # linux user for nginx
+    NGINXBREW_GROUP  # linux group for nginx
+
+You can change directory/options for nginx if you write configfile for nginxbrew.
+
+The following my_config.rb is configuration to share $prefix of nginx & nginx.conf troughout all builds of nginx.
+
+```ruby
+Nginxbrew.configure do |config|
+    config.ngx_prefix = File.join(config.home_dir, "share")
+    config.ngx_conf_path = File.join(config.home_dir, "share/nginx.conf")
+    config.ngx_configure =<<-EOF
+        # --- options for ./configure, starts from ./configure ...
+    EOF
+end
+```
+
+
+after that, specify path to config file which you wrote as follows
+
+    $ export NGINXBREW_CONFIG=/path/to/my_config.rb
+
+
+then nginxbrew starts to using this configuration.
+
+## TODO
+
+ - write tests completely
+ - share nginx.conf for every versions
+ - list up available nginx versions like as follows
+
+     $ nginxbrew nginxes
+
+ - installable without specifying minor version of nginx like as follows
+
+     $ nginxbrew install 1.7 # head of 1.7 will be installed
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/nginxbrew/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/bin/nginxbrew

@@ -0,0 +1,57 @@
+#!/usr/bin/env ruby
+require "nginxbrew"
+
+usage =<<-EOF
+Usage: nginxbrew [-v] [-h] command [<args>]
+
+    -v, --version                    Print the version and exit.
+    -h, --help                       Print this help.
+
+Available subcommands:
+    install <version>                Install nginx with specified version.
+    use <version>                    Switch nginx into specified version.
+    list                             Show list of installed nginx versions
+
+Optional environments:
+    NGINXBREW_HOME                   Path to nginxbrew (will be) installed, ~/nginxbrew is default.
+    NGINXBREW_USER                   User for nginx (enabled in `install`), "nginx" is default.
+    NGINXBREW_GROUP                  Group for nginx (enable in `install`), "nginx" is default.
+    NGINXBREW_DEBUG                  if 1, use DEBUG level for logging.
+    NGINXBREW_CONFIG                 /path/to/configfile written in ruby DSL for build nginx.
+EOF
+
+
+if ARGV.include?("-h") || ARGV.include?("--help") || ARGV.size == 0
+    puts usage
+    exit 0
+end
+
+if ARGV.include?("-v") || ARGV.include?("--version")
+    require "nginxbrew/version"
+    puts "nginxbrew #{Nginxbrew::VERSION}"
+    exit 0
+end
+
+
+ENV["HOME"] ||= File.dirname(__FILE__) # recover $HOME if empty
+
+
+begin
+    command = ARGV.shift
+    case command
+        when "install", "use"
+            version = ARGV.shift
+            raise Exception.new("version is required!") unless version
+            Nginxbrew.run(:"#{command}", envs={ "VERSION" => version })
+        when "list"
+            Nginxbrew.run(:list)
+        else
+            raise Exception.new("Unknown command '#{command}'")
+    end
+rescue SystemExit => e # from rake.abort
+    exit 255
+rescue Exception => e
+    $stderr.puts "ERROR: #{e.message}"
+    exit 255
+end
+

data/lib/nginxbrew/config/base.rb

@@ -0,0 +1,61 @@
+module Nginxbrew
+
+    class << self
+        attr_accessor :config
+    end
+
+    def self.configure
+        yield config
+    end
+
+    class Configuration
+        NGX_URL = "http://nginx.org/download"
+        OPENRESTY_URL = "http://openresty.org/download"
+
+        attr_accessor :ngx_configure, :ngx_conf_path, :ngx_prefix
+        attr_reader :ngx_user, :ngx_group, :nginx_log_dir,
+            :builtfile, :dist_to, :tarball, :src, :url, :home_dir, :ngx_sbin_path
+
+        def initialize(opts={})
+            @home_dir = opts[:home_dir]
+            @dist_dir = opts[:dist_dir]
+            @ngx_version = opts[:ngx_version]
+            @is_openresty = opts[:is_openresty]
+            @ngx_user = opts[:ngx_user]
+            @ngx_group = opts[:ngx_group]
+            @dist_to = File.join(@dist_dir, "ngx-#{@ngx_version}")
+            @nginx_log_dir = File.join(@home_dir, "logs", @ngx_version)
+            @src = opts[:src]
+            @tarball = "#{@src}.tar.gz"
+            @url = "#{@is_openresty ? OPENRESTY_URL : NGX_URL}/#{@tarball}"
+            @ngx_sbin_path = File.join(@dist_to, "bin/nginx")
+            @builtfile = File.join(@dist_to, "built")
+            @ngx_configure = nil
+            @ngx_conf_path = File.join(@dist_to, "nginx.conf")
+            @ngx_prefix = File.join(@dist_to, "user/share")
+        end
+
+        def configure_command
+            return @ngx_configure if @ngx_configure
+            cmd =<<-EOF
+                ./configure \
+                --user=#{@ngx_user} \
+                --group=#{@ngx_group} \
+                --prefix=#{@ngx_prefix} \
+                --sbin-path=#{@ngx_sbin_path} \
+                --conf-path=#{@ngx_conf_path} \
+                --error-log-path=#{@nginx_log_dir}/error.log \
+                --http-log-path=#{@nginx_log_dir}/access.log \
+                --http-client-body-temp-path=#{@dist_to}/tmp/client_body \
+                --http-proxy-temp-path=#{@dist_to}/tmp/proxy \
+                --http-fastcgi-temp-path=#{@dist_to}/tmp/fastcgi \
+                --http-uwsgi-temp-path=#{@dist_to}/tmp/uwsgi \
+                --pid-path=#{@dist_to}/run/nginx.pid
+            EOF
+            cmd.split(" ").join(" ")
+        end
+
+    end
+
+end
+

data/lib/nginxbrew/config/default.rb

@@ -0,0 +1,5 @@
+Nginxbrew.configure do |config|
+    # config.ngx_prefix = File.join(config.home_dir, "share")
+    # config.ngx_conf_path = File.join(config.home_dir, "share/nginx.conf")
+end
+

data/lib/nginxbrew/tasks.rb

@@ -0,0 +1,165 @@
+#!/usr/bin/env ruby
+require "logger"
+require "pathname"
+require "fileutils"
+
+
+$logger = Logger.new(STDOUT)
+$logger.level = (ENV["NGINXBREW_DEBUG"].to_i == 1) ? Logger::DEBUG : Logger::ERROR
+
+
+def package_name_from(version)
+    "ngx-#{version}"
+end
+
+
+def version_from_package(name)
+    prefix = "ngx-"
+    idx = name.index(prefix)
+    abort "Invalid name #{name}" if idx < 0
+    name.slice(prefix.size, name.size - 1)
+end
+
+
+def installed_packages(root)
+    Pathname.new(root).children.select{|e| e.directory? }.inject({}) do |memo, d|
+        version = version_from_package(File.basename(d))
+        memo[version] = d
+        memo
+    end
+end
+
+
+def sh_exc(cmd, *opts)
+    line = cmd
+    line += " " + opts.join(" ")
+    $logger.debug("exec: #{line}")
+    sh line
+end
+
+
+OPENRESTY = "openresty-"
+
+HOME_DIR = ENV["NGINXBREW_HOME"] || File.join(ENV["HOME"], "nginxbrew")
+VERSION = ENV["VERSION"]
+NGINX_USER = ENV["NGINXBREW_USER"] || "nginx"
+NGINX_GROUP = ENV["NGINXBREW_GROUP"] || "nginx"
+
+CONFIG_FILE = ENV["NGINXBREW_CONFIG"]
+if CONFIG_FILE && !FileTest.file?(CONFIG_FILE)
+    raise Exception.new("Specified configuration file #{CONFIG_FILE} is not found")
+end
+
+
+SOURCE_DIR = "#{HOME_DIR}/src"
+DIST_DIR = "#{HOME_DIR}/versions"
+BIN_DIR = "#{HOME_DIR}/bin"
+NGINX_CURRENT_BIN_NAME = "#{BIN_DIR}/nginx"
+
+
+[HOME_DIR, SOURCE_DIR, BIN_DIR, DIST_DIR].each do |dir|
+    directory dir
+end
+
+
+if VERSION
+    require "nginxbrew/config/base"
+
+    is_openresty = VERSION.index(OPENRESTY) == 0
+    version_ = VERSION
+    version_ = version_.slice(OPENRESTY.size, version_.size - 1) if is_openresty
+
+    Nginxbrew.config = Nginxbrew::Configuration.new(
+        :home_dir => HOME_DIR,
+        :dist_dir => DIST_DIR,
+        :ngx_version => VERSION,
+        :is_openresty => is_openresty,
+        :src => is_openresty ? "ngx_openresty-#{version_}" : "nginx-#{version_}",
+        :ngx_user => NGINX_USER,
+        :ngx_group => NGINX_GROUP
+    )
+
+    require "nginxbrew/config/default"
+    require CONFIG_FILE if CONFIG_FILE
+    $logger.debug(Nginxbrew.config.inspect)
+
+    config = Nginxbrew.config
+
+    directory config.dist_to
+
+    TARBALL_DOWNLOADED_TO = File.join(SOURCE_DIR, config.tarball)
+    SOURCE_EXTRACTED_TO = File.join(SOURCE_DIR, config.src)
+
+    desc "get nginx tarball version:#{VERSION}"
+    file TARBALL_DOWNLOADED_TO => SOURCE_DIR do
+        Dir.chdir(SOURCE_DIR) do
+            sh_exc("wget", config.url)
+        end
+    end
+
+
+    desc "extract tarball, #{SOURCE_EXTRACTED_TO} will be created"
+    directory SOURCE_EXTRACTED_TO => TARBALL_DOWNLOADED_TO do
+        Dir.chdir(SOURCE_DIR) do
+            sh_exc("tar", "zxf", TARBALL_DOWNLOADED_TO)
+        end
+    end
+
+
+    desc "do build/install, after that create file:built to keep status of build"
+    file config.builtfile => [SOURCE_EXTRACTED_TO, config.dist_to] do
+            Dir.chdir(SOURCE_EXTRACTED_TO) do
+                [config.configure_command, "gmake", "gmake install"].each do |cmd|
+                    sh_exc(cmd)
+                end
+            end
+            sh_exc("touch", config.builtfile)
+    end
+
+
+    desc "install nginx"
+    task :install => [config.builtfile] do
+        if installed_packages(DIST_DIR).size == 1
+            $logger.debug("this is first install, use this version as default")
+            Rake::Task[:use].invoke
+        end
+    end
+
+
+    desc "switch nginx version"
+    task :use => [BIN_DIR, :chown] do
+        abort "version:#{VERSION} is not installed!" unless FileTest.directory?(config.dist_to)
+        FileUtils.ln_s(config.ngx_sbin_path, NGINX_CURRENT_BIN_NAME, :force => true)
+        $stdout.puts("#{VERSION} default to use")
+        $stdout.puts("bin: #{config.ngx_sbin_path}")
+    end
+end
+
+
+desc "chown to sudo user or normal user"
+task :chown do
+    sudo_user = ENV["SUDO_USER"]
+    user = ENV["USER"]
+    if sudo_user && sudo_user != user
+        [HOME_DIR, DIST_DIR, BIN_DIR].each do |dir|
+            sh_exc("chown", "-R", sudo_user, dir)
+        end    
+    end
+end
+
+
+desc "list installed nginx"
+task :list => DIST_DIR do
+    used_version = nil
+    if FileTest.file?(NGINX_CURRENT_BIN_NAME)
+        target_path = File.readlink(NGINX_CURRENT_BIN_NAME)
+        path_list = target_path.split("/")
+        2.times {|i| path_list.pop } # remove bin/nginx
+        used_version = version_from_package(path_list.pop)
+    end
+    installed_packages(DIST_DIR).keys.sort.each do |v|
+        prefix = (v == used_version) ? "*" : " "
+        $stdout.puts("#{prefix} #{v}")
+    end
+end
+

data/lib/nginxbrew/version.rb

@@ -0,0 +1,3 @@
+module Nginxbrew
+  VERSION = "0.0.3"
+end

data/lib/nginxbrew.rb

@@ -0,0 +1,14 @@
+require "nginxbrew/version"
+require "rake"
+
+module Nginxbrew
+
+    def run(command, env={})
+        env.each{|k, v| ENV[k] = v }
+        require "nginxbrew/tasks"
+        Rake::Task[command].invoke
+    end
+
+    module_function :run
+end
+

data/nginxbrew.gemspec

@@ -0,0 +1,23 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'nginxbrew/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "nginxbrew"
+  spec.version       = Nginxbrew::VERSION
+  spec.authors       = ["takumakanari"]
+  spec.email         = ["chemtrails.t@gmail.com"]
+  spec.summary       = "Multi installation for nginx."
+  spec.description   = "Nginxbrew is a tool for install multi-version of nginx/nginxopenresty into your local environment."
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   << "nginxbrew"
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,86 @@
+--- !ruby/object:Gem::Specification
+name: nginxbrew
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- takumakanari
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-10-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Nginxbrew is a tool for install multi-version of nginx/nginxopenresty
+  into your local environment.
+email:
+- chemtrails.t@gmail.com
+executables:
+- nginxbrew
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/nginxbrew
+- lib/nginxbrew.rb
+- lib/nginxbrew/config/base.rb
+- lib/nginxbrew/config/default.rb
+- lib/nginxbrew/tasks.rb
+- lib/nginxbrew/version.rb
+- nginxbrew.gemspec
+homepage: ''
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.2
+signing_key: 
+specification_version: 4
+summary: Multi installation for nginx.
+test_files: []