quartz_flow 0.0.1

data/bin/createdb.rb

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+require 'fileutils'
+require 'quartz_flow/model'
+
+DataMapper::Logger.new($stdout, :debug)
+
+$settings = {}
+def set(sym, value)
+  puts "Set called: #{sym}=#{value}"
+  $settings[sym] = value
+end
+
+require './etc/quartz'
+
+dbPath = "#{Dir.pwd}/#{$settings[:db_file]}"
+path = "sqlite://#{dbPath}"
+DataMapper.setup(:default, path)
+
+dir = File.dirname($settings[:db_file])
+FileUtils.mkdir dir if dir.length > 0 && ! File.directory?(dir)
+
+
+if ! File.exists?(dbPath)
+  puts "creating database #{path}"
+  DataMapper.auto_migrate!
+else
+  puts "upgrading database #{path}"
+  DataMapper.auto_upgrade!
+end
+

data/bin/quartzflow

@@ -0,0 +1,177 @@
+#!/usr/bin/env ruby
+require 'getoptlong'
+require 'quartz_torrent'
+
+def doSetup
+  home = "."
+
+  opts = GetoptLong.new(
+    [ '--homedir', '-d', GetoptLong::REQUIRED_ARGUMENT],
+  )       
+
+  opts.each do |opt, arg|
+    if opt == '--homedir'
+      home = arg
+    end
+  end
+
+  if ! File.directory?(home)
+    puts "Error: The directory '#{home}' we will setup into doesn't exist."
+    exit 1
+  end
+
+  if ! File.owned?(home)
+    puts "Error: The directory '#{home}' is not owned by this user. Please change the owner."
+    exit 1
+  end
+
+  puts "Initializing new quartzflow home in #{home == "." ? "current directory" : home}"
+  Home.new(home).setup
+end
+
+def doHelp
+  if ARGV.size == 0
+    puts "Used to manage or start quartzflow."
+    puts "Usage: #{$0} [command] [options]"
+    puts ""
+    puts "If no command is specified, start is assumed."
+    puts "For help with a specific command, use 'help command'. The available commands are:"
+    puts "  start     Start quartzflow"
+    puts "  setup     Setup a new quartzflow home directory"
+    puts "  adduser   Add a user"
+  else
+    command = ARGV.shift
+    if command == "setup"
+      puts "Initialize a new quartzflow home directory. This command creates the necessary "
+      puts "subdirectories and files needed for quartzflow to run. When run without options, "
+      puts "the current directory is set up. The directory should be empty and owned by the "
+      puts "current user."
+      puts ""
+      puts "Options:"
+      puts "  --homedir DIR, -d DIR       Setup DIR instead of the current directory"
+    elsif command == "start"
+      puts "Start quartzflow. When run without options, the current directory should be a"
+      puts "quartzflow home directory, as created using the setup command."
+      puts ""
+      puts "Options:"
+      puts "  --noauth, -n                Disable user authentication (users won't be "
+      puts "                              prompted for a password)"
+    elsif command == "adduser"
+      puts "Add a user. This command must be run with the --login option."
+      puts ""
+      puts "Options:"
+      puts "  --login LOGIN, -l LOGIN     Login name for the user to be added"
+    else
+      puts "Unknown command"
+    end
+  end
+end
+
+def doAddUser
+  isLinux = RUBY_PLATFORM.downcase.include?("linux")
+
+  opts = GetoptLong.new(
+    [ '--login', '-l', GetoptLong::REQUIRED_ARGUMENT],
+  )
+
+  login = nil
+  opts.each do |opt, arg|
+    if opt == '--login'
+      login = arg
+    end
+  end
+
+  if ! login
+    puts "The --login option is required for the adduser command"
+    exit 1
+  end
+
+  system "stty -echo" if isLinux
+
+  print "Password: "
+  $stdout.flush
+  passwd1 = $stdin.gets.strip
+  puts
+  print "Password again: "
+  $stdout.flush
+  passwd2 = $stdin.gets.strip
+  puts
+
+  system "stty echo" if isLinux
+
+  if passwd1 != passwd2
+    puts "Passwords don't match"
+    exit 1
+  end
+
+  auth = Authentication.new("etc/passwd")
+  auth.add_account(login, passwd1)
+end
+
+def doStart
+  QuartzTorrent.initThread("main")
+
+  opts = GetoptLong.new(
+    [ '--noauth', '-n', GetoptLong::NO_ARGUMENT],
+  )
+
+  $useAuthentication = true
+  opts.each do |opt, arg|
+    if opt == '--noauth'
+      $useAuthentication = false
+      puts "Warning: running without user authentication. This is not secure"
+    end
+  end
+
+  require 'quartz_flow/server'
+
+  # There is an interaction with Sinatra where we can't register signal handlers until
+  # Sinatra has started (and thus performed it's own registration/reset of the handlers).
+  # The workaround is to wait for the server to start before registering.
+  Thread.new do
+    begin
+      puts "Starting thread"
+      stdout = $stdout
+      io = File.open('/dev/pts/0','w')
+      until Server.running?
+        sleep 1
+      end
+
+      if Signal.list.has_key?('USR1')
+        puts "Registering SIGUSR1 handler"
+        Signal.trap('SIGUSR1') { QuartzTorrent.logBacktraces($stdout) }
+        Signal.trap('SIGQUIT') { QuartzTorrent.logBacktraces($stdout) }
+      end 
+    rescue
+      puts $!
+      puts $!.backtrace.join "\n"
+    end
+  end
+
+  Server.run!
+end
+
+command = :start
+
+if ARGV.size > 0
+  command = ARGV.shift.to_sym
+end
+
+if command == :setup
+  # home is slow to load since it loads the model and calls DataMapper.finalize, so we require it only when needed
+  require 'quartz_flow/home'
+  doSetup
+elsif command == :start
+  # home is slow to load since it loads the model and calls DataMapper.finalize, so we require it only when needed
+  require 'quartz_flow/home'
+  exit 1 if ! Home.new.validate
+
+  doStart
+elsif command == :help
+  doHelp
+elsif command == :adduser
+  require 'quartz_flow/authentication'
+  doAddUser
+else
+  puts "Unknown command #{command}"
+end

data/etc/logging.rb

@@ -0,0 +1,12 @@
+# Configure logging levels. Default level for all loggers is :info.
+
+#set "peerclient", :debug
+#set "peer_manager", :debug
+#set "tracker_client", :debug
+#set "http_tracker_client", :debug
+#set "udp_tracker_client", :debug
+#set "peerclient", :debug
+#set "peerclient.reactor", :debug
+#set "blockstate", :debug
+#set "piecemanager", :debug
+#set "peerholder", :debug

data/etc/quartz.rb

@@ -0,0 +1,25 @@
+# Quartzflow config file.
+
+# IP address that the web server should bind to
+set :bind, "0.0.0.0"
+
+# TCP port that the web server should bind to
+set :port, 4444
+
+# Directory where downloaded torrent data will be stored
+set :basedir, "download" 
+
+# Directory where .torrent files and .info files will be stored.
+set :metadir, "meta" 
+
+# TCP port used for torrents
+set :torrent_port, 9997
+
+# SQLite database used for storing settings and state
+set :db_file, "db/quartz.sqlite"
+
+# Where to log torrent protocol messages
+set :torrent_log, "log/torrent.log"
+
+# On which day of the month should monthly usage tracking reset
+set :monthly_usage_reset_day, 5

data/lib/quartz_flow/authentication.rb

@@ -0,0 +1,88 @@
+require 'digest'
+require 'fileutils'
+require 'quartz_flow/randstring'
+
+class AccountInfo
+  def initialize(login = nil, password_hash = nil, salt = nil)
+    @login = login
+    @password_hash = password_hash
+    @salt = salt
+  end
+  attr_accessor :login
+  attr_accessor :password_hash
+  attr_accessor :salt
+end  
+
+
+class Authentication
+  def initialize(password_file)
+    @password_file = password_file
+    @accounts = {}
+    load_password_file(password_file)
+  end
+
+  def add_account(login, unhashed_password)
+    if @accounts.has_key?login
+      raise "The account #{login} already exists"
+    end
+    raise "Password cannot be empty" if unhashed_password.nil?
+    add_account_internal(login, unhashed_password)
+  end
+
+  def del_account(login)
+    if ! @accounts.has_key?(login)
+      raise "The account #{login} does not exist"
+    end
+    del_account_internal(login)
+  end
+
+  # Returns true on success, false if the user cannot be authenticated
+  def authenticate(login, password)
+    # Reload the password file in case users were added/deleted
+    acct = @accounts[login]
+    return false if ! acct
+    hashed = hash_password(password, acct.salt)
+    hashed == acct.password_hash
+  end
+  
+  private
+  
+  def load_password_file(filename)
+    if File.exists? filename
+      File.open(filename, "r") do |file|
+        @accounts.clear
+        file.each_line do |line|
+          if line =~ /([^:]+):(.*):(.*)/
+            @accounts[$1] = AccountInfo.new($1,$2,$3)
+          end
+        end
+      end
+    end
+  end
+
+  def add_account_internal(login, unhashed_password)
+    salt = RandString.make_random_string(10)
+    acct = AccountInfo.new(login, hash_password(unhashed_password, salt), salt)
+    File.open(@password_file, "a") do |file|
+      file.puts "#{login}:#{acct.password_hash}:#{salt}"
+    end
+    @accounts[login] = acct
+  end
+
+  def hash_password(pass, salt)
+    Digest::SHA256.hexdigest(pass + salt)
+  end
+
+  def del_account_internal(login)
+    tmpfile = "#{@password_file}.new"
+    File.open(tmpfile, "w") do |outfile|
+      File.open(@password_file, "r") do |infile|
+        infile.each_line do |line|
+          outfile.print line if line !~ /^#{login}:/
+        end
+      end
+    end
+    FileUtils.mv tmpfile, @password_file
+  end
+
+end

data/lib/quartz_flow/home.rb

@@ -0,0 +1,76 @@
+require 'fileutils'
+require 'quartz_flow/model'
+
+# Class used to setup a new QuartzFlow home directory, and get information about it.
+class Home
+  def initialize(dir = ".")
+    @dir = dir
+
+    @subdirs = [
+      "etc",
+      "log",
+      "download",
+      "meta",
+      "public",
+      "db",
+      "views",
+    ]
+
+    @installRoot = Home.determineAppRoot("quartz_flow")
+  end
+
+  def validate
+    rc = true
+    @subdirs.each do |subdir|
+      path = File.join(@dir, subdir)
+      if ! File.directory?(path)
+        puts "Error: The home directory is invalid: the subdirectory #{subdir} doesn't exist under the home directory. Was the setup command run?"
+        rc = false
+        break
+      end
+    end
+    rc
+  end
+
+  def setup
+    @subdirs.each do |subdir|
+      if File.directory?(subdir)
+        puts "Directory #{subdir} already exists. Skipping creation."
+      else
+        installedPath = @installRoot + File::SEPARATOR + subdir 
+        if File.directory? installedPath
+          FileUtils.cp_r installedPath, @dir
+          puts "Copying #{subdir}"
+        else
+          FileUtils.mkdir @dir + File::SEPARATOR + subdir
+          puts "Creating #{subdir}"
+        end
+      end
+    end
+
+    # Create database
+    dbFile = "#{File.expand_path(@dir)}/db/quartz.sqlite"
+    if ! File.exists?(dbFile)
+      puts "Creating database file"
+      path = "sqlite://#{File.expand_path(@dir)}/db/quartz.sqlite"
+      DataMapper.setup(:default, path)
+      DataMapper.auto_migrate!
+    else
+      puts "Database file already exists. Running upgrade."
+      path = "sqlite://#{File.expand_path(@dir)}/db/quartz.sqlite"
+      DataMapper.setup(:default, path)
+      DataMapper.auto_upgrade!
+    end
+
+  end
+
+  def self.determineAppRoot(gemname)
+    # Are we running as a Gem, or from the source directory?
+    if Gem.loaded_specs[gemname]
+      Gem.loaded_specs[gemname].full_gem_path
+    else
+      "."
+    end
+  end
+
+end

data/lib/quartz_flow/mock_client.rb

@@ -0,0 +1,247 @@
+require 'quartz_torrent/magnet'
+
+module BEncode
+  class DecodeError
+  end
+end
+
+
+module QuartzTorrent
+  class Words
+    def initialize
+      @words = []
+      File.open "/usr/share/dict/words", "r" do |file|
+        file.each_line do |l|
+          @words.push l.chomp
+        end
+      end
+    end
+
+    def randomWord
+      @words[rand(@words.size)]
+    end
+  end
+
+  class Metainfo
+
+    def self.createFromFile(file)
+    end
+
+    class FileInfo
+      def initialize(length = nil, path = nil)
+        @length = length
+        @path = path
+      end
+        
+      # Relative path to the file. For a single-file torrent this is simply the name of the file. For a multi-file torrent,
+      # this is the directory names from the torrent and the filename separated by the file separator.
+      attr_accessor :path
+      # Length of the file.
+      attr_accessor :length
+    end 
+
+    class Info
+      def initialize
+        @files = []
+        @name = nil
+        @pieceLen = 0
+        @pieces = []
+        @private = false
+      end
+    
+      # Array of FileInfo objects
+      attr_accessor :files
+      # Suggested file or directory name
+      attr_accessor :name
+      # Length of each piece in bytes. The last piece may be shorter than this.
+      attr_accessor :pieceLen
+      # Array of SHA1 digests of all peices. These digests are in binary format. 
+      attr_accessor :pieces
+      # True if no external peer source is allowed.
+      attr_accessor :private
+
+      # Total length of the torrent data in bytes.
+      def dataLength
+        files.reduce(0){ |memo,f| memo + f.length}
+      end
+    end
+  end
+
+  class TrackerPeer
+    def initialize(ip, port, id = nil)
+      @ip = ip
+      @port = port
+      @id = id
+    end
+
+    attr_accessor :ip
+    attr_accessor :port
+    attr_accessor :id
+  end
+
+  class Peer
+    def initialize(trackerPeer)
+      @trackerPeer = trackerPeer
+      @amChoked = true
+      @amInterested = false
+      @peerChoked = true
+      @peerInterested = false
+      @infoHash = nil
+      @state = :disconnected
+      @uploadRate = 0
+      @downloadRate = 0
+      @uploadRateDataOnly = 0
+      @downloadRateDataOnly = 0
+      @bitfield = nil
+      @firstEstablishTime = nil
+      @isUs = false
+      @requestedBlocks = {}
+      @requestedBlocksSizeLastPass = nil
+      @maxRequestedBlocks = 50
+    end
+
+    attr_accessor :trackerPeer
+    attr_accessor :amChoked
+    attr_accessor :amInterested
+    attr_accessor :peerChoked
+    attr_accessor :peerInterested
+    attr_accessor :infoHash
+    attr_accessor :firstEstablishTime
+    attr_accessor :maxRequestedBlocks
+    attr_accessor :state
+    attr_accessor :isUs
+    attr_accessor :uploadRate
+    attr_accessor :downloadRate
+    attr_accessor :uploadRateDataOnly
+    attr_accessor :downloadRateDataOnly
+    attr_accessor :bitfield
+    attr_accessor :requestedBlocks
+    attr_accessor :requestedBlocksSizeLastPass
+    attr_accessor :peerMsgSerializer
+  end
+
+  class TorrentDataDelegate
+    # Create a new TorrentDataDelegate. This is meant to only be called internally.
+    def initialize
+      @info = nil
+      @infoHash = nil
+      @recommendedName = nil
+      @downloadRate = nil
+      @uploadRate = nil
+      @downloadRateDataOnly = nil
+      @uploadRateDataOnly = nil
+      @completedBytes = nil
+      @peers = nil
+      @state = nil
+      @completePieceBitfield = nil
+      @metainfoLength = nil
+      @metainfoCompletedLength = nil
+      @paused = nil
+    end
+
+    # Torrent Metainfo.info struct. This is nil if the torrent has no metadata and we haven't downloaded it yet
+    # (i.e. a magnet link).
+    attr_accessor :info
+    attr_accessor :infoHash
+    # Recommended display name for this torrent.
+    attr_accessor :recommendedName
+    attr_accessor :downloadRate
+    attr_accessor :uploadRate
+    attr_accessor :downloadRateDataOnly
+    attr_accessor :uploadRateDataOnly
+    attr_accessor :completedBytes
+    attr_accessor :peers
+    # State of the torrent. This may be one of :downloading_metainfo, :error, :checking_pieces, :running, :downloading_metainfo, or :deleted.
+    # The :deleted state indicates that the torrent that this TorrentDataDelegate refers to is no longer being managed by the peer client.
+    attr_accessor :state
+    attr_accessor :completePieceBitfield
+    # Length of metainfo info in bytes. This is only set when the state is :downloading_metainfo
+    attr_accessor :metainfoLength
+    # How much of the metainfo info we have downloaded in bytes. This is only set when the state is :downloading_metainfo
+    attr_accessor :metainfoCompletedLength
+    attr_accessor :paused
+  end
+
+  class PeerClient
+    def initialize(ignored)
+      @words = Words.new
+      @torrents = {}
+      7.times{ addTorrent }
+      Thread.new do
+        while true
+          begin
+            @torrents.each{ |k,t| t.downloadRate += (rand(1000) - 500)}
+          rescue
+            puts "Exception in Mock PeerClient: #{$!}" 
+          end
+          sleep 2
+        end
+      end
+    end
+
+    def port=(p)
+    end
+
+    def start
+    end
+
+    def stop
+    end
+
+    def addTorrentByMetainfo(info)
+    end
+
+    def torrentData(infoHash = nil)
+      @torrents
+    end
+
+    def addTorrent
+      d = makeFakeTorrentDelegate
+      @torrents[d.infoHash] = d
+    end
+
+    private
+    def makeFakeTorrentDelegate
+      result = TorrentDataDelegate.new
+      name = ""
+      (rand(3)+1).times do 
+        name << @words.randomWord + " "
+      end
+      result.recommendedName = name
+      result.infoHash = randomBinaryData 20
+      result.downloadRate = 100*1024
+      result.uploadRate = 5*1024
+      result.downloadRateDataOnly = 100*1024
+      result.uploadRateDataOnly = 5*1024
+      result.completedBytes = 800
+      result.peers = []
+      result.state = :running
+      result.paused = false
+
+      result.info = Metainfo::Info.new
+      result.info.files = [Metainfo::FileInfo.new(1000, "file1"), Metainfo::FileInfo.new(1000, "file2")]
+
+      3.times do
+        
+        peer = Peer.new(TrackerPeer.new("176.23.54.201", 5000))
+        peer.amChoked = false
+        peer.amInterested = false
+        peer.peerChoked = false
+        peer.peerInterested = true
+        peer.uploadRate = 20*1024
+        peer.downloadRate = 10*1024
+    
+        result.peers.push peer
+      end
+
+      result
+    end
+
+    def randomBinaryData(len)
+      result = ""
+      len.times{ result << rand(256) }
+      result
+    end
+  end
+end
+

data/lib/quartz_flow/model.rb

@@ -0,0 +1,27 @@
+require 'data_mapper'
+
+class Setting
+  include DataMapper::Resource
+
+  property :id,     Serial
+  property :name,   String
+  property :value,  String
+  property :scope,  Enum[:global, :user, :torrent]
+  # For settings that are not global, owner identifies who they apply to.
+  # For user settings, this is the user. For torrent settings this is the torrent infohash in hex ascii
+  property :owner,  String
+end
+
+class UsageBucket
+  include DataMapper::Resource
+
+  property :id,             Serial
+  property :type,           Enum[:daily, :monthly]
+  property :index,          Integer
+  property :label,          String
+  property :criteriaData,   Time
+  property :absoluteUsage,  Integer
+  property :value,          Integer
+end
+
+DataMapper.finalize

data/lib/quartz_flow/randstring.rb

@@ -0,0 +1,10 @@
+class RandString
+  SALT_CHARS = %w{a b c d e f g h i j k l m n o p q r s t u v w x y z A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 1 2 3 4 5 6 7 8 9 0 _ % $ @ ! " ' . , < > }
+
+  def self.make_random_string(len)
+    rc = ""
+    len.times{ rc << SALT_CHARS[rand(SALT_CHARS.size)] }
+    rc
+  end
+end
+