bt-tools 0.3.0

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.3
+script: rspec

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Andrew Page
+
+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,40 @@
+# bt-tools
+
+[![Build Status](https://travis-ci.org/andrewpage/tools.cd.svg?branch=master)](https://travis-ci.org/andrewpage/tools.cd) [![Code Climate](https://codeclimate.com/github/andrewpage/tools.cd/badges/gpa.svg)](https://codeclimate.com/github/andrewpage/tools.cd) [![Test Coverage](https://codeclimate.com/github/andrewpage/tools.cd/badges/coverage.svg)](https://codeclimate.com/github/andrewpage/tools.cd/coverage)
+
+Collection of tools for managing a seedbox.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'bt-tools'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install bt-tools
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/bt-tools.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/bin/bt-tools

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+
+require 'tools'
+
+# Pass command line options to Tools::CLI for parsing
+cli = Tools::CLI.new(ARGV)
+
+# Run the program
+cli.execute

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'tools'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+require "pry"
+Pry.start
+
+# require 'irb'
+# IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/bt-tools.gemspec

@@ -0,0 +1,31 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'tools/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'bt-tools'
+  spec.version       = Tools::VERSION
+  spec.authors       = ['Andrew Page']
+  spec.email         = %w(andrew@andrewpage.me)
+
+  spec.summary       = 'Collection of tools for automating BitTorrent.'
+  spec.description   = 'Collection of tools for provisioning, managing, and automating BitTorrent seedboxes.'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.executables   = %w(bt-tools)
+  spec.require_paths = %w(lib)
+
+  spec.add_dependency 'activesupport', '~> 4.2.0'
+
+  # General Development Dependencies
+  spec.add_development_dependency 'bundler'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'pry'
+
+  # Test Dependencies
+  spec.add_development_dependency 'rspec'
+  spec.add_development_dependency 'aruba'
+  spec.add_development_dependency 'codeclimate-test-reporter'
+end

data/example-config/configuration.json

@@ -0,0 +1,19 @@
+{
+  "create": {
+    "manifest": "create.json",
+    "source": "rtorrent/data",
+    "output": "rtorrent/torrents",
+    "announceURL": "http://tracker.what.cd:34000/TEST/announce",
+    "private": true,
+    "pieceSize": 18
+  },
+  "transcode": {
+    "formats": {
+      "320": "transcode-320.json",
+      "V0": "transcode-V0.json",
+      "V2": "transcode-V2.json"
+    },
+    "source": "rtorrent/data",
+    "output": "rtorrent/data"
+  }
+}

data/example-config/create.json

@@ -0,0 +1,3 @@
+{
+  "files": []
+}

data/example-config/transcode-320.json

@@ -0,0 +1,3 @@
+{
+  "files": []
+}

data/example-config/transcode-V0.json

@@ -0,0 +1,3 @@
+{
+  "files": []
+}

data/example-config/transcode-V2.json

@@ -0,0 +1,3 @@
+{
+  "files": []
+}

data/lib/tools/actions/create.rb

@@ -0,0 +1,103 @@
+require 'json'
+require 'fileutils'
+
+module Tools
+  module Actions
+    class Create
+      include Support::Execution
+      include Support::Manifest
+
+      attr_reader :files, :announce, :source, :output, :piece_size, :privacy
+
+      # Create creates .torrent files for all files found in its manifest.
+      # @param manifest [String] Path to JSON configuration file that lists all files to be proceesed.
+      # @param announce [String] Announce URL of the primary tracker for this torrent.
+      # @param source [String] Path to the directory where source files will be located.
+      # @param output [String] Path to the directory where completed .torrent files will be saved.
+      # @param piece_size [Fixnum] BitTorrent piece size, as a power of 2. e.g. 18 = piece size of 256kb because 2**18 is 256kb
+      # @param privacy [Boolean] Should this torrent be private?
+      def initialize(manifest:, announce:, source:, output:, piece_size:, privacy:)
+        @announce = announce
+        @source = source
+        @output = output
+        @piece_size = piece_size
+        @privacy = privacy
+
+        @files = extract_files(manifest)
+      end
+
+      # Create a .torrent file for every file in the manifest
+      def execute
+        create_output_directory
+
+        files.each do |file_name|
+          # Full relative path to the source file
+          infile_path = source_path(file_name)
+          # File name of output file
+          outfile_name = torrent_name(file_name)
+          # Full relative path to output file
+          outfile_path = output_path(outfile_name)
+
+          if can_create_torrent?(infile_path)
+            make_torrent(infile_path, outfile_path)
+
+            puts "√ #{outfile_name}"
+          end
+        end
+      end
+
+      private
+
+      # Creates .torrent output directory if it does not yet exist.
+      def create_output_directory
+        FileUtils.mkdir_p(output) unless File.exists?(output)
+      end
+
+      # Generates a path to the source file within the source directory
+      # @param file_name [String] Name of the source file, relative to the source directory.
+      # @return [String] Path to the source file, relative to the calling location.
+      def source_path(file_name)
+        File.join(source, file_name)
+      end
+
+      # Generates a path to the output file within the output directory
+      # @param file_name [String] Name of the output file, relative to the output directory.
+      # @return [String] Path to the output file, relative to the calling location.
+      def output_path(file_name)
+        File.join(output, file_name)
+      end
+
+      # Generates the name for the finished .torrent file
+      # @param file_name [String] Name of the source file
+      # @return [String] .torrent name
+      def torrent_name(file_name)
+        basename = File.basename(file_name)
+
+        [basename, 'torrent'].join('.')
+      end
+
+      # @param infile_path [String] Path to the source file.
+      # @return [Boolean] Can we create the torrent for this source file?
+      def can_create_torrent?(infile_path)
+        File.exist?(infile_path)
+      end
+
+      # Create the .torrent file
+      # @param name [String] Name of the completed .torrent file.
+      # @param source [String] Path to the source directory for this torrent.
+      # @return [String] Result of the command execution.
+      def make_torrent(infile_path, outfile_path)
+        cmd = Array.new
+        cmd << %(mktorrent)
+        cmd << %(-l #{piece_size}) # piece_size is an exponent of two
+        cmd << %(-p) if privacy
+        cmd << %(-a #{announce})
+        cmd << %("#{infile_path}")
+        cmd << %(-o "#{outfile_path}")
+        cmd = cmd.join(' ')
+
+        execute_command(cmd)
+      end
+    end
+  end
+end

data/lib/tools/actions/transcode.rb

@@ -0,0 +1,65 @@
+require 'fileutils'
+
+module Tools
+  module Actions
+    class Transcode
+      include Support::Execution
+
+      def initialize(directory, formats = %w(V0 V2 320))
+        @directory = directory
+        @formats = formats
+      end
+
+      def execute
+        directory = @directory
+
+        @formats.each do |bit|
+          new_directory = copy_directory(directory, bit)
+
+          Dir.chdir(new_directory) do
+            Dir['*.flac'].each do |file|
+              transcode(file, bit)
+              FileUtils.rm(file)
+            end
+          end
+        end
+      end
+
+      private
+
+      def copy_directory(directory, bit)
+        new_directory = directory.gsub(%r{(flac|FLAC)}, bit)
+
+        FileUtils.cp_r(directory, new_directory)
+
+        new_directory
+      end
+
+      def transcode(file, bitrate)
+        preset = vbr?(bitrate) ? 'V' : 'b'
+
+        cmd = Array.new
+        cmd << %(flac)
+        cmd << %(-cd)
+        cmd << %("#{file}")
+        cmd << %(|)
+        cmd << %(lame)
+        cmd << %(-#{preset})
+        cmd << cmd_bitrate(bitrate)
+        cmd << %(-)
+        cmd << %("#{File.basename(file).split('.')[0]}.mp3")
+        cmd = cmd.join(' ')
+
+        execute_command(cmd)
+      end
+
+      def vbr?(bitrate)
+        bitrate.start_with?('V')
+      end
+
+      def cmd_bitrate(bitrate)
+        vbr?(bitrate) ? bitrate[1..-1] : bitrate
+      end
+    end
+  end
+end

data/lib/tools/api.rb

@@ -0,0 +1,102 @@
+require 'json'
+
+module Tools
+  module API
+    CREATE_REQUIRED_KEYS = %i(announceURL source output pieceSize)
+    TRANSCODE_REQUIRED_KEYS = %i(formats source output)
+
+    # Create .torrent files for each entry in the config manifest
+    # @param config_path [String] Path to the primary configuration file.
+    def create(config_path)
+      # Get a Hash from the config JSON
+      config = read_config(config_path, :create)
+
+      # Get path for the manifest (secondary) file
+      manifest = relative_config_path(config_path, config['manifest'])
+
+      # Initialize .torrent Creator
+      creator = Actions::Create.new(
+        manifest: manifest,
+        announce: config['announceURL'],
+        source: config['source'],
+        output: config['output'],
+        piece_size: config['pieceSize'],
+        privacy: config['private']
+      )
+
+      # Create torrents
+      creator.execute
+    end
+
+    # Transcode all FLAC files to the desired formats
+    # @param config_path [String] Path to the primary configuration file.
+    def transcode(config_path)
+      config = read_config(config_path, :transcode)
+
+      # Format keys and their manifest files
+      format_configuration = config['formats']
+
+      # Relativize all paths
+      relative_configuration = format_configuration.map do |key, manifest_path|
+        [key, relative_config_path(config_path, manifest_path)]
+      end.to_h
+
+      # Format objects
+      formats = Tools::Formats::Format.create_from_configuration(relative_configuration)
+
+      # Initialize file transcoder
+      transcoder = Actions::Transcode.new(
+        manifests: formats,
+        source: config['source'],
+        output: config['source']
+      )
+
+      # Transcode all formats
+      transcoder.execute
+    end
+
+    private
+
+    # Validates that all required keys are present in the configuration
+    # @param config [Hash] Configuration hash to validate.
+    # @param required_keys [Array] Keys that must be present in the configuration.
+    def validate_configuration(config, required_keys)
+      required = required_keys.map(&:to_s)
+      existing = config.keys.map(&:to_s)
+
+      # The difference between these two arrays is the list of keys that are missing
+      missing = required - existing
+
+      raise Tools::MissingKeysException.new(missing) unless missing.empty?
+    end
+
+    # All required keys for the given action.
+    # @param action [Symbol] The action to retreive required keys for.
+    # @return [Array] Keys that are required to be present in the configuration for a given action.
+    def required_keys(action)
+
+    end
+
+    # Read configuration and parse JSON
+    # @param path [String] Path of the configuration file to parse.
+    # @param action [String] Select inner hash corresponding to this key.
+    # @return [Hash] Hash representing the JSON contained within the specified file.
+    def read_config(path, action = nil)
+      contents = File.read(path)
+      json = JSON.parse(contents)
+
+      action ? json[action.to_s] : json
+    end
+
+    # Generate a path for the secondary config file that is relative
+    # to the primary config file
+    # @param config [String] Path to the secondary configuration file.
+    # @param main [String] Path to the primary configuration file.
+    # @return [String] Path to the secondary configuration file, relative to the directory of the primary configuration file.
+    def relative_config_path(primary, secondary)
+      config_directory = File.dirname(primary)
+
+      File.join(config_directory, secondary)
+    end
+  end
+end

data/lib/tools/cli.rb

@@ -0,0 +1,80 @@
+require 'ostruct'
+require 'optionparser'
+
+module Tools
+  class CLI
+    AVAILABLE_COMMANDS = %i(create transcode)
+
+    attr_reader :options
+
+    # CLI will parse all command line options
+    # @param args [Array] Arguments, typically from ARGV.
+    def initialize(args)
+      @args = args
+      @options = OpenStruct.new
+
+      parse
+      validate
+    end
+
+    # Perform actions based on command & options
+    def execute
+      Tools.public_send(command, options.configuration_path)
+    end
+
+    private
+
+    # Extract command + arguments from ARGV
+    def parse
+      # Parse all arguments first
+      option_parser.parse!(arguments)
+
+      # Get the first argument, this is our command
+      cmd = arguments.pop
+      raise OptionParser::MissingArgument, 'command' unless cmd
+
+      # Set the command if it's present
+      options.command = cmd.to_sym
+    end
+
+    # @return [Array] Command line arguments passed into this program.
+    def arguments
+      @args
+    end
+
+    # @return [Symbol] Command that was specified to this program
+    def command
+      options.command
+    end
+
+    # Ensure we have valid data
+    def validate
+      raise Tools::InvalidCommandException.new(command, AVAILABLE_COMMANDS) unless valid_command?
+      raise Tools::MissingConfigurationException.new('You must specify a valid configuration file.') unless options.configuration_path
+    end
+
+    # @return [Boolean] Is this command supported?
+    def valid_command?
+      AVAILABLE_COMMANDS.include?(command)
+    end
+
+    # CLI option parsing singleton
+    # @return [OptionParser] Object that can parse command line objects according to our specifications.
+    def option_parser
+      @parser ||= OptionParser.new do |opts|
+        opts.banner = "Usage: ./tools [#{AVAILABLE_COMMANDS.join('|')}] <options>"
+
+        # Allow user to choose a different configuration file
+        opts.on('-c', '--config [path]', 'Change configuration file from default.') do |path|
+          options.configuration_path = path
+        end
+
+        # View program help
+        opts.on_tail('-h', '--help', 'See program help.') do
+          puts opts
+          exit
+        end
+      end
+    end
+  end
+end

data/lib/tools/formats/f_320.rb

@@ -0,0 +1,15 @@
+module Tools
+  module Formats
+    class F320 < Format
+      # Transcode to 320kbps CBR
+      def transcode_command
+        'Top Kek 320'
+      end
+
+      # Locate configuration under key 320
+      def key
+        '320'
+      end
+    end
+  end
+end

data/lib/tools/formats/f_v0.rb

@@ -0,0 +1,15 @@
+module Tools
+  module Formats
+    class FV0 < Format
+      # Transcode to 320kbps CBR
+      def transcode_command
+        'Top Kek V0'
+      end
+
+      # Locate configuration under key 320
+      def key
+        'V0'
+      end
+    end
+  end
+end

data/lib/tools/formats/f_v2.rb

@@ -0,0 +1,15 @@
+module Tools
+  module Formats
+    class FV2 < Format
+      # Transcode to 320kbps CBR
+      def transcode_command
+        'Top Kek V2'
+      end
+
+      # Locate configuration under key 320
+      def key
+        'V2'
+      end
+    end
+  end
+end

data/lib/tools/formats/format.rb

@@ -0,0 +1,71 @@
+require 'active_support/core_ext/string'
+
+module Tools
+  module Formats
+    class Format
+      include Support::Manifest
+
+      attr_reader :files
+
+      # Generate Format objects for all objects in the `formats` hash
+      # @param formats [Hash] K: format name, V: path to manifest file
+      # @return [Array<Format>] Returns an array of Format objects
+      def self.create_from_configuration(formats)
+        initialized_formats = []
+
+        formats.each do |format_str, manifest_path|
+          # Format prefixed with an F
+          format_name = format_class_name(format_str)
+
+          # Constantized name, namespaced to the current namespace
+          format_class = namespaced_class(format_name)
+
+          # Initialize a new Format object with the corresponding manifest
+          format_object = format_class.new(manifest_path)
+
+          # Add it to the array to be returned
+          initialized_formats << format_object
+        end
+
+        initialized_formats
+      end
+
+      def transcode_command
+        require_subclass
+      end
+
+      def key
+        require_subclass
+      end
+
+      private
+
+      # Generate the proper convention for a Format class name
+      # @param format_name [String] Name of the format.
+      # @return [String] format_name prefixed with "F"
+      def self.format_class_name(format_name)
+        "F#{format_name}"
+      end
+
+      # Generate a constantized class name under the same namespace
+      # @param klass [String] Name of class to constantize.
+      # @return [Class] Constantized new class name.
+      def self.namespaced_class(klass)
+        class_string = self.to_s
+        namespace = class_string.deconstantize
+
+        [namespace, klass].join('::').constantize
+      end
+
+      # Initialize a Format with a manifest file
+      # @param manifest [String] Path to manifest file.
+      def initialize(manifest_path)
+        @files = extract_files(manifest_path)
+      end
+
+      def require_subclass
+        fail 'Must be implemented by subclass.'
+      end
+    end
+  end
+end