nginx_utils 0.0.5 → 0.0.6

data/bin/nginx_utils

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# coding: utf-8
+
+require "nginx_utils"
+
+NginxUtils::CLI.start

data/lib/nginx_utils/cli.rb

@@ -0,0 +1,36 @@
+# coding: utf-8
+
+module NginxUtils
+  class CLI < Thor
+    desc "status example.com", "Print status of Nginx"
+    long_desc <<-LONGDESC
+    `status` to view the status of Nginx.
+    LONGDESC
+    option :only_value, type: :boolean, desc: "print status value only."
+    def status(host="localhost")
+      result = NginxUtils::Status.get host: host
+      if options[:only_value]
+        puts result.values.join("\t")
+      else
+        puts "Active Connections: #{result[:active_connection]}"
+        puts "Accepts: #{result[:accepts]} Handled: #{result[:handled]} Requests: #{result[:requests]}"
+        puts "Reading: #{result[:reading]} Writing: #{result[:writing]} Waiting: #{result[:waiting]}"
+      end
+    end
+
+    desc "logrotate -d", "Nginx logrotate"
+    long_desc <<-LONGDESC
+    `logrotate` will log rotation of Nginx.
+    LONGDESC
+    option :debug, type: :boolean, aliases: "-d", desc: "Debug mode. Run only log output to STDOUT."
+    option :script_log, desc: "Log file for script."
+    option :log_level, desc: "Log level of script log."
+    option :root_dir, desc: "Root directory of Nginx."
+    option :target_logs, desc: "Specify logs of target."
+    option :retention, desc: "Specify in days the retention period of log."
+    option :pid_file, desc: "PID file of Nginx"
+    def logrotate
+      NginxUtils::Logrotate.new(options).execute
+    end
+  end
+end

data/lib/nginx_utils/logreader.rb

@@ -5,7 +5,7 @@ module NginxUtils
     include Enumerable
 
     def initialize(log, options={})
-      @log = File.open(log, "r")
+      @log = File.open(log)
 
       if options[:parser]
         if options[:parser].is_a? Regexp
@@ -27,7 +27,7 @@ module NginxUtils
 
     private
     def parse(line)
-      case @format
+      case @format.to_sym
       when :ltsv then
         row = line.split("\t").map do |f|
           c = f.split(":")

data/lib/nginx_utils/logrotate.rb

@@ -7,111 +7,16 @@ module NginxUtils
     attr_accessor :delete_logs
 
     def initialize(options={})
-      # Debug
-      #   debug: false => Not execute. Only output of logs to STDOUT.
-      #   debug: true => Execute rotate logs Nginx. (default)
-      if options[:debug]
-        debug
-      else
-        @execute = true
-
-        # Script log file
-        #   not specified => /tmp/nginx_rotate.log (default)
-        #   script_log: false => Not output of logs.
-        #   script_log: "/path/to/nginx_rotate.log" => /path/to/nginx_rotate.log
-        #   script_log: STDOUT => STDOUT
-        set_logger options[:script_log]
-
-        # Script log level
-        #   not specified => Logger::DEBUG (default)
-        #   log_level: [:fatal|:error|:info|:warn]
-        set_log_level options[:log_level]
-      end
-
-      # Target logs
-      # Log of rename target is "#{root_dir}/**/#{target_logs}"
-      # Log of delete target is "#{root_dir}/**/#{target_logs}.*"
-      # Default parameters are as follows:
-      #   - root_dir => /usr/local/nginx
-      #   - target_logs => *.log
-      @root_dir = options[:root_dir] || "/usr/local/nginx"
-      @target_logs = options[:target_logs] || "*.log"
-      @rename_logs = Dir.glob(File.join(@root_dir, "**", @target_logs))
-      @delete_logs = Dir.glob(File.join(@root_dir, "**", "#{@target_logs}.*"))
-
-      # Rename prefix
-      # Log of rename target to add the prefix.
-      # File name of the renamed after: "#{filename}.#{prefix}"
-      # Current time default. (YYYYmmddHHMMSS)
-      @prefix = options[:prefix] || Time.now.strftime("%Y%m%d%H%M%S")
-
-      # Retention period
-      # Delete log last modification time has passed the retention period.
-      # Specified unit of day.
-      dates = options[:retention] || 90
-      @retention = Time.now - (dates.to_i * 3600 * 24)
-
-      # PID file of Nginx
-      # The default is "#{root_dir}/logs/nginx.pid".
-      @pid_file = options[:pid_file] || File.join(@root_dir, "logs", "nginx.pid")
+      configure(options)
     end
 
     def config(options={})
-      # Debug
-      unless options[:debug].nil?
-        if options[:debug]
-          debug
-        else
-          debug false
-        end
-      end
-
-      # Script log file
-      unless options[:script_log].nil?
-        set_logger options[:script_log]
-      end
-
-      # Script log level
-      unless options[:log_level].nil?
-        set_log_level options[:log_level]
-      end
-
-      # Target logs
-      reglog = false
-      unless options[:root_dir].nil?
-        @root_dir = options[:root_dir]
-        reglob = true
-      end
-
-      unless options[:target_logs].nil?
-        @target_logs = options[:target_logs]
-        reglob = true
-      end
-
-      if reglob
-        @rename_logs = Dir.glob(File.join(@root_dir, "**", @target_logs))
-        @delete_logs = Dir.glob(File.join(@root_dir, "**", "#{@target_logs}.*"))
-      end
-
-      # Rename prefix
-      unless options[:prefix].nil?
-        @prefix = options[:prefix]
-      end
-
-      # Retention period
-      unless options[:retention].nil?
-        @retention = Time.now - (options[:retention].to_i * 3600 * 24)
-      end
-
-      # PID file of Nginx
-      unless options[:pid_file].nil?
-        @pid_file = options[:pid_file]
-      end
+      configure(options)
     end
 
     def rename
       @rename_logs.each do |log|
-        after = "#{log}.#{@prefix}"
+        after = "#{log}.#{@params[:prefix]}"
         if File.exists? after
           @logger.warn "File already exists: #{after}" if @logger
         else
@@ -122,8 +27,10 @@ module NginxUtils
     end
 
     def delete
+      retention_time = Time.now - (@params[:retention].to_i * 3600 * 24)
+
       @delete_logs.each do |log|
-        if File.stat(log).mtime < @retention
+        if File.stat(log).mtime < retention_time
           File.unlink(log) if @execute
           @logger.debug "Delete log file: #{log}" if @logger
         end
@@ -131,19 +38,19 @@ module NginxUtils
     end
 
     def restart
-      if File.exists? @pid_file
-        cmd = "kill -USR1 `cat #{@pid_file}`"
-        @logger.debug "Nginx restart command: #{cmd}" if @logger
+      if File.exists? @params[:pid_file]
         if @execute
-          if system(cmd)
+          begin
+            Process.kill(:USR1, File.read(@params[:pid_file]).to_i)
             @logger.info "Nginx restart is successfully" if @logger
-          else
+          rescue => e
             @logger.error "Nginx restart failed" if @logger
-            raise "Nginx restart failed" if @logger == false
+            @logger.error e if @logger
+            raise "Nginx restart failed"
           end
         end
       else
-        @logger.warn "Pid file is not found. Do not restart nginx. (#{@pid_file})" if @logger
+        @logger.warn "Pid file is not found. Do not restart nginx." if @logger
       end
     end
 
@@ -156,8 +63,48 @@ module NginxUtils
     end
 
     private
-    def debug(set=true)
-      if set
+    def configure(options)
+      options = options.inject({}){|r,(k,v)| r.store(k.to_sym, v); r}
+      if @params.nil?
+        first = true
+        @params = default_params.merge(options)
+        flags = @params.keys
+      else
+        first = false
+        flags = options.select{|k,v| @params[k] != v}.keys
+        @params.merge!(options)
+      end
+
+      reglob = false
+
+      flags.each do |key|
+        case key
+        when :debug then config_debug
+        when :script_log then config_logger
+        when :log_level then config_loglevel
+        when :root_dir then reglob = true
+        when :target_logs then reglob = true
+        end
+      end
+
+      reglob_logs if reglob
+    end
+
+    def default_params
+      {
+        debug: false,
+        script_log: "/tmp/nginx_rotate.log",
+        log_level: :debug,
+        root_dir: "/usr/local/nginx",
+        target_logs: "*.log",
+        prefix: Time.now.strftime("%Y%m%d%H%M%S"),
+        retention: 90,
+        pid_file: "/usr/local/nginx/logs/nginx.pid"
+      }
+    end
+
+    def config_debug
+      if @params[:debug]
         @execute = false
         @logger = Logger.new(STDOUT)
       else
@@ -165,17 +112,17 @@ module NginxUtils
       end
     end
 
-    def set_logger(log)
-      case log
-      when nil then @logger = Logger.new("/tmp/nginx_rotate.log")
-      when false then @logger = false
-      else @logger = Logger.new(log)
+    def config_logger
+      if @params[:script_log] == false
+        @logger = false
+      else
+        @logger = Logger.new(@params[:script_log])
       end
     end
 
-    def set_log_level(level)
+    def config_loglevel
       if @logger
-        case level
+        case @params[:log_level]
         when :fatal then @logger.level = Logger::FATAL
         when :error then @logger.level = Logger::ERROR
         when :warn then @logger.level = Logger::WARN
@@ -185,5 +132,10 @@ module NginxUtils
         end
       end
     end
+
+    def reglob_logs
+      @rename_logs = Dir.glob(File.join(@params[:root_dir], "**", @params[:target_logs]))
+      @delete_logs = Dir.glob(File.join(@params[:root_dir], "**", "#{@params[:target_logs]}.*"))
+    end
   end
 end

data/lib/nginx_utils/version.rb

@@ -1,3 +1,3 @@
 module NginxUtils
-  VERSION = "0.0.5"
+  VERSION = "0.0.6"
 end

data/lib/nginx_utils.rb

@@ -2,8 +2,10 @@
 
 require "logger"
 require "net/http"
+require "thor"
 
 require "nginx_utils/version"
 require "nginx_utils/logrotate"
 require "nginx_utils/logreader"
 require "nginx_utils/status"
+require "nginx_utils/cli"

data/nginx_utils.gemspec

@@ -18,8 +18,8 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
+  spec.add_dependency "thor"
   spec.add_development_dependency "bundler", "~> 1.3"
   spec.add_development_dependency "rake"
   spec.add_development_dependency "rspec"
-  spec.add_development_dependency "fakefs"
 end

data/spec/nginx_utils/cli_spec.rb

@@ -0,0 +1,114 @@
+# coding: utf-8
+
+require "spec_helper"
+require "stringio"
+
+describe "NginxUtils::CLI" do
+  def capture(stream)
+    begin
+      stream = stream.to_s
+      eval "$#{stream} = StringIO.new"
+      yield
+      result = eval("$#{stream}").string
+    ensure
+      eval("$#{stream} = #{stream.upcase}")
+    end
+    result
+  end
+
+  describe "#status" do
+    let(:result) {
+      {
+        active_connections: 1,
+        accepts: 4,
+        handled: 5,
+        requests: 51,
+        reading: 1,
+        writing: 3,
+        waiting: 2
+      }
+    }
+
+    before(:each) {NginxUtils::Status.should_receive(:get).and_return(result)}
+
+    it "default output" do
+      args = ["status"]
+      expect(
+        capture(:stdout) {
+          NginxUtils::CLI.start(args)
+        }
+      ).to eq("Active Connections: \nAccepts: 4 Handled: 5 Requests: 51\nReading: 1 Writing: 3 Waiting: 2\n")
+    end
+
+    it "only value output" do 
+      args = ["status", "--only_value"]
+      expect(
+        capture(:stdout) {
+          NginxUtils::CLI.start(args)
+        }
+      ).to eq("1\t4\t5\t51\t1\t3\t2\n")
+    end
+  end
+
+  describe "#logrotate" do
+    before(:each) do
+      @rotate = double("lotate mock")
+      @rotate.should_receive(:execute).and_return(true)
+    end
+
+    it "logrotate should be execute" do
+      NginxUtils::Logrotate.should_receive(:new).and_return(@rotate)
+      args = ["logrotate"]
+      NginxUtils::CLI.start(args)
+    end
+
+    it "debug option" do
+      options = {"debug" => true}
+      NginxUtils::Logrotate.should_receive(:new).with(options).and_return(@rotate)
+      args = ["logrotate", "-d"]
+      NginxUtils::CLI.start(args)
+    end
+
+    it "script_log option" do
+      options = {"script_log" => "/var/log/nginx_rotate.log"}
+      NginxUtils::Logrotate.should_receive(:new).with(options).and_return(@rotate)
+      args = ["logrotate", "--script_log", "/var/log/nginx_rotate.log"]
+      NginxUtils::CLI.start(args)
+    end
+
+    it "log_level option" do
+      options = {"log_level" => "warn"}
+      NginxUtils::Logrotate.should_receive(:new).with(options).and_return(@rotate)
+      args = ["logrotate", "--log_level", "warn"]
+      NginxUtils::CLI.start(args)
+    end
+
+    it "root_dir option" do
+      options = {"root_dir" => "/usr/local/nginx_other"}
+      NginxUtils::Logrotate.should_receive(:new).with(options).and_return(@rotate)
+      args = ["logrotate", "--root_dir", "/usr/local/nginx_other"]
+      NginxUtils::CLI.start(args)
+    end
+
+    it "target_logs option" do
+      options = {"target_logs" => "*_log"}
+      NginxUtils::Logrotate.should_receive(:new).with(options).and_return(@rotate)
+      args = ["logrotate", "--target_logs", "*_log"]
+      NginxUtils::CLI.start(args)
+    end
+
+    it "retention option" do
+      options = {"retention" => "30"}
+      NginxUtils::Logrotate.should_receive(:new).with(options).and_return(@rotate)
+      args = ["logrotate", "--retention", "30"]
+      NginxUtils::CLI.start(args)
+    end
+
+    it "pid_file option" do
+      options = {"pid_file" => "/var/run/nginx.pid"}
+      NginxUtils::Logrotate.should_receive(:new).with(options).and_return(@rotate)
+      args = ["logrotate", "--pid_file", "/var/run/nginx.pid"]
+      NginxUtils::CLI.start(args)
+    end
+  end
+end

data/spec/nginx_utils/logreader_spec.rb

@@ -2,125 +2,130 @@
 
 require "spec_helper"
 
-describe NginxUtils do
-  include FakeFS::SpecHelpers
-
-  def create_log(format)
-    log_dir = "/tmp"
-    FileUtils.mkdir_p log_dir
-
-    case format
-    when :ltsv then
-      line = "time:2013-05-19T08:13:14+00:00\thost:192.168.1.10\txff:-\tmethod:GET\tpath:/\tstatus:200\tua:Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_3) AppleWebKit/537.31 (KHTML, like Gecko) Chrome/26.0.1410.65 Safari/537.31\treq_size:124\treq_time:0.007\tres_size:239\tbody_size:11\tapp_time:-\n"
-    when :combined then
-      line = "192.168.1.10 - - [19/May/2013:23:14:04 +0900] \"GET / HTTP/1.1\" 200 239 \"-\" \"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_3) AppleWebKit/537.31 (KHTML, like Gecko) Chrome/26.0.1410.65 Safari/537.31\"\n"
-    else raise "format error"
-    end
-
-    File.open(File.join(log_dir, "access.log"), "w") do |f|
-      3.times {f.write line}
-    end
+describe "NginxUtils::Logreader" do
+  let!(:io_mock) do
+    io = double("io mock").as_null_object
+    File.stub(:open).and_return(io)
+    io
   end
 
-  before(:each) do
-    @log_file = "/tmp/access.log"
-    @parser = /([0-9.]+)\s-\s([^\s]+)\s\[(.*?)\]\s"(.*?)"\s([0-9]+)\s([0-9]+)\s"(.*?)"\s"(.*?)"\s"(.*)".*/
-  end
+  let(:access_log) {"/usr/local/nginx/logs/access.log"}
+  let(:parser) {/([0-9.]+)\s-\s([^\s]+)\s\[(.*?)\]\s"(.*?)"\s([0-9]+)\s([0-9]+)\s"(.*?)"\s"(.*?)".*/}
+  let(:reader) {NginxUtils::Logreader.new(access_log)}
 
-  describe "Logreader" do
-    describe "#initialize" do
-      context "with default parameters" do
-        before(:each) do
-          create_log(:ltsv)
-          @reader = NginxUtils::Logreader.new(@log_file)
-        end
-
-        it "specified file should be opened" do
-          expect(@reader.instance_eval{@log}.path).to eq(@log_file)
-        end
-
-        it "default format should be ltsv" do
-          expect(@reader.instance_eval{@format}).to eq(:ltsv)
-        end
-
-        it "default parser should be nil" do
-          expect(@reader.instance_eval{@parser}).to eq(nil)
-        end
+  describe "#initialize" do
+    context "with default parameters" do
+      it "specified file should be opened" do
+        File.should_receive(:open).with(access_log)
+        reader
       end
 
-      context "with custom parameters" do
-        before(:each) do
-          create_log(:combined)
-        end
-
-        it "format should be specified parameter" do
-          reader = NginxUtils::Logreader.new(@log_file, format: :combined)
-          expect(reader.instance_eval{@format}).to eq(:combined)
-        end
-
-        it "parser should be specified parameter" do
-          reader = NginxUtils::Logreader.new(@log_file, parser: @parser)
-          expect(reader.instance_eval{@parser}).to eq(@parser)
-        end
-
-        it "format should be :custom if specified parser" do
-          reader = NginxUtils::Logreader.new(@log_file, parser: @parser)
-          expect(reader.instance_eval{@format}).to eq(:custom)
-        end
-
-        it "should create exception if parser is not Regexp instance" do
-          expect(proc{NginxUtils::Logreader.new(@log_file, parser: "invalid parser")}).to raise_error("invalid argument")
-        end
+      it "default format should be ltsv" do
+        expect(reader.instance_eval{@format}).to eq(:ltsv)
+      end
+
+      it "default parser should be nil" do
+        expect(reader.instance_eval{@parser}).to eq(nil)
       end
     end
 
-    describe "#each" do
-      context "with ltsv log" do
-        it "return ltsv hash" do
-          create_log(:ltsv)
-          reader = NginxUtils::Logreader.new(@log_file)
-          ltsv_hash = {
-            time: "2013-05-19T08:13:14+00:00",
-            host: "192.168.1.10",
-            xff:"-",
-            method: "GET",
-            path: "/",
-            status: "200",
-            ua: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_3) AppleWebKit/537.31 (KHTML, like Gecko) Chrome/26.0.1410.65 Safari/537.31",
-            req_size: "124",
-            req_time: "0.007",
-            res_size: "239",
-            body_size: "11",
-            app_time: "-"
-          }
-          reader.each {|line| expect(line).to eq(ltsv_hash)}
-        end
+    context "with custom parameters" do
+      it "format should be specified parameter" do
+        reader = NginxUtils::Logreader.new(access_log, format: :combined)
+        expect(reader.instance_eval{@format}).to eq(:combined)
       end
 
-      context "with combined log" do
-        it "return combined hash" do
-          create_log(:combined)
-          reader = NginxUtils::Logreader.new(@log_file, format: :combined)
-          combined_hash = {
-            remote_addr: "192.168.1.10",
-            remote_user: "-",
-            time_local: "19/May/2013:23:14:04 +0900",
-            request: "GET / HTTP/1.1",
-            status: "200",
-            body_bytes_sent: "239",
-            http_referer: "-",
-            http_user_agent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_3) AppleWebKit/537.31 (KHTML, like Gecko) Chrome/26.0.1410.65 Safari/537.31"
+      it "parser should be specified parameter" do
+        reader = NginxUtils::Logreader.new(access_log, parser: parser)
+        expect(reader.instance_eval{@parser}).to eq(parser)
+      end
+
+      it "format should be :custom if specified parser" do
+        reader = NginxUtils::Logreader.new(access_log, parser: parser)
+        expect(reader.instance_eval{@format}).to eq(:custom)
+      end
+
+      it "should create exception if parser is not Regexp instance" do
+        expect(
+          proc {
+            NginxUtils::Logreader.new(access_log, parser: "invalid parser")
           }
-          reader.each {|line| expect(line).to eq(combined_hash)}
-        end
-
-        it "return unknown log if parse error" do
-          create_log(:combined)
-          File.open(@log_file, "w") {|f| f.write "unknown log"}
-          reader = NginxUtils::Logreader.new(@log_file, format: :combined)
-          reader.each {|line| expect(line).to eq({unknown: "unknown log"})}
-        end
+        ).to raise_error("invalid argument")
       end
     end
   end
+
+  describe "#each" do
+    it "call parse method" do
+      io_mock.stub(:each).and_yield("log line\n")
+      NginxUtils::Logreader.any_instance.should_receive(:parse)
+      reader.each {|line| line}
+    end
+  end
+
+  describe "#parse" do
+    let(:ltsv_line) {"time:2013-05-19T08:13:14+00:00\thost:192.168.1.10\txff:-\tmethod:GET\tpath:/\tstatus:200\tua:Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_3) AppleWebKit/537.31 (KHTML, like Gecko) Chrome/26.0.1410.65 Safari/537.31\treq_size:124\treq_time:0.007\tres_size:239\tbody_size:11\tapp_time:-\n"}
+    let(:combined_line) {"192.168.1.10 - - [19/May/2013:23:14:04 +0900] \"GET / HTTP/1.1\" 200 239 \"-\" \"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_3) AppleWebKit/537.31 (KHTML, like Gecko) Chrome/26.0.1410.65 Safari/537.31\"\n"}
+
+    it "ltsv format log" do
+      ltsv_hash = {
+        time: "2013-05-19T08:13:14+00:00",
+        host: "192.168.1.10",
+        xff:"-",
+        method: "GET",
+        path: "/",
+        status: "200",
+        ua: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_3) AppleWebKit/537.31 (KHTML, like Gecko) Chrome/26.0.1410.65 Safari/537.31",
+        req_size: "124",
+        req_time: "0.007",
+        res_size: "239",
+        body_size: "11",
+        app_time: "-"
+      }
+      expect(reader.send(:parse, ltsv_line.chomp)).to eq(ltsv_hash)
+    end
+
+    it "combined format log" do
+      combined_hash = {
+        remote_addr: "192.168.1.10",
+        remote_user: "-",
+        time_local: "19/May/2013:23:14:04 +0900",
+        request: "GET / HTTP/1.1",
+        status: "200",
+        body_bytes_sent: "239",
+        http_referer: "-",
+        http_user_agent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_3) AppleWebKit/537.31 (KHTML, like Gecko) Chrome/26.0.1410.65 Safari/537.31"
+      }
+      reader = NginxUtils::Logreader.new(access_log, format: :combined)
+      expect(reader.send(:parse, combined_line.chomp)).to eq(combined_hash)
+    end
+
+    it "return unknown log if parse error" do
+      unknown_line = "unknown log"
+      reader = NginxUtils::Logreader.new(access_log, format: :combined)
+      expect(reader.send(:parse, unknown_line)).to eq({unknown: unknown_line})
+    end
+
+    it "custom format parser" do
+      custom_hash = [
+        [
+          "192.168.1.10",
+          "-",
+          "19/May/2013:23:14:04 +0900",
+          "GET / HTTP/1.1",
+          "200",
+          "239",
+          "-",
+          "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_8_3) AppleWebKit/537.31 (KHTML, like Gecko) Chrome/26.0.1410.65 Safari/537.31"
+        ]
+      ]
+      reader = NginxUtils::Logreader.new(access_log, parser: parser)
+      expect(reader.send(:parse, combined_line.chomp)).to eq(custom_hash)
+    end
+
+    it "create exception if unknown format" do
+      reader = NginxUtils::Logreader.new(access_log, format: :unknown)
+      expect(proc{reader.send(:parse, combined_line.chomp)}).to raise_error("format error")
+    end
+  end
 end