nzbgetpp 0.1.1rc0

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.gitignore

@@ -0,0 +1,15 @@
+# rcov generated
+coverage
+
+# rdoc generated
+rdoc
+
+# yard generated
+doc
+.yardoc
+
+# bundler
+.bundle
+
+# jeweler generated
+pkg

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,28 @@
+PATH
+  remote: .
+  specs:
+    nzbgetpp (0.1.1rc0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    rake (0.9.2.2)
+    rcov (0.9.9)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.1)
+    rspec-expectations (2.5.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.5.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  nzbgetpp!
+  rake
+  rcov
+  rspec

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2010 Marc Bowes
+
+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,103 @@
+# nzbgetpp #
+
+This is a postprocessing script for
+[nzbget](http://nzbget.sf.net). That is, after nzbget is done
+downloading things, this is a script that can be called to tidy up
+your download. Currently, we support:
+
+* unrarring files
+* removing unneeded files
+* categories
+* callbacks
+* logging
+* tests
+
+NzbGetPP has a pre-defined callback for
+[dewey](http://github.com/timsjoberg/dewey), which will automatically
+place TV shows in the right place (and can be configured to rename
+things).
+
+Other callbacks can include things like telling some other client to
+download the now-available file (more on this coming Real Soon Now) or
+updating a database collection.
+
+## Design ##
+
+One of the major painpoints I've found with writing nzbget
+postprocessing scripts is they tend to be monolithic (bash) scripts
+and become really hard to reason about and extend. Testing them is
+also painful. This project has been designed to make it real easy to
+reason about it (OO design), see what is happening (logging) and test
+it works without actually downloading things (rspec).
+
+## Installing ##
+
+Install the project via a gem or git/hub:
+
+`gem install nzbgetpp`
+
+.. or if that doesn't work, or you want the Git version:
+
+    NZBGETPP_INSTALL_PATH=~/src/nzbgetpp
+    git clone git://github.com/marcbowes/nzbgetpp $NZBGETPP_INSTALL_PATH
+    # or:
+    # curl https://github.com/marcbowes/nzbgetpp/tarball/master > $NZBGETPP_INSTALL_PATH
+    pushd $NZBGETPP_INSTALL_PATH
+    sudo rake install
+
+## Configuring ##
+
+We look in two places for a `config.rb` file: either the default one
+we ship in `support/`, or in `$HOME/.nzbgetpp/config.rb`. This is a
+Ruby script that essentially lets you write code into
+`lib/nzbgetpp.rb`. We provide convenience `configure do` and
+`install_callback(name) do` methods, both of which have examples in
+the factory edition of the config.
+
+The shipped version should "Just Work (TM)" in that it tries to pick
+the various binaries out of your environment. We make the assumption
+that you want to store stuff in `$HOME/download/complete`, but you can
+change this by setting `storage_directory` in the configure block.
+
+The only possibly mysterious value is the `scratch_directory`. This is
+the directory we use to work on the nzb. It means that we don't step
+on anyone's toes as it is neither the initial destination, nor the
+final. That is, if you have some other script running (e.g. scanning
+for new files), this prevents race conditions (we do a `mv` at the
+end, which is atomic on the filesystem). That said, please make sure
+that `storage_directory` is on the same drive as `scratch_directory`,
+else you will incur a penalty when moving the files at the end.
+
+## Alternatives ##
+
+Have a look at the
+[nzbget page on post-processing scripts](http://nzbget.sourceforge.net/Postprocessing_scripts). At the time of writing, the two options are:
+
+* [PPWeb](http://dalrun.com/Linux/Software/Nzbget/PPWeb/) is a Perl
+  based Web solution for managing nzbget and comes with post-processing scripts.
+* [Oversight](http://code.google.com/p/oversight/wiki/UnpackingScriptsOnly)
+  is a full system but they provide their unpacking scripts in
+  isolation. I was using this for a while and it works OK, but I found
+  it slow and tricky to extend.
+
+## Contributing to nzbgetpp ##
+ 
+* Check out the latest master to make sure the feature hasn't been
+  implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't
+  requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it
+  in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If
+  you want to have your own version, or is otherwise necessary, that
+  is fine, but please isolate to its own commit so I can cherry-pick
+  around it.
+
+## Copyright ##
+
+Copyright (c) 2011 Marc Bowes. I don't care what you do with it. There
+are no guarentees.
+

data/Rakefile

@@ -0,0 +1,17 @@
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new do |t|
+  t.rspec_opts = %w(-fs --color)
+  # If you're pedantic ..
+  # t.ruby_opts = %w(-w)
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/bin/nzbgetpp

@@ -0,0 +1,82 @@
+#!/usr/bin/env ruby
+
+# Reference: http://nzbget.svn.sourceforge.net/viewvc/nzbget/trunk/postprocess-example.sh?revision=359&content-type=text%2Fplain
+#
+# NZBGet passes following arguments to postprocess-programm as environment
+# variables:
+#  NZBPP_DIRECTORY    - path to destination dir for downloaded files;
+#  NZBPP_NZBFILENAME  - name of processed nzb-file;
+#  NZBPP_PARFILENAME  - name of par-file or empty string (if no collections were 
+#                       found);
+#  NZBPP_PARSTATUS    - result of par-check:
+#                       0 = not checked: par-check disabled or nzb-file does
+#                           not contain any par-files;
+#                       1 = checked and failed to repair;
+#                       2 = checked and successfully repaired;
+#                       3 = checked and can be repaired but repair is disabled;
+#  NZBPP_NZBCOMPLETED - state of nzb-job:
+#                       0 = there are more collections in this nzb-file queued;
+#                       1 = this was the last collection in nzb-file;
+#  NZBPP_PARFAILED    - indication of failed par-jobs for current nzb-file:
+#                       0 = no failed par-jobs;
+#                       1 = current par-job or any of the previous par-jobs for
+#                           the same nzb-files failed;
+#  NZBPP_CATEGORY     - category assigned to nzb-file (can be empty string).
+#
+
+# ARGV looks something like this
+# [
+#  "/path/to/dst/name-of-folder",              # 0. NZBPP_DIRECTORY
+#  "/path/to/nzb/name-of-nzb",                 # 1. NZBPP_NZBFILENAME
+#  "/path/to/dst/name-of-folder/name-of-par2", # 2. NZBPP_PARFILENAME
+#  "2",                                        # 3. NZBPP_PARSTATUS
+#  "1",                                        # 4. NZBPP_NZBCOMPLETED
+#  "0",                                        # 5. NZBPP_PARFAILED
+#  ""                                          # 6. NZBPP_CATEGORY
+# ]
+
+# Return value: nzbget processes the exit code returned by the script:
+#  91 - request nzbget to do par-check/repair for current collection in the 
+#       current nzb-file;
+#  92 - request nzbget to do par-check/repair for all collections in the 
+#       current nzb-file;
+#  93 - post-process successful (status = SUCCESS);
+#  94 - post-process failed (status = FAILURE);
+#  95 - post-process skipped (status = NONE);
+# All other return codes are interpreted as "status unknown".
+RC_POSTPROCESS_PARCHECK_CURRENT = 91
+RC_POSTPROCESS_PARCHECK_ALL     = 92
+RC_POSTPROCESS_SUCCESS          = 93
+RC_POSTPROCESS_ERROR            = 94
+RC_POSTPROCESS_NONE             = 95
+
+begin
+  require 'nzbgetpp'
+
+  pp = NzbGetPP::PostProcessor.new(ARGV[0],
+                                   NzbGetPP::Nzb.new(ARGV[1],
+                                                     ARGV[4]),
+                                   NzbGetPP::Par.new(ARGV[2],
+                                                     ARGV[3],
+                                                     ARGV[5]),
+                                   ARGV[6])
+  pp.postprocess!
+  
+  Kernel.exit! RC_POSTPROCESS_SUCCESS
+rescue NzbGetPP::PostProcessor::InflationError
+  Kernel.exit! RC_POSTPROCESS_PARCHECK_ALL
+rescue Exception => e
+  STDERR.puts("[ERROR] (#{e.class.name}) #{e.message}")
+  e.backtrace.each do |line|
+    STDERR.puts("[DETAIL] #{line}")
+  end
+
+  File.open("/tmp/nzbgetpp.stderr", "a") do |f|
+    f.puts("An exception occurred running nzbgetpp at " + Time.now.to_s)
+    f.puts([[e.class.name, e.message].join(": "),
+            e.backtrace.join("\n")].join("\n"))
+    f.puts()
+  end
+  
+  Kernel.exit! RC_POSTPROCESS_ERROR
+end

data/lib/nzbgetpp/log.rb

@@ -0,0 +1,90 @@
+module NzbGetPP
+  class Log
+
+    require "time"
+    
+    LEVELS = {
+      :debug => 0,
+      :detail => 1,
+      :info  => 2,
+      :warning => 3,
+      :error => 4,
+      :fatal => 5,
+    }
+          
+    attr_accessor :log_fn
+    attr_reader :level
+    
+    def initialize(level = :debug,
+                   log_fn = nil)
+      self.level = level
+      self.log_fn = log_fn
+      open_log_fd()
+    end
+
+    def open_log_fd
+      @log_fd.close() if @log_fd and not @log_fd.closed?
+      if self.log_fn
+        @log_fd = File.open(self.log_fn, "a")
+      end
+    end
+
+    def close_log_fd
+      if @log_fd and not @log_fd.closed?
+        @log_fd.flush()
+        @log_fd.close()
+      end
+    end
+            
+    LEVELS.each_key do |level|
+      define_method(level) do |message|
+        write_to_log(level, message)
+      end
+    end
+
+    def level=(level)
+      @level = level
+      @_enum_level = LEVELS[level]
+    end
+    
+    def write_to_log(level, message)
+      if LEVELS[level] >= @_enum_level
+        do_write_to_log(level, message)
+      else
+        # Toss it
+      end
+    end
+
+    def do_write_to_log(level, message)
+      puts("[%s] %s" % [level.to_s.upcase, message])
+
+      if @log_fd and not @log_fd.closed?
+        log_for_humans(Time.now.iso8601(), level, message)
+      end
+    end
+
+    # Map the log level (LOG_LEVEL_*) to an array containing
+    # [human_name:String, colour:String(ANSI escape sequence)]
+    ANSI_RED = "\033[0;31m"
+    ANSI_RED_INVERTED = "\033[7;31m"
+    ANSI_BROWN = "\033[0;33m"
+    ANSI_MAGENTA = "\033[0;35m"
+    ANSI_GREEN = "\033[0;32m"
+    ANSI_BOLD_WHITE = "\033[0;37m"
+    ANSI_NORMAL = "\033[0m"
+    HUMAN_LOG_LEVELS = { 
+      :fatal => ["FATAL", ANSI_RED_INVERTED],
+      :error => ["ERROR", ANSI_RED],
+      :warning => ["WARN", ANSI_MAGENTA],
+      :info => ["INFO", ANSI_GREEN],
+      :detail => ["DEBUG", ANSI_NORMAL],
+      :debug => ["DEBUG", ANSI_BROWN],
+    }
+    def log_for_humans(iso8601_timestr, log_level, log_msg)
+      level_str, level_colour = HUMAN_LOG_LEVELS[log_level]
+      @log_fd.puts("#{ANSI_BOLD_WHITE}#{iso8601_timestr}#{ANSI_NORMAL} "\
+                   "#{level_colour}#{"%5.5s" % level_str}#{ANSI_NORMAL} #{log_msg}")
+      @log_fd.flush()
+    end
+  end
+end

data/lib/nzbgetpp/nzb.rb

@@ -0,0 +1,26 @@
+module NzbGetPP
+  class Nzb
+
+    COMPLETED = {
+      "0" => false,
+      "1" => true,
+    }
+    
+    attr_reader :filename
+    
+    
+    def initialize(filename, completed)
+      @filename = filename
+      self.completed = completed
+    end
+
+
+    def completed=(nzbpp_nzbcompleted)
+      @completed = COMPLETED[nzbpp_nzbcompleted]
+    end
+    
+    def completed?
+      !!@completed
+    end
+  end
+end

data/lib/nzbgetpp/par.rb

@@ -0,0 +1,38 @@
+module NzbGetPP
+  class Par
+    
+    STATUSES = {
+      "0" => :not_checked,
+      "1" => :cannot_repair,
+      "2" => :repaired,
+      "3" => :repairable,
+    }
+
+    FAILED = {
+      "0" => false,
+      "1" => true,
+    }
+
+    attr_reader :filename, :status
+
+    
+    def initialize(filename, status, failed)
+      @filename = filename
+      self.status = status
+      self.failed = failed
+    end
+
+
+    def status=(nzbpp_parstatus)
+      @status = STATUSES[nzbpp_parstatus]
+    end
+    
+    def failed=(nzbpp_parfailed)
+      @failed = FAILED[nzbpp_parfailed]
+    end
+                  
+    def failed?
+      !!@failed
+    end
+  end
+end

data/lib/nzbgetpp/shellout.rb

@@ -0,0 +1,27 @@
+module NzbGetPP
+  module Shellout
+    # FIXME: probably want to implement timeouts here..
+    def shellout(cmd)
+      stdout_rd, stdout_wr = IO.pipe
+      stderr_rd, stderr_wr = IO.pipe
+      child_pid, child_status = nil
+      child_pid = Kernel.fork
+
+      if child_pid
+        stdout_wr.close
+        stderr_wr.close
+        return [child_pid, stdout_wr, stderr_wr]
+      else
+        Process.setsid
+        STDIN.close
+        STDOUT.reopen(stdout_wr)
+        STDERR.reopen(stderr_wr)
+        3.upto(256) { |fd| IO.new(fd).close rescue nil }
+
+        Kernel.exec(cmd)
+        # Never reached.
+        Kernel.exit!
+      end
+    end
+  end
+end

data/lib/nzbgetpp/version.rb

@@ -0,0 +1,3 @@
+module NzbGetPP
+  VERSION = "0.1.1rc0"
+end

data/lib/nzbgetpp.rb

@@ -0,0 +1,244 @@
+module NzbGetPP
+  
+  require "nzbgetpp/version"
+  
+  class PostProcessor
+    
+    require 'fileutils'
+    require 'pathname'
+    require 'ostruct'
+    require 'nzbgetpp/log'
+    require 'nzbgetpp/nzb'
+    require 'nzbgetpp/par'
+    require 'nzbgetpp/shellout'
+
+    include Shellout
+
+    class Error < RuntimeError; end
+    class ConfigError < Error; end
+    class InflationError < Error; end
+
+    
+    attr_accessor :category
+    attr_accessor :config
+    attr_accessor :log
+    attr_accessor :nzb
+    attr_accessor :par
+    attr_reader   :path
+    
+    def initialize(path,
+                   nzb,
+                   par,
+                   category)
+      self.path     = path
+      self.nzb      = nzb
+      self.par      = par
+      self.category = category
+      
+      clear_callbacks()
+      load_config()
+      self.log = mk_log(config.log_level, config.log_fn)
+    end
+
+
+    def load_config()
+      @config = OpenStruct.new()
+      config_fn = figure_config_fn()
+      ruby = File.read(config_fn)
+      Kernel.eval(ruby, binding(), config_fn, 0)
+      @config
+    end
+    
+    def configure
+      yield(@config)
+    end
+
+    def install_callback(name, &block)
+      @callbacks.push([name, block])
+    end
+
+    def clear_callbacks
+      @callbacks = Array.new()
+    end
+
+    def run_callbacks
+      log.info("Running callbacks")
+      log.detail("Callbacks #=> #{@callbacks.inspect()}")
+      
+      @callbacks.each do |name, block|
+        log.debug("Running callback #{name}")
+        block.call()
+      end
+    end
+    
+    def postprocess!
+      unless nzb.completed?
+        log.info("Called prematurely - this nzb ain't ready for me")
+        return true
+      end
+      
+      unless Dir[path.join("*.rar").to_s].empty?
+        inflate_rar_files
+      else
+        log.info("Nothing to inflate")
+      end
+
+      remove_unneeded_files(path)
+      merge_directory_tree(path, scratch_directory)
+      remove_download_directory(path)
+      remove_unneeded_files(scratch_directory)
+
+      log.info("Moving to final resting place")
+      storage_dir = storage_directory.dirname
+      unless storage_dir.exist?
+        log.debug("Storage dir #{storage_dir} will be created")
+        FileUtils.mkdir_p(storage_dir.to_s)
+      end
+      FileUtils.mv(scratch_directory, storage_directory)
+      run_callbacks()
+
+      log.info("Postprocessing complete")
+      log.close_log_fd()
+      return true
+    rescue PostProcessor::Error => e
+      log.error("#{e.class.name}: #{e.message}")
+      e.backtrace.each do |line|
+        log.detail(line)
+      end
+      raise(e)
+    end
+
+    # We shellout to unrar as a demonstration of our lack of faith for
+    # Ruby-based unraring to handle large files efficiently, fast or
+    # even at all.
+    def inflate_rar_files
+      log.info("Inflating rar files")
+
+      unrar_cmd = mk_unrar_cmd
+      log.debug(unrar_cmd)
+      FileUtils.mkdir_p(scratch_directory)
+
+      child_pid, stdout, stderr = shellout(unrar_cmd)
+
+      # Will raise Errno::ECHILD if the pid doesn't exist
+      until Process.wait(child_pid, Process::WNOHANG)
+        readable, _ = IO.select([stdout, stderr], [], [], 1)
+        readable.each do |io|
+          line = io.readline
+          case io
+          when stdout
+            log.detail(line)
+          else
+            log.error(line)
+          end
+        end
+      end
+
+      if $?.success?
+        log.info("Inflation succeeded")
+      else
+        raise(InflationError, child_status.inspect)
+      end
+    end
+
+    def merge_directory_tree(source, destination)
+      Dir.glob(File.join(source, "**/*")).each do |f|
+         # Skip directories. If they're empty, we don't want to create
+         # them. If they have content, we'll create them via the
+         # mkdir_p().
+        next if File.directory?(f)
+
+        rel_dir     = File.dirname(f).gsub(/^#{Regexp.escape(source.to_s)}\/?/, "")
+        target_dir  = File.join(destination,
+                                rel_dir)
+
+        unless File.exist?(target_dir)
+          log.debug("Making %s" % target_dir)
+          FileUtils.mkdir_p(target_dir)
+        end
+        
+        log.debug("Will move #{f} to #{target_dir}")
+        FileUtils.mv(f, target_dir)
+      end
+    end
+
+    def remove_download_directory(where)
+      FileUtils.rm_r(where)
+    end
+
+    def remove_unneeded_files(where)
+      log.info("Cleaning up unnecessary files in %s" %
+               where.to_s)
+      
+      config.discard_files.each do |glob|
+        log.debug("Will remove %s #=> %s" %
+                  [
+                   where.join(glob),
+                   Dir.glob(where.join(glob)).inspect()
+                  ])
+        Dir.glob(where.join(glob)).each do |file|
+          FileUtils.rm_f(file)
+        end
+      end
+
+      Dir.glob(where.join("*")) do |glob|
+        remove_unneeded_files(Pathname.new(glob)) if File.directory? glob
+      end
+    end
+
+    def path=(path)
+      @path = Pathname.new(File.expand_path(path))
+      raise ArgumentError unless @path.exist?
+    rescue => e
+      raise(ArgumentError,
+            "#{path.inspect} is not a valid download destination")
+    end
+
+    def mk_log(log_level, log_fn)
+      Log.new(log_level, log_fn)
+    end
+
+    def mk_unrar_cmd
+      [
+       config.unrar_bin,
+       config.unrar_flags.join(" "),
+       "\"#{unrar_targets.to_s}\"",
+       "\"#{scratch_directory.to_s}\"",
+      ].join(" ")
+    end
+
+    def unrar_targets
+      @unrar_targets ||= Pathname.new(File.join(path,
+                                                config.unrar_targets)).expand_path
+    end
+
+    def scratch_directory
+      @scratch_directory ||= Pathname.new(File.join(*[
+                                                      config.scratch_directory,
+                                                      self.category,
+                                                      path.basename,
+                                                     ].compact)).expand_path
+    end
+
+    def storage_directory
+      @storage_directory ||= Pathname.new(File.join(*[
+                                                      config.storage_directory,
+                                                      self.category,
+                                                      path.basename,
+                                                     ].compact)).expand_path
+    end
+
+    def figure_config_fn
+      fn = "config.rb"
+      
+      custom = File.join(ENV["HOME"], ".nzbgetpp", fn)
+      return custom if File.exist? custom
+      
+      default = File.expand_path(File.join(File.dirname(__FILE__), "../support", fn))
+      return default if File.exist? default
+
+      raise RuntimeError,
+      "Unable to find config in #{[custom, default].inspect}"
+    end
+  end
+end

data/nzbgetpp.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "nzbgetpp/version"
+
+Gem::Specification.new do |s|
+  s.name        = "nzbgetpp"
+  s.version     = NzbGetPP::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Marc Bowes"]
+  s.email       = ["marcbowes+nzbgetpp@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{NzbGet Postprocessor}
+  s.description = %q{A postprocessing script for NzbGet, written in Ruby.}
+
+  s.rubyforge_project = "nzbgetpp"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_development_dependency(%q<rake>, [">= 0"])
+  s.add_development_dependency(%q<rspec>, [">= 0"])
+  s.add_development_dependency(%q<rcov>, [">= 0"])
+end

data/spec/log_spec.rb

@@ -0,0 +1,22 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'nzbgetpp/log'
+
+describe NzbGetPP::Log do
+  before do
+    @log = NzbGetPP::MockLog.new
+  end
+  
+  it "should write to the log when the level is permitting" do
+    @log.debug("foo")
+    @log.store.should == [
+                          [:debug, "foo"]
+                         ]
+  end
+
+  it "should toss unprivileged messages" do
+    @log.level = :error
+    @log.debug("foo")
+    @log.store.should be_empty
+  end
+end

data/spec/nzb_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'nzbgetpp/nzb'
+
+describe NzbGetPP::Nzb do
+  before do
+    @nzb = NzbGetPP::Nzb.new("name.nzb", "1")
+  end
+
+  it "should correctly report completed?" do
+    @nzb.completed?.should be_true
+    @nzb.completed = "0"
+    @nzb.completed?.should be_false
+    @nzb.completed = "1"
+    @nzb.completed?.should be_true
+  end
+end

data/spec/nzbgetpp_spec.rb

@@ -0,0 +1,106 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'fileutils'
+
+describe NzbGetPP do
+  before do
+    @workdir = "/tmp/nzbgetpp-spec-#{$$}"
+    FileUtils.mkdir_p(@workdir)
+    
+    FileUtils.cp_r(File.join(File.dirname(__FILE__),
+                             "support/sample-dst"),
+                   File.join(@workdir,
+                             "dst"))
+    
+    @pp = NzbGetPP::PostProcessor.new(File.join(@workdir, "dst/example job"),
+                                      NzbGetPP::Nzb.new("example.nzb", 1),
+                                      NzbGetPP::Par.new("example.par2", 2, 0),
+                                      nil)
+    @pp.config.scratch_directory = File.join(@workdir, "scratch")
+
+    # Comment me out if you want logging for debug purposes
+    # @pp.log.log_fn = "/tmp/nzbgetpp.log"
+    # @pp.log.open_log_fd()
+    @pp.log = NzbGetPP::MockLog.new()
+  end
+
+  it "should correctly determine unrar targets" do
+    @pp.unrar_targets.to_s.should == File.join(@workdir, "dst/example job/*.rar")
+  end
+
+  it "should correctly determine scratch directory" do
+    @pp.scratch_directory.to_s.should == File.join(@pp.config.scratch_directory, "example job")
+  end
+
+  it "should correctly determine scratch directory with categories" do
+    @pp.category = "category"
+    @pp.scratch_directory.to_s.should == File.join(@pp.config.scratch_directory, "category/example job")
+  end
+
+  it "should correctly determine storage directory with categories" do
+    @pp.category = "category"
+    @pp.storage_directory.to_s.should == File.join(@pp.config.storage_directory, "category/example job")
+  end
+
+  # Disabled: requires unrar to be installed
+  #
+  # it "should inflate rars" do
+  #   @pp.inflate_rar_files
+  #   @pp.scratch_directory.join("example.file").exist?.should be_true
+  # end
+
+  it "should move survivors to the scratch dir" do
+    @pp.merge_directory_tree(@pp.path.to_s, @pp.scratch_directory)
+    @pp.scratch_directory.join("survivor").exist?.should be_true
+  end
+
+  it "should remove unneeded files" do
+    # Make some junk
+    junk_dir = Pathname.new(File.join(@workdir, "junk"))
+    FileUtils.mkdir_p(junk_dir)
+    junk_files = %w[
+     junk.rar
+     junk.r00
+     junk.r01
+     junk.s00
+     junk.s01
+     junk.nzb
+     junk.1
+     junk.sfv
+     junk.srr
+     junk.sample.file
+     _brokenlog.txt
+     survivor
+    ].each do |junk_file|
+      FileUtils.touch(junk_dir.join(junk_file))
+    end
+    Dir[junk_dir.join("*").to_s].size.should == junk_files.size
+    
+    @pp.remove_unneeded_files(junk_dir)
+    
+    # Check we completed our list
+    @pp.config.discard_files.each do |glob|
+      Dir[junk_dir.join(glob).to_s].should be_empty
+    end
+    
+    # Safety net
+    survivor = junk_dir.join("survivor")
+    survivor.exist?.should be_true
+    FileUtils.rm(survivor.to_s)
+    Dir[junk_dir.join("*").to_s].should be_empty
+  end
+
+  it "should run callbacks" do
+    @pp.clear_callbacks
+    touched = false
+    @pp.install_callback(:toucher) do
+      touched = true
+    end
+    @pp.run_callbacks
+    touched.should == true
+  end
+
+  after do
+    FileUtils.rm_r(@workdir)
+  end
+end

data/spec/par_spec.rb

@@ -0,0 +1,29 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'nzbgetpp/par'
+
+describe NzbGetPP::Par do
+  before do
+    @par = NzbGetPP::Par.new("name.par2", "2", "0")
+  end
+
+  it "should correctly report status" do
+    @par.status.should == :repaired
+    @par.status = "0"
+    @par.status.should == :not_checked
+    @par.status = "1"
+    @par.status.should == :cannot_repair
+    @par.status = "2"
+    @par.status.should == :repaired
+    @par.status = "3"
+    @par.status.should == :repairable
+  end
+  
+  it "should correctly report failed?" do
+    @par.failed?.should be_false
+    @par.failed = "1"
+    @par.failed?.should be_true
+    @par.failed = "0"
+    @par.failed?.should be_false
+  end
+end

data/spec/shellout_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+require 'nzbgetpp/shellout'
+
+include NzbGetPP::Shellout
+
+describe NzbGetPP::Shellout do
+  it "should return 0 for true" do
+    pid, _ = shellout("/bin/true")
+    Process.wait(pid)
+    $?.success?.should be_true
+  end
+
+  it "should return 1 for false" do
+    pid, _ = shellout("/bin/false")
+    Process.wait(pid)
+    $?.success?.should be_false
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'nzbgetpp'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

data/spec/support/log.rb

@@ -0,0 +1,16 @@
+module NzbGetPP
+  require 'nzbgetpp/log'
+  
+  class MockLog < Log
+    attr_reader :store
+
+    def initialize
+      @store = []
+      super
+    end
+    
+    def do_write_to_log(level, message)
+      @store << [level, message]
+    end
+  end
+end

data/spec/unrar_spec.rb

@@ -0,0 +1,47 @@
+require "spec_helper"
+
+require 'nzbgetpp/shellout'
+
+include NzbGetPP::Shellout
+
+describe NzbGetPP do
+  it "should parse * as a * not as an expanded list of arguments" do
+    sample_prog_fpath = File.join("/tmp/nzbgetpp-spec", Process.pid.to_s, "arg_writer.sh")
+    dir = File.dirname(sample_prog_fpath)
+    FileUtils.mkdir_p(dir)
+    File.open(sample_prog_fpath, "w") do |f|
+      f.puts <<SCRIPT
+#!/usr bin/env/ruby
+
+argc_fpath = File.expand_path("argc", File.dirname(__FILE__))
+argv_fpath = File.expand_path("argv", File.dirname(__FILE__))
+File.open(argc_fpath, "w") do |f|
+  f.puts(ARGV.size)
+end
+File.open(argv_fpath, "w") do |f|
+  f.puts(ARGV.inspect)
+end
+SCRIPT
+    end
+    FileUtils.touch(File.join(dir, "foo"))
+    FileUtils.touch(File.join(dir, "bar"))
+
+    arg = File.join(dir, "*").inspect
+    cmd = [
+           "ruby",
+           sample_prog_fpath,
+           arg,
+          ].join(" ")
+    child_pid, _ = shellout(cmd)
+    Process.wait(child_pid)
+    $?.success?.should be_true
+
+    File.read(File.join(dir, "argc")).strip.
+      should == "1"
+    
+    File.read(File.join(dir, "argv")).strip.
+      should == "[#{arg}]"
+
+    FileUtils.rm_r(dir)
+  end
+end

data/support/config.rb

@@ -0,0 +1,98 @@
+def which(bin)
+  candidates = ENV["PATH"].split(":").map do |dir|
+    File.expand_path(bin, dir)
+  end
+
+  candidates.detect do |candidate|
+    File.exist?(candidate)
+  end
+end
+
+configure do |c|
+  c.unrar_targets = "*.rar"
+  c.discard_files = [
+                     "*.rar",
+                     "*.r[0-9][0-9]",
+                     "*.s[0-9][0-9]",
+                     "*.nzb",
+                     "*.par2",
+                     "*.1",
+                     "*.sfv",
+                     "*.srr",
+                     "*sample*",
+                     "_brokenlog.txt",
+                    ] 
+  c.scratch_directory = File.join(ENV["HOME"], "download/scratch")
+  c.storage_directory = File.join(ENV["HOME"], "download/complete")
+  c.unrar_bin = which("unrar")
+  c.unrar_flags = [
+                   "x",
+                   "-y",
+                   "-p-",
+                   "-o+",
+                  ]
+
+  c.log_level = :debug
+  log_dir = File.join(ENV["HOME"], ".nzbgetpp")
+  c.log_fn = File.join(log_dir, "log") if File.exist?(log_dir)
+end
+
+#
+# Dewey support
+#
+configure do |c|
+  c.tv_dir = File.join(config.storage_directory, "archive/tv.series")
+  c.dewey_bin = which("dewey")
+end
+
+def move_tv_shows_to_the_archive
+  if category.nil? ||
+    category !~ /tv/i
+    # Not TV, so move along
+    log.detail("This isn't a TV show, so dewey won't be invoked")
+    return
+  end
+
+  if config.dewey_bin.nil? ||
+      config.dewey_bin.empty? ||
+      !File.exist?(config.dewey_bin)
+    # Dewey not available, so we won't archive this tv show
+    log.warning("This is a TV show but dewey isn't available :-(")
+    return
+  end
+
+  # Support for appending extra information into your tv-dir. For
+  # example, this allows us to set the category to 'tv/720p' and call
+  # dewey with '--tv-dir=archive/tv.series/720p'.
+  tv_dir = config.tv_dir
+  if (m = category.match(/tv\/(\w+)/i))
+    tv_dir = File.join(tv_dir, m[1])
+  end
+  
+  dewey_exec = [
+                config.dewey_bin,
+                [
+                 ["--tv-dir", tv_dir.inspect()],
+                ].map { |args| args.join("=") },
+                storage_directory.to_s.inspect(),
+               ].join(" ")
+  log.detail("Will exec(): " + dewey_exec.inspect())
+
+  rd, wr = IO.pipe()
+  rc = shellout(dewey_exec, nil, wr, wr)
+  wr.close() unless wr.closed?
+  rd.each_line do |line|
+    log.detail(line)
+  end
+  rd.close() unless rd.closed?
+  
+  if rc
+    log.info("Dewey seems happy :-)")
+  else
+    log.error("Dewey failed with a rc #{rc.inspect()} :-(")
+  end
+end
+
+install_callback(:dewey) do
+  move_tv_shows_to_the_archive()
+end

metadata

@@ -0,0 +1,111 @@
+--- !ruby/object:Gem::Specification
+name: nzbgetpp
+version: !ruby/object:Gem::Version
+  version: 0.1.1rc0
+  prerelease: 5
+platform: ruby
+authors:
+- Marc Bowes
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &18907960 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *18907960
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &18905760 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *18905760
+- !ruby/object:Gem::Dependency
+  name: rcov
+  requirement: &18904720 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *18904720
+description: A postprocessing script for NzbGet, written in Ruby.
+email:
+- marcbowes+nzbgetpp@gmail.com
+executables:
+- nzbgetpp
+extensions: []
+extra_rdoc_files: []
+files:
+- .document
+- .gitignore
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- VERSION
+- bin/nzbgetpp
+- lib/nzbgetpp.rb
+- lib/nzbgetpp/log.rb
+- lib/nzbgetpp/nzb.rb
+- lib/nzbgetpp/par.rb
+- lib/nzbgetpp/shellout.rb
+- lib/nzbgetpp/version.rb
+- nzbgetpp.gemspec
+- spec/log_spec.rb
+- spec/nzb_spec.rb
+- spec/nzbgetpp_spec.rb
+- spec/par_spec.rb
+- spec/shellout_spec.rb
+- spec/spec_helper.rb
+- spec/support/log.rb
+- spec/support/sample-dst/example job/_brokenlog.txt
+- spec/support/sample-dst/example job/example.rar
+- spec/support/sample-dst/example job/survivor
+- spec/unrar_spec.rb
+- support/config.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: 3546351088323564806
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: nzbgetpp
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: NzbGet Postprocessor
+test_files: []