rumplayer 0.1.1

data/README.markdown

@@ -0,0 +1,43 @@
+== RuMplayer
+
+Given you and (at least) one of your buddies want to watch movies together, but
+on different devices which may be located (very) far from each other.
+
+With RuMplayer you can watch them simultaneously without having to leave your comfy home.
+
+== Requirements
+
+* a public server where you can install RuMplayer an run the server.
+* all your buddies must have a copy of the movie to watch.
+
+
+== Installation
+
+    (sudo) gem install gemcutter
+    (sudo) gem tumble
+    (sudo) gem install rumplayer
+
+    rumplayer
+    CTRL+C
+
+Now, edit ~/.rumplayer.yml and add 
+
+== Usage
+
+On the Server run:
+
+    rumplayer -v --server
+
+
+All your buddies wait for the movie to start by running
+
+    cd /wherever/the/movie/is/located/
+    rumplayer
+
+You start the movie by supplying the filename
+
+    cd /my/location/of/the/movie
+    rumplayer movie.mkv
+
+Now all your buddies can pause, seek or stop the movie. 
+All these actions get distributed to all watchers.

data/Rakefile

@@ -0,0 +1,34 @@
+begin  
+  require 'rubygems'
+  require 'jeweler'  
+  Jeweler::Tasks.new do |gemspec|  
+    gemspec.name        = %q{rumplayer}
+    gemspec.summary     = %q{watch common movies simultaneously}
+    gemspec.description = %q{
+      RumPlayer allows you and your buddies to watch movies simultaneously
+      without sharing the room or continent. All participans must have a copy
+      of the movie to watch.
+    }
+    gemspec.email       = %q{niklas+rumplayer@lanpartei.de}
+    gemspec.homepage    = %q{http://github.com/niklas/rumplayer/}
+    gemspec.authors     = ["Niklas Hofer"]
+    gemspec.executables = %w{rumplayer}
+
+    gemspec.has_rdoc    = false
+    gemspec.files       = %w{
+      README.mardown
+      Rakefile
+      rumplayer
+      lib/rumplayer.rb
+      lib/rumplayer/client.rb
+      lib/rumplayer/server.rb
+      lib/rumplayer/mplayer.rb
+      lib/rumplayer/config.rb
+
+      lib/drbfire.rb
+    }
+  end  
+  Jeweler::GemcutterTasks.new  
+rescue LoadError  
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"  
+end

data/bin/rumplayer

@@ -0,0 +1,48 @@
+#!/usr/bin/ruby
+
+require 'rubygems'
+require 'optparse'
+
+require 'active_support'
+
+APP_ROOT = File.expand_path( File.join( File.dirname(__FILE__), '..' ) )
+ActiveSupport::Dependencies::load_paths << File.join(APP_ROOT, "lib")
+
+
+$options = {}
+
+OptionParser.new do |opts|
+  opts.banner = <<-EOTEXT
+RuMplayer - play common movies synchronously
+
+Usage: #{$0} [options] [file(s)]
+  #{$0}  (no files)            start and listen for commands
+  #{$0}  one or more files     start distributed playback
+
+Hint: All watchers must start this command from the same directory,
+      all paths are relative
+  EOTEXT
+
+  opts.separator ''
+  opts.separator "Options:"
+  opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+    $options[:verbose] = v
+  end
+
+  opts.on("-s", "--server", "Start Server on configured uri") do |s|
+    $options[:server] = s
+  end
+
+
+end.parse!
+
+if $options[:server]
+  Rumplayer::Server.start
+else
+  if ARGV.empty?
+    Rumplayer::Client.wait
+  else
+    Rumplayer::Client.run(ARGV)
+  end
+end
+

data/lib/drbfire.rb

@@ -0,0 +1,292 @@
+# :include:README
+#--
+# Author:: Nathaniel Talbott.
+# Copyright:: Copyright (c) 2004 Nathaniel Talbott. All rights reserved.
+# License:: Ruby license.
+
+require 'delegate'
+require 'drb'
+require 'timeout'
+
+# = DRb Firewall Protocol
+# 
+# == Prerequisites
+#
+# It is assumed that you already know how to use DRb; if you don't
+# you'll need to go read up on it and understand the basics of how it
+# works before using DRbFire. DRbFire actually wraps the standard
+# protocols that DRb uses, so generally anything that applies to them
+# applies to DRbFire.
+#
+#
+# == Basic Usage
+# 
+# Using DRbFire is quite simple, and can be summed up in four steps:
+#
+# 1. Start with <tt>require 'drb/drbfire'</tt>.
+#
+# 2. Use <tt>drbfire://</tt> instead of <tt>druby://</tt> when
+#    specifying the server url.
+#
+# 3. When calling <tt>DRb.start_service</tt> on the client, specify
+#    the server's uri as the uri (as opposed to the normal usage, which
+#    is to specify *no* uri).
+#
+# 4. Specify the right configuration when calling
+#    <tt>DRb.start_service</tt>, specifically the role to use:
+#    On the server:: <tt>DRbFire::ROLE => DRbFire::SERVER</tt>
+#    On the client:: <tt>DRbFire::ROLE => DRbFire::CLIENT</tt>
+#
+# So a simple server would look like:
+#
+#   require 'drb/drbfire'
+#
+#   front = ['a', 'b', 'c']
+#   DRb.start_service('drbfire://some.server.com:5555', front, DRbFire::ROLE => DRbFire::SERVER)
+#   DRb.thread.join
+#
+# And a simple client:
+#
+#   require 'drb/drbfire'
+#
+#   DRb.start_service('drbfire://some.server.com:5555', nil, DRbFire::ROLE => DRbFire::CLIENT)
+#   DRbObject.new(nil, 'drbfire://some.server.com:5555').each do |e|
+#     p e
+#   end
+#
+# 
+# == Advanced Usage
+#
+# You can do some more interesting tricks with DRbFire, too:
+#
+# <b>Using SSL</b>:: To do this, you have to set the delegate in the
+#                    configuration (on both the server and the client) using
+#                    <tt>DRbFire::DELEGATE => DRb::DRbSSLSocket</tt>. Other
+#                    DRb protcols may also work as delegates, but only the
+#                    SSL protocol is tested.
+#
+#
+# == Caveats
+#
+# * DRbFire uses a 32-bit id space, meaning ids will wrap after
+#   approximately ~4.2 billion connections. If that's a non-theoretical
+#   problem for you, and you tell me about it, I'll figure out some
+#   way to fix it. It'd be worth it just to find out that DRbFire is
+#   being used in such a mind-blowing fashion.
+#
+# * You're limited to one _server_ per process at this point. You can
+#   have (and handle) as many clients as you want (well, ok, so I just
+#   said there's really a limit somewhere around 4.2 billion. I'm
+#   trying to simplify here). Again, this is possible to deal with,
+#   but not something that I've needed at this point and not something
+#   I'm guessing is terribly common. Let me know if it's a problem for
+#   you.
+
+
+module DRbFire
+  # The current version.
+  VERSION = [0, 1, 0]
+  
+  # The role configuration key.
+  ROLE = "#{self}::ROLE"
+
+  # The server role configuration value.
+  SERVER = "#{self}::SERVER"
+
+  # The client role configuration value.
+  CLIENT = "#{self}::CLIENT"
+
+  # The delegate configuration key.
+  DELEGATE = "#{self}::DELEGATE"
+
+  # Miscellaneous constants
+  SCHEME = "drbfire" #:nodoc:
+  ID_FORMAT = "N" #:nodoc:
+  INCOMING_CONN = "1" #:nodoc:
+  OUTGOING_CONN = "2" #:nodoc:
+  SIGNAL_CONN = "3" #:nodoc:
+
+  class Protocol < SimpleDelegator #nodoc:all
+    class ClientServer
+      attr_reader :signal_id
+
+      def initialize(uri, config)
+        @uri = uri
+        @config = config
+        @connection = Protocol.open(uri, config, SIGNAL_CONN)
+        @signal_id = @connection.read_signal_id
+      end
+
+      def uri
+        "#{@uri}?#{@signal_id}"
+      end
+
+      def accept
+        @connection.stream.read(1)
+        connection = Protocol.open(@uri, @config, OUTGOING_CONN)
+        connection.stream.write([@signal_id].pack(ID_FORMAT))
+        connection
+      end
+
+      def close
+        @connection.close
+      end
+    end
+
+    class ClientServerProxy
+      def initialize(connection, id)
+        @connection = connection
+        @id = id
+        @queue = Queue.new
+      end
+
+      def write_signal_id
+        @connection.stream.write([@id].pack(ID_FORMAT))
+      end
+
+      def push(connection)
+        @queue.push(connection)
+      end
+
+      def open
+        @connection.stream.write("0")
+        timeout(20) do
+          @queue.pop
+        end
+      rescue TimeoutError
+        raise DRb::DRbConnError, "Unable to get a client connection."
+      end
+    end
+
+    class << self
+      def open_server(uri, config)
+        # make sure the scheme is ours
+        parse_uri(uri)
+        
+        if(server?(config))
+          @client_servers ||= {}
+          
+          sock = delegate(config).open_server(uri, config)
+          
+          # get the uri from the delegate, and replace the scheme with drbfire://
+          # this allows randomly chosen ports (:0) to work
+          scheme = sock.uri.match(/^(.*):\/\//)[1]
+          drbfire_uri = sock.uri.sub(scheme, SCHEME)
+          
+          new(drbfire_uri, sock)
+        else
+          ClientServer.new(uri, config)
+        end
+      end
+
+      def open(uri, config, type=INCOMING_CONN)
+        unless(server?(config))
+          connection = new(uri, delegate(config).open(uri, config))
+          connection.stream.write(type)
+          connection
+        else
+          @client_servers[parse_uri(uri).last.to_i].open
+        end
+      end
+
+      def add_client_connection(id, connection)
+        if((c = @client_servers[id]))
+          c.push(connection)
+        else
+        end
+      end
+
+      def add_client_server(id, server)
+        @client_servers[id] = server
+      end
+
+     def parse_uri(uri)
+        if(%r{^#{SCHEME}://([^:]+):(\d+)(?:\?(.+))?$} =~ uri)
+          [$1, $2.to_i, $3]
+        else
+          raise DRb::DRbBadScheme, uri unless(/^#{SCHEME}/ =~ uri)
+          raise DRb::DRbBadURI, "Can't parse uri: #{uri}"
+        end
+      end
+
+      def uri_option(uri, config)
+        host, port, option = parse_uri(uri)
+        return "#{SCHEME}://#{host}:#{port}", option
+      end
+
+      private
+
+      def server?(config)
+        raise "Invalid configuration #{config.inspect}" unless(config.include?(ROLE))
+        config[ROLE] == SERVER
+      end
+
+      def delegate(config)
+        unless(defined?(@delegate))
+          @delegate = Class.new(config[DELEGATE] || DRb::DRbTCPSocket) do
+            class << self
+              attr_writer :delegate
+
+              def parse_uri(uri)
+                @delegate.parse_uri(uri)
+              end
+
+              def uri_option(uri, config)
+                @delegate.uri_option(uri, config)
+              end
+            end
+          end
+          @delegate.delegate = self
+        end
+        @delegate
+      end
+    end
+
+    attr_reader :signal_id, :uri
+
+    def initialize(uri, delegate)
+      super(delegate)
+      @uri = uri
+      @id = 0
+      @id_mutex = Mutex.new
+    end
+
+    def accept
+      while(__getobj__.instance_eval{@socket})
+        begin
+          connection = self.class.new(nil, __getobj__.accept)
+        rescue IOError
+          return nil
+        end
+        begin
+          type = connection.stream.read(1)
+        rescue
+          next
+        end
+        case type
+        when INCOMING_CONN
+          return connection
+        when OUTGOING_CONN
+          self.class.add_client_connection(connection.read_signal_id, connection)
+          next
+        when SIGNAL_CONN
+          new_id = nil
+          @id_mutex.synchronize do
+            new_id = (@id += 1)
+          end
+          client_server = ClientServerProxy.new(connection, new_id)
+          self.class.add_client_server(new_id, client_server)
+          client_server.write_signal_id
+          next
+        else
+          raise "Invalid type #{type}"
+        end
+      end
+    end
+
+    def read_signal_id
+      stream.read(4).unpack(ID_FORMAT).first
+    end
+  end
+end
+DRb::DRbProtocol.add_protocol(DRbFire::Protocol)

data/lib/rumplayer.rb

@@ -0,0 +1,13 @@
+require_dependency 'drbfire'
+module Rumplayer
+  include DRb::DRbUndumped
+
+
+  module Log
+    def log(message)
+      if $options[:verbose]
+        STDERR.puts message
+      end
+    end
+  end
+end

data/lib/rumplayer/client.rb

@@ -0,0 +1,84 @@
+class Rumplayer::Client
+  include DRb::DRbUndumped
+  include Rumplayer::Log
+  include Rumplayer::Config
+  include Rumplayer::Mplayer
+
+  def self.wait
+    new.wait
+  end
+
+  def self.run(argv=[])
+    client = new(argv).run_and_tell
+  end
+
+  attr_reader :argv
+  def initialize(argv=[])
+    @argv = argv
+  end
+
+  def run_and_tell argv=argv
+    enter
+    tell(argv)
+  end
+
+  def run argv=argv
+    log "Running #{argv.inspect}"
+    if is_slave?
+      @mplayer_thread = Thread.start{ run_mplayer argv }
+    else
+      run_mplayer argv
+    end
+  end
+
+  def wait
+    enter
+    say "waiting for command"
+    sleep 100000
+    log "tired of waiting"
+  end
+
+  def enter
+    say "Connecting.."
+    log "Started as %s" % start_service.uri
+    buddies.register(self, name)
+    trap('INT') { leave }
+  end
+
+  def start_service
+    @service = DRb.start_service(config['uri'], self, DRbFire::ROLE => DRbFire::CLIENT)
+    @service
+  end
+
+  def leave
+    log "leaving"
+    buddies.unregister(self) if @buddies
+    DRb.stop_service
+    kill_mplayer!
+    log "joining loose threads"
+    @mplayer_thread.join(1) if @mplayer_thread
+    log "exiting"
+    DRb.thread.join if DRb.thread
+    say "killing remaining %i threads (you may want ctrl+c manually)" % Thread.list.size
+    Thread.list.map(&:kill)
+    exit
+  end
+
+  def say(message="no message")
+    STDERR.puts message
+  end
+
+  def tell argv=argv
+    log "Telling #{argv.inspect}"
+    buddies.run(argv.dup)
+  end
+
+  def buddies
+    @buddies ||= DRbObject.new(nil, config['uri'])
+  end
+
+  def is_slave?
+    argv.empty?
+  end
+
+end

data/lib/rumplayer/config.rb

@@ -0,0 +1,57 @@
+module Rumplayer
+  module Config
+    def username
+      `whoami`.chomp
+    end
+
+    def hostname
+      `hostname`.chomp
+    end
+
+    def name
+      @name ||= [username, hostname].join('@')
+    end
+
+    def config_path
+      File.join( ENV['HOME'], '.rumplayer.yml' )
+    end
+
+    def config_exists?
+      File.exists? config_path
+    end
+
+    def default_config
+      {
+        'uri' => "drbfire://localhost:18383"
+      }
+    end
+
+    def config
+      return @config if @config
+      unless config_exists?
+        write_default_config 
+        say "written default config to #{config_path}"
+        say "please edit it"
+      end
+      load_config
+    end
+
+    private
+    def write_default_config
+      write_config default_config
+    end
+
+    def write_config config=@config
+      File.open(config_path, 'w') do |f|
+        f.puts config.to_yaml
+      end
+    end
+
+    def load_config
+      @config = YAML.load( File.read(config_path ))
+      log "loaded config %s" % @config.inspect
+      @config
+    end
+  end
+end
+

data/lib/rumplayer/mplayer.rb

@@ -0,0 +1,85 @@
+module Rumplayer::Mplayer
+  MplayerCommand = `which mplayer`.chomp
+  MplayerOptions = %w(-really-quiet)
+
+  def key(char)
+    leave if char == "\003"
+    leave if char == "q"
+    synchronize do
+      @mplayer_pipe.print char
+    end if @mplayer_pipe
+  end
+
+  def kill_mplayer!
+    Process.kill("TERM", @mplayer) if mplayer_is_running?
+    clean_up_all_traces_of_mplayer!
+  end
+
+  def mplayer_is_running?
+    @mplayer and `ps -p #{@mplayer}`.chomp.lines.count > 1
+  end
+
+  def clean_up_all_traces_of_mplayer!
+    @mplayer_pipe.close rescue nil
+    @mplayer = nil
+  end
+
+  private
+  def run_mplayer argv=argv, options ={}
+    kill_mplayer!
+    log "starting mplayer"
+    rd, wr = IO.pipe
+    @mplayer = fork do
+      STDIN.reopen(rd)
+      command = [MplayerCommand] + MplayerOptions + options.to_a.flatten + argv
+      exec(*command)
+    end
+    Process::detach(@mplayer)
+    @mplayer_pipe = wr
+    forward_keys
+    clean_up_all_traces_of_mplayer!
+    log "Finished playing #{argv.inspect}"
+  end
+
+  def forward_keys
+    while @mplayer
+      char = read_char
+      if ["\003", "q"].include? char
+        buddies.say("#{name} has quit. You should quit, too (with 'q' or ctrl+c)")
+        buddies.leave
+      else
+        buddies.key(char)
+      end
+    end
+  end
+
+  def read_char
+    begin
+      # save previous state of stty
+      old_state = `stty -g`
+      # disable echoing and enable raw (not having to press enter)
+      system "stty raw -echo"
+      c = STDIN.getc.chr
+      if c == "\e"
+        extra_thread = Thread.new do
+          c = c + STDIN.getc.chr
+          c = c + STDIN.getc.chr
+        end
+        extra_thread.join(0.00001)
+        extra_thread.kill
+      end
+    rescue => ex
+      puts "#{ex.class}: #{ex.message}"
+      puts ex.backtrace
+    ensure
+      # restore previous state of stty
+      system "stty #{old_state}"
+    end
+    return c
+  end
+
+  def synchronize(&block)
+    @mplayer_mutex ||= Mutex.new
+    @mplayer_mutex.synchronize(&block)
+  end
+end

data/lib/rumplayer/server.rb

@@ -0,0 +1,89 @@
+class Rumplayer::Server
+  include DRb::DRbUndumped
+  include Rumplayer::Log
+  include Rumplayer::Config
+
+  class Watcher < Struct.new(:handler, :name)
+    @@last_index = 0
+    attr_reader :index
+    def self.next_index
+      @@last_index += 1
+      @@last_index
+    end
+    def initialize(*args)
+      super
+      @index = self.class.next_index
+    end
+    def method_missing(method_name, *args, &block)
+      handler.__send__(method_name, *args, &block)
+    end
+    def to_s
+      "#{name} (#{index}) [#{handler.__drburi}]"
+    end
+  end
+
+  def self.start(argv=[])
+    new.start
+  end
+
+  def initialize
+    @watchers = []
+  end
+
+  def start
+    log "Starting Server"
+    DRb.start_service(config['uri'], self, DRbFire::ROLE => DRbFire::SERVER)
+    DRb.thread.join
+  end
+
+  def register(client, name=nil)
+    watcher = Watcher.new(client, name || client.inspect)
+    log "connected #{watcher}"
+
+    say("#{watcher.name} connected")
+    watcher.say "Connected."
+    if @watchers.empty?
+      watcher.say "no other buddies connected (yet)"
+    else
+      watcher.say "Buddies: %s" % @watchers.map(&:name).join(', ')
+    end
+    @watchers << watcher
+    log "currently connected: %i" % @watchers.size
+  end
+
+  def unregister(client)
+    if watcher = @watchers.find {|w| w.handler == client }
+      watcher.say "Goodbye"
+      remove_watcher watcher
+    end
+  end
+
+  def method_missing(method_name, *args, &block)
+    log "#{method_name} to all: #{args.inspect}"
+    each_watcher do |watcher|
+      watcher.__send__(method_name, *args, &block)
+    end
+  end
+
+  def each_watcher
+    unless @watchers.blank?
+      @watchers.each do |watcher|
+        begin
+          yield(watcher)
+        rescue DRb::DRbConnError => e
+          remove_watcher(watcher)
+        rescue RangeError => e
+          log "got RangeError, trying to continue"
+        end
+      end
+    end
+  end
+
+  def remove_watcher watcher
+    @watchers.delete(watcher)
+    log "disconnected #{watcher}"
+    log "currently connected: %i" % @watchers.size
+    say("#{watcher.name} disconnected")
+  end
+
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: rumplayer
+version: !ruby/object:Gem::Version 
+  version: 0.1.1
+platform: ruby
+authors: 
+- Niklas Hofer
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-15 00:00:00 +01:00
+default_executable: rumplayer
+dependencies: []
+
+description: "\n      RumPlayer allows you and your buddies to watch movies simultaneously\n      without sharing the room or continent. All participans must have a copy\n      of the movie to watch.\n    "
+email: niklas+rumplayer@lanpartei.de
+executables: 
+- rumplayer
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- Rakefile
+- lib/drbfire.rb
+- lib/rumplayer.rb
+- lib/rumplayer/client.rb
+- lib/rumplayer/config.rb
+- lib/rumplayer/mplayer.rb
+- lib/rumplayer/server.rb
+- README.markdown
+has_rdoc: true
+homepage: http://github.com/niklas/rumplayer/
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: watch common movies simultaneously
+test_files: []
+