audioscrobbler 0.0.1 → 0.0.2

data/audioscrobbler.gemspec

@@ -1,7 +1,7 @@
 require 'rubygems'
 SPEC = Gem::Specification.new do |s|
   s.name          = "audioscrobbler"
-  s.version       = "0.0.1"
+  s.version       = "0.0.2"
   s.author        = "Daniel Erat"
   s.email         = "dan-ruby@erat.org"
   s.homepage      = "http://www.erat.org/ruby/"

data/lib/audioscrobbler.rb

@@ -9,19 +9,26 @@
 # description is located at http://www.audioscrobbler.net/wiki/Protocol1.1 .
 #
 # == Version
-# 0.0.1
+# 0.0.2
 #
 # == Author
 # Daniel Erat <dan-ruby@erat.org>
 #
 # == Copyright
-# Copyright 2005 Daniel Erat
+# Copyright 2007 Daniel Erat
 #
 # == License
 # GNU GPL; see COPYING
 #
 # == Changes
 # 0.0.1  Initial release
+# 0.0.2  Upgraded from v1.1 to v1.2 of the Audioscrobbler protocol.  This means:
+#        - "Now Playing" notifications
+#        - callers should now submit when tracks stop playing instead of as
+#          soon as the submission criteria is met
+#        - track numbers can be submitted
+#        Also added a race condition that I haven't bothered fixing (I
+#        think I'm the only person using this library?).
 
 require "cgi"
 require "md5"
@@ -36,8 +43,8 @@ require "uri"
 # Last.fm (http://www.last.fm) using the Audioscrobbler plugin protocol
 # (http://www.audioscrobbler.net/).
 #
-# Version 1.1 of the plugin protocol
-# (http://www.audioscrobbler.net/wiki/Protocol1.1) is currently used.
+# Version 1.2 of the plugin protocol
+# (http://www.audioscrobbler.net/development/protocol/) is currently used.
 #
 # == Usage
 #  require "audioscrobbler"
@@ -55,7 +62,17 @@ require "uri"
 #  # submission queue.
 #  scrob.start_submitter_thread
 #
-#  # Now wait until the Audioscrobbler submission criteria has been met.
+#  # Report the currently-playing song:
+#  scrob.report_now_playing("Beach Boys",      # artist
+#                           "God Only Knows",  # title
+#                           175,               # track length, in seconds
+#                           "Pet Sounds",      # album (optional)
+#                           "",                # MusicBrainzID (optional)
+#                           "8",               # track number (optional)
+#                          )
+#
+#  # Now wait until the Audioscrobbler submission criteria has been met and
+#  # the track has finished playing.
 #
 #  # And then queue the track for submission:
 #  scrob.enqueue("Beach Boys",      # artist
@@ -64,13 +81,13 @@ require "uri"
 #                1125378558,        # track start time
 #                "Pet Sounds",      # album (optional)
 #                "",                # MusicBrainzID (optional)
+#                "8",               # track number (optional)
 #               )
 class Audioscrobbler
-  # Default URI to connect to for the handshake.
-  DEFAULT_HANDSHAKE_URI = "http://post.audioscrobbler.com/"
+  # Default URL to connect to for the handshake.
+  DEFAULT_HANDSHAKE_URL = "http://post.audioscrobbler.com/"
 
   # Default minimum interval to wait between successful submissions.
-  # This will be overriden if the server supplies an interval.
   DEFAULT_SUBMIT_INTERVAL_SEC = 5
 
   # Default plugin name and version to report to the server.
@@ -99,16 +116,18 @@ class Audioscrobbler
     @client = DEFAULT_CLIENT
     @version = DEFAULT_VERSION
 
-    @handshake_uri = DEFAULT_HANDSHAKE_URI
+    @handshake_url = DEFAULT_HANDSHAKE_URL
     @last_handshake_time = nil
     @handshake_backoff_sec = 0
+    @hard_failures = 0
 
-    @md5_resp = nil
-    @submit_uri = nil
+    @session_id = nil
+    @submit_url = nil
+    @now_playing_url = nil
     @submit_interval_sec = DEFAULT_SUBMIT_INTERVAL_SEC
   end
   attr_accessor :username, :password, :verbose
-  attr_accessor :client, :version, :handshake_uri
+  attr_accessor :client, :version, :handshake_url
 
   ##
   # Update the backoff interval after handshake failure.  If we haven't
@@ -135,33 +154,39 @@ class Audioscrobbler
   # If the connection fails, @handshake_backoff_sec is also updated
   # appropriately.  Wait this long before trying to handshake again.
   #
-  def do_handshake
+  def do_handshake(can_sleep=true)
     # Sleep before trying again if needed.
-    if @last_handshake_time != nil and \
-        @last_handshake_time + @handshake_backoff_sec > Time.now
+    if can_sleep and
+       @last_handshake_time != nil and
+       @last_handshake_time + @handshake_backoff_sec > Time.now
       sleep(@last_handshake_time + @handshake_backoff_sec - Time.now)
     end
 
     @last_handshake_time = Time.now
+    timestamp = Time.now.to_i.to_s
+    auth_token = MD5.hexdigest(MD5.hexdigest(@password) + timestamp)
 
     args = {
-      "hs" => "true",
-      "p"  => "1.1",
-      "c"  => @client,
-      "v"  => @version,
-      "u"  => @username,
+      'hs' => 'true',
+      'p'  => '1.2',
+      'c'  => @client,
+      'v'  => @version,
+      'u'  => @username,
+      't'  => timestamp,
+      'a'  => auth_token,
     }
-    uri = @handshake_uri + '?' + args.collect {|attr, value|
+    arg_pairs = args.collect do |attr, value|
       CGI.escape(attr.to_s) + '=' + CGI.escape(value.to_s)
-    }.join('&')
+    end
+    url = @handshake_url + '?' + arg_pairs.join('&')
 
-    vlog("Beginning handshake with #@handshake_uri")
+    vlog("Beginning handshake with #@handshake_url")
 
     begin
-      data = Net::HTTP.get_response(URI.parse(uri)).body
+      data = Net::HTTP.get_response(URI.parse(url)).body
     rescue Exception
       handle_handshake_failure(
-        "Read of #@handshake_uri for handshake failed: #{$!}")
+        "Read of #@handshake_url for handshake failed: #{$!}")
       return false
     end
 
@@ -172,47 +197,33 @@ class Audioscrobbler
       return false
     end
 
+    # The expected response is:
+    # OK
+    # Session ID
+    # Now-Playing URL
+    # Submission URL
     lines = data.split("\n")
-
-    # Check whether the server says we can talk to it.
-    # INTERVAL is supposed to be returned even on failure, but we don't
-    # bother looking at it in this case because we already back off
-    # extremely aggressively from handshake failures, and we'll end up
-    # getting a new submission interval when we handshake successfully.
     response = lines[0].split[0]
-    if response != "UPTODATE" and response != "UPDATE"
-      handle_handshake_failure("Got \"#{lines[0]}\" from server during " \
-                               "handshake (expected UPTODATE or UPDATE)")
+    if response != 'OK'
+      handle_handshake_failure(
+        "Got \"#{lines[0]}\" from server during handshake (expected OK)")
       return false
     end
 
-    # The expected response is something along the lines of:
-    # UPTODATE or UPDATE <plugin uri>
-    # <md5 challenge>
-    # <uri to submit script>
-    # INTERVAL <num>
-    if lines.length < 3
+    if lines.length != 4
       handle_handshake_failure(
-        "Got #{lines.length} during handshake (expected >=3)")
+        "Got #{lines.length} during handshake (expected 4)")
       return false
     end
 
     # Create our response based on the server's challenge and
-    # save the submission URI.
-    @md5_resp = MD5.hexdigest(MD5.hexdigest(@password) + lines[1])
-    @submit_uri = lines[2]
-    vlog("Using MD5 response #@md5_resp")
-    vlog("Got submission URI #@submit_uri")
-
-    # Get submission interval.
-    if lines.length < 4 or lines[3].split.length != 2 or \
-        lines[3].split[0] != "INTERVAL"
-      vlog("Didn't get submission interval; using #@submit_interval_sec sec")
-    else
-      @submit_interval_sec = lines[3].split[0].to_i
-      vlog("Got submission interval of #@submit_interval_sec sec")
-    end
+    # save the submission URL.
+    @session_id, @now_playing_url, @submit_url = lines[1,3]
+    vlog("Got session ID #@session_id, submission URL " \
+         "#@submit_url, and now-playing URL #@now_playing_url")
 
+    @handshake_backoff_sec = 0
+    @hard_failures = 0
     return true
   end
   private :do_handshake
@@ -227,41 +238,39 @@ class Audioscrobbler
         tracks = @queue.peek(MAX_TRACKS_IN_SUBMISSION)
 
         # Keep trying to handshake until we're successful.
-        do_handshake while not @md5_resp
+        do_handshake while not @session_id
 
         # Might as well re-check in case more tracks have shown up
-        # during the handshaking.
+        # during the handshake.
         tracks = @queue.peek(MAX_TRACKS_IN_SUBMISSION)
         vlog("Submitting #{tracks.length} track(s)")
 
         # Construct our argument list.
-        args = {
-          "u" => @username,
-          "s" => @md5_resp,
-        }
+        args = { "s" => @session_id }
         for i in 0..tracks.length-1
           args.update({
             "a[#{i}]" => tracks[i].artist,
             "t[#{i}]" => tracks[i].title,
+            "i[#{i}]" => Time.at(tracks[i].start_time).to_i,
+            "o[#{i}]" => 'P',
+            "r[#{i}]" => '',
+            "l[#{i}]" => tracks[i].length.to_s,
             "b[#{i}]" => tracks[i].album,
+            "n[#{i}]" => tracks[i].track_num,
             "m[#{i}]" => tracks[i].mbid,
-            "l[#{i}]" => tracks[i].length.to_s,
-            "i[#{i}]" => Time.at(tracks[i].start_time).utc.
-                         strftime('%Y-%m-%d %H:%M:%S')
           })
         end
         # Convert it into a single escaped string for the body.
         body = args.collect {|k, v| "#{k}=" + CGI.escape(v.to_s) }.join('&')
 
-        success = false
-
         begin
-          uri = URI.parse(@submit_uri)
-          data = Net::HTTP.start(uri.host, uri.port) do |http|
-            http.post(uri.path, body).body
+          url = URI.parse(@submit_url)
+          headers = { 'Content-Type' => 'application/x-www-form-urlencoded' }
+          data = Net::HTTP.start(url.host, url.port) do |http|
+            http.post(url.path, body, headers).body
           end
         rescue Exception
-          vlog("Submission failed -- couldn't read #@submit_uri: #{$!}")
+          vlog("Submission failed -- couldn't read #@submit_url: #{$!}")
         else
           # Check whether the submission was successful.
           lines = data.split("\n")
@@ -270,43 +279,83 @@ class Audioscrobbler
           elsif lines[0] == "OK"
             vlog("Submission was successful")
             @queue.delete(tracks.length)
-            success = true
-          elsif lines[0] == "BADAUTH"
-            vlog("Submission failed -- authorization failed")
-            # Unset the hash so we'll re-handshake.
-            @md5_resp = nil
+          elsif lines[0] == "BADSESSION"
+            vlog("Submission failed -- session is invalid")
+            # Unset the session ID so we'll re-handshake.
+            @session_id = nil
           else
             vlog("Submission failed -- got unknown response \"#{lines[0]}\"")
-          end
-
-          # Use the server-supplied submission interval, or our default
-          # if the server didn't supply one.
-          if lines.length > 1 and lines[1].split[0] and \
-              lines[1].split[0] == "INTERVAL" and lines[1].split[1]
-            @submit_interval_sec = lines[1].split[1].to_i
-          else
-            @submit_interval_sec = DEFAULT_SUBMIT_INTERVAL_SEC
+            @hard_failures += 1
           end
         end
 
-        # If we failed, do exponential backoff starting at 60 seconds.
-        # Better safe than blocked!
-        if not success
-          if @submit_interval_sec < 60
-            @submit_interval_sec = 60
-          else
-            @submit_interval_sec *= 2
-          end
-          vlog("Because of failure, backing off to #@submit_interval_sec sec")
+        if @hard_failures >= 3
+          vlog("Got #@hard_failures failures; re-handshaking")
+          @session_id = nil
         end
 
         vlog("Sleeping #@submit_interval_sec sec before checking for " \
-            "more tracks")
+             "more tracks")
         sleep(@submit_interval_sec)
       end
     end
   end
 
+  ##
+  # Report the track that is currently playing.
+  # Returns true if the report was successful and false otherwise.
+  #
+  # @param artist      artist name
+  # @param title       track name
+  # @param length      track length
+  # @param album       album name
+  # @param mbid        MusicBrainz ID
+  # @param track_num   track number on album
+  #
+  def report_now_playing(artist, title, length, album="", mbid="",
+                         track_num='')
+    vlog("Reporting \"#{artist} - #{title}\" as now-playing")
+
+    # FIXME(derat): Huge race condition here between us and the submission
+    # thread, but I am to lazy to fix it right now.
+    if not @session_id
+      do_handshake(false)
+    end
+
+    # Construct our argument list.
+    args = {
+      's' => @session_id,
+      'a' => artist,
+      't' => title,
+      'b' => album,
+      'l' => length.to_i,
+      'n' => track_num,
+      'm' => mbid,
+    }
+    # Convert it into a single escaped string for the body.
+    body = args.collect {|k, v| "#{k}=" + CGI.escape(v.to_s) }.join('&')
+
+    success = false
+    url = URI.parse(@now_playing_url)
+    headers = { 'Content-Type' => 'application/x-www-form-urlencoded' }
+    begin
+      data = Net::HTTP.start(url.host, url.port) do |http|
+        http.post(url.path, body, headers).body
+      end
+    rescue Exception
+      vlog("Submission failed -- couldn't read #@now_playing_url: #{$!}")
+    else
+      data.chomp!
+      if data == "OK"
+        vlog("Now-playing report was successful")
+        success = true
+      else
+        vlog("Now-playing report failed -- got \"#{data}\"")
+      end
+    end
+    success
+  end
+
   ##
   # Enqueue a track for submission.
   #
@@ -316,9 +365,26 @@ class Audioscrobbler
   # @param start_time  track start time, as UTC unix time
   # @param album       album name
   # @param mbid        MusicBrainz ID
+  # @param track_num   track number on album
   #
-  def enqueue(artist, title, length, start_time, album="", mbid="")
-    @queue.append(artist, title, length, start_time, album, mbid)
+  def enqueue(artist, title, length, start_time, album="", mbid="",
+              track_num=nil)
+    if not length or length < 30
+      log("Ignoring #{artist} - #{title}, as it is #{length} second(s) " \
+          "long (min is 30 seconds)")
+      return
+    elsif not artist or artist == ''
+      log("Ignoring #{title}, as it is missing an artist tag")
+      return
+    elsif not title or title == ''
+      log("Ignoring #{artist}, as it is missing a title tag")
+      return
+    elsif not start_time or start_time <= 0
+      log("Ignoring #{artist} - #{title} with bogus start time #{start_time}")
+      return
+    end
+
+    @queue.append(artist, title, length, start_time, album, mbid, track_num)
   end
 
   ##
@@ -375,10 +441,13 @@ class Audioscrobbler
     # @param start_time  track start time, as UTC unix time
     # @param album       album name
     # @param mbid        MusicBrainz ID
+    # @param track_num   track number on album
     #
-    def append(artist, title, length, start_time, album="", mbid="")
+    def append(artist, title, length, start_time, album="", mbid="",
+               track_num=nil)
       @mutex.synchronize do
-        track = PlayedTrack.new(artist, title, length, start_time, album, mbid)
+        track = PlayedTrack.new(artist, title, length, start_time, album, mbid,
+                                track_num)
         File.open(@filename, "a") {|f| f.puts(track.serialize) } if @filename
         @queue.push(track)
         @condvar.signal
@@ -433,24 +502,29 @@ class Audioscrobbler
       # @param start_time  track start time, as UTC unix time
       # @param album       album name
       # @param mbid        MusicBrainz ID
+      # @param track_num   track number on album
       #
-      def initialize(artist, title, length, start_time, album="", mbid="")
+      def initialize(artist, title, length, start_time, album="", mbid="",
+                     track_num=nil)
         @artist = artist.to_s
         @title = title.to_s
         @length = length.to_i
         @start_time = start_time.to_i
         @album = album ? album.to_s : ""
         @mbid = mbid ? mbid.to_s : ""
+        @track_num = track_num ? track_num.to_s : ""
       end
-      attr_reader :artist, :title, :length, :start_time, :album, :mbid
+      attr_reader :artist, :title, :length, :start_time, :album, \
+                  :mbid, :track_num
 
       ##
       # Convert this track's information into a form suitable for writing to
       # a text file.  Returns a string.
       #
       def serialize
-        [@artist, @title, @length.to_s, @start_time.to_s,
-          @album, @mbid].collect {|x| x ? CGI.escape(x) : "" }.join("\t")
+        parts = [@artist, @title, @length.to_s, @start_time.to_s,
+                 @album, @mbid, @track_num]
+        parts.collect {|x| x ? CGI.escape(x) : "" }.join("\t")
       end
 
       ##
@@ -460,7 +534,7 @@ class Audioscrobbler
       # @param str  serialized PlayedTrack to deserialize (string)
       #
       def self.deserialize(str)
-        PlayedTrack.new(*str.split("\t", 6).collect {|x|
+        PlayedTrack.new(*str.split("\t").collect {|x|
           x ? CGI.unescape(x) : "" })
       end
 
@@ -468,7 +542,7 @@ class Audioscrobbler
         other.class == PlayedTrack and @artist == other.artist and
           @title == other.title and @length == other.length and
           @start_time == other.start_time and @album == other.album and
-          @mbid == other.mbid
+          @mbid == other.mbid and @track_num == other.track_num
       end
     end  # class PlayedTrack
   end  # class SubmissionQueue

data/test/test_audioscrobbler.rb

@@ -17,6 +17,8 @@
 # == License
 # GNU GPL; see COPYING
 
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
 require 'audioscrobbler'
 require 'cgi'
 require 'md5'
@@ -44,15 +46,16 @@ end
 
 # Implements the handshake portion of the Audioscrobbler protocol.
 class AudioscrobblerHandshakeServlet < WEBrick::HTTPServlet::AbstractServlet
-  def initialize(server, status, user, challenge, submit_url,
-                 plugin_name='tst', plugin_version=0.1)
+  def initialize(server, status, user, password, session_id, submit_url,
+                 now_playing_url, plugin_name='tst', plugin_version=0.1)
     @status = status
     @user = user
-    @challenge = challenge
+    @password = password
+    @session_id = session_id
     @submit_url = submit_url
+    @now_playing_url = now_playing_url
     @plugin_name = plugin_name
     @plugin_version = plugin_version
-    @failure_interval = 1
   end
 
   def do_GET(req, res)
@@ -64,7 +67,7 @@ class AudioscrobblerHandshakeServlet < WEBrick::HTTPServlet::AbstractServlet
     begin
       if req.query['hs'] != 'true'
         throw "FAILED Handshake not requested"
-      elsif req.query['p'] != '1.1'
+      elsif req.query['p'] != '1.2'
         throw "FAILED Wrong or missing protocol version"
       elsif req.query['c'] != @plugin_name
         throw "FAILED Wrong or missing plugin name"
@@ -72,15 +75,19 @@ class AudioscrobblerHandshakeServlet < WEBrick::HTTPServlet::AbstractServlet
         throw "FAILED Missing plugin version"
       elsif req.query['u'] != @user
         throw "BADUSER"
+      elsif not req.query['t']
+        throw "BADTIME Missing timestamp"
+      elsif req.query['a'] !=
+            MD5.hexdigest(MD5.hexdigest(@password) + req.query['t'])
+        throw "BADAUTH Invalid auth token"
       end
 
-      # TODO(derat): Test UPDATE responses?
       @status.successes += 1
-      res.body = "UPTODATE\n#@challenge\n#@submit_url\nINTERVAL 0"
+      res.body = "OK\n#@session_id\n#@now_playing_url\n#@submit_url\n"
 
     rescue RuntimeError
       @status.failures += 1
-      res.body = "#{$!.message}\nINTERVAL #@failure_interval"
+      res.body = "#{$!.message}\n"
     end
   end  # do_GET
 end  # AudioscrobblerHandshakeServlet
@@ -89,21 +96,27 @@ end  # AudioscrobblerHandshakeServlet
 # Stores a submitted track.  Used by AudioscrobblerSubmitStatus.
 class Track
   def initialize(artist=nil, title=nil, length=nil, start_time=nil,
-                 album=nil, mbid=nil)
+                 album=nil, mbid=nil, track_num=nil, source=nil,
+                 rating=nil)
     @artist = artist
     @title = title
     @length = length
     @start_time = start_time
     @album = album
     @mbid = mbid
+    @track_num = track_num
+    @source = source
+    @rating = rating
   end
-  attr_accessor :artist, :title, :length, :start_time, :album, :mbid
+  attr_accessor :artist, :title, :length, :start_time, :album, :mbid, \
+                :track_num, :source, :rating
 
   def ==(other)
     other.class == Track and @artist == other.artist and
       @title == other.title and @length == other.length and
       @start_time == other.start_time and @album == other.album and
-      @mbid == other.mbid
+      @mbid == other.mbid and @track_num == other.track_num and
+      @source == other.source and @rating == other.rating
   end
 end
 
@@ -128,18 +141,16 @@ end
 
 # Implements the track submission portion of the Audioscrobbler protocol.
 class AudioscrobblerSubmitServlet < WEBrick::HTTPServlet::AbstractServlet
-  def initialize(server, status, user, password, challenge)
+  def initialize(server, status, session_id)
     @status = status
-    @user = user
-    @md5 = MD5.hexdigest(MD5.hexdigest(password) + challenge)
-    @failure_interval = 1
+    @session_id = session_id
   end
 
   # POST is supposed to be used rather than GET.
   def do_GET(req, res)
     @status.attempts += 1
     @status.failures += 1
-    res.body = "FAILED Use POST, not GET\nINTERVAL #@failure_interval"
+    res.body = "FAILED Use POST, not GET\n"
   end
 
   def do_POST(req, res)
@@ -148,29 +159,26 @@ class AudioscrobblerSubmitServlet < WEBrick::HTTPServlet::AbstractServlet
 
     begin
       # Make sure that they authenticated correctly.
-      if req.query['u'] != @user
-        raise "BADAUTH"
-      elsif req.query['s'] != @md5
-        raise "BADAUTH"
+      if req.query['s'] != @session_id
+        raise "BADSESSION"
       end
 
       # Handle the track parameters.
       tracks = []
       req.query.each_pair do |k, v|
-        if k =~ /^([atbmli])\[(\d+)\]$/
+        if k =~ /^([atiorlbnm])\[(\d+)\]$/
           track = (tracks[$2.to_i] ||= Track.new)
           v = CGI.unescape(v)
           case
           when $1 == 'a': track.artist = v
           when $1 == 't': track.title = v
+          when $1 == 'i': track.start_time = v.to_i
+          when $1 == 'o': track.source = v
+          when $1 == 'r': track.rating = v
+          when $1 == 'l': track.length = v.to_i
           when $1 == 'b': track.album = v
+          when $1 == 'n': track.track_num = v.to_i
           when $1 == 'm': track.mbid = v
-          when $1 == 'l': track.length = v.to_i
-          when $1 == 'i':
-            # We get start times in a strange format, but it's more
-            # convenient to store them as seconds since the epoch.
-            v =~ /^(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})$/
-            track.start_time = Time.gm($1, $2, $3, $4, $5, $6).to_i
           end
         end
       end
@@ -180,7 +188,8 @@ class AudioscrobblerSubmitServlet < WEBrick::HTTPServlet::AbstractServlet
         if not track
           raise "FAILED Missing track"
         elsif not track.artist or not track.title or not track.album or
-              not track.mbid or not track.length or not track.start_time
+              not track.mbid or not track.length or not track.start_time or
+              not track.track_num or not track.source or not track.rating
           raise "FAILED Missing parameter"
         elsif track.artist.length == 0 or track.title.length == 0 or
               track.length == 0 or track.start_time == 0
@@ -198,32 +207,103 @@ class AudioscrobblerSubmitServlet < WEBrick::HTTPServlet::AbstractServlet
       # If we get here, then we didn't find any problems.
       @status.tracks += tracks
       @status.successes += 1
-      res.body = "OK\nINTERVAL 0"
+      res.body = "OK\n"
 
     # If we threw an exception, return an error.
     rescue RuntimeError
       @status.failures += 1
-      res.body = "#{$!.message}\nINTERVAL #@failure_interval"
+      res.body = "#{$!.message}\n"
     end
   end # do_POST
 end  # AudioscrobblerSubmitServlet
 
 
+# Implements the now-playing portion of the Audioscrobbler protocol.
+class AudioscrobblerNowPlayingServlet < WEBrick::HTTPServlet::AbstractServlet
+  def initialize(server, status, session_id)
+    @status = status
+    @session_id = session_id
+  end
+
+  # POST is supposed to be used rather than GET.
+  def do_GET(req, res)
+    @status.attempts += 1
+    @status.failures += 1
+    res.body = "FAILED Use POST, not GET\n"
+  end
+
+  def do_POST(req, res)
+    @status.attempts += 1
+    res['Content-Type'] = "text/plain"
+
+    begin
+      # Make sure that they authenticated correctly.
+      if req.query['s'] != @session_id
+        raise "BADSESSION"
+      end
+
+      # Handle the track parameters.
+      track = Track.new
+      req.query.each_pair do |k, v|
+        if %w{a t b l n m}.member? k
+          v = CGI.unescape(v)
+          case
+          when k == 'a': track.artist = v
+          when k == 't': track.title = v
+          when k == 'b': track.album = v
+          when k == 'l': track.length = v.to_i
+          when k == 'n': track.track_num = v.to_i
+          when k == 'm': track.mbid = v
+          end
+        end
+      end
+
+      # Make sure that no data was missing from the submitted tracks.
+      if not track.artist or not track.title or not track.album or
+         not track.mbid or not track.length or not track.track_num
+        raise "FAILED Missing parameter"
+      elsif track.artist.length == 0 or track.title.length == 0 or
+            track.length == 0
+        raise "FAILED Empty required parameter"
+      end
+
+      # If we get here, then we didn't find any problems.
+      @status.tracks << track
+      @status.successes += 1
+      res.body = "OK\n"
+
+    # If we threw an exception, return an error.
+    rescue RuntimeError
+      @status.failures += 1
+      res.body = "#{$!.message}\n"
+    end
+  end # do_POST
+end  # AudioscrobblerNowPlayingServlet
+
+
 # Regression test for the Audioscrobbler class.
 class TestAudioscrobbler < Test::Unit::TestCase
   def test_audioscrobbler
     @handshake_status = AudioscrobblerHandshakeStatus.new
     @submit_status = AudioscrobblerSubmitStatus.new
+    @now_playing_status = AudioscrobblerSubmitStatus.new
     # FIXME(derat): Is there some better way to choose a port here?
     @http_port = 16349
 
     @server_thread = Thread.new do
       s = WEBrick::HTTPServer.new(:BindAddress => "127.0.0.1",
-                                  :Port => @http_port)
+                                  :Port => @http_port,
+                                  :Logger => WEBrick::Log.new(
+                                      nil, WEBrick::BasicLog::WARN),
+                                  :AccessLog => [])
       s.mount("/handshake", AudioscrobblerHandshakeServlet, @handshake_status,
-              "username", "challenge", "http://127.0.0.1:#@http_port/submit")
+              "username", "password", "sessionid",
+              "http://127.0.0.1:#@http_port/submit",
+              "http://127.0.0.1:#@http_port/nowplaying")
       s.mount("/submit", AudioscrobblerSubmitServlet, @submit_status,
-              "username", "password", "challenge")
+              "sessionid")
+      s.mount("/nowplaying", AudioscrobblerNowPlayingServlet,
+              @now_playing_status, "sessionid")
       trap("INT") { s.shutdown }
       s.start
     end
@@ -231,23 +311,35 @@ class TestAudioscrobbler < Test::Unit::TestCase
     a = Audioscrobbler.new("username", "password")
     a.client = "tst"
     a.version = "1.1"
-    a.handshake_uri = "http://127.0.0.1:#@http_port/handshake"
-    a.verbose = true
+    a.handshake_url = "http://127.0.0.1:#@http_port/handshake"
+    a.verbose = false
 
     a.start_submitter_thread
 
     tracks = []
     tracks.push(Track.new("Beck", "Devil's Haircut", 100, 1128285297,
-      "Odelay", ''))
-    tracks.push(Track.new("Faith No More", "Midlife Crisis", 100, 1128285297,
-      "Angel Dust", ''))
-    tracks.push(Track.new("Hans Zimmer", "Greed", 100, 1128285297,
-      "Broken Arrow", ''))
-    tracks.push(Track.new("M�m", "Sleepswim", 100, 1128285297,
-      "Finally We Are No One", ''))
+                          "Odelay", 'abc', 1, 'P', ''))
+    tracks.push(Track.new("Faith No More", "Midlife Crisis", 101, 1128285298,
+                          "Angel Dust", 'def', 2, 'P', ''))
+    tracks.push(Track.new("Hans Zimmer", "Greed", 102, 1128285299,
+                          "Broken Arrow", 'ghi', 3, 'P', ''))
+    tracks.push(Track.new("M�m", "Sleepswim", 103, 1128285300,
+                          "Finally We Are No One", 'jkl', 4, 'P', ''))
+    now_playing = []
+    now_playing.push(Track.new('Harold Budd', 'Sandtreader', 334, nil,
+                               'Lovely Thunder', 'abc', 2))
+    now_playing.push(Track.new('Sasha', 'Boileroom', 424, nil,
+                               'Airdrawndagger', 'def', 7))
 
     tracks.each do |t|
-      a.enqueue(t.artist, t.title, t.length, t.start_time, t.album, t.mbid)
+      a.enqueue(t.artist, t.title, t.length, t.start_time, t.album, t.mbid,
+                t.track_num)
+    end
+
+    sleep 0.1  # avoid race condition :-/
+    now_playing.each do |t|
+      a.report_now_playing(t.artist, t.title, t.length, t.album, t.mbid,
+                           t.track_num)
     end
 
     # FIXME(derat): This is awful.  I should add functionality to
@@ -255,12 +347,16 @@ class TestAudioscrobbler < Test::Unit::TestCase
     # submit the just-enqueued track.
     sleep 3
 
-    assert_equal(@handshake_status.failures, 0)
+    assert_equal(0, @handshake_status.failures)
     assert(@handshake_status.successes > 0)
 
-    assert_equal(@submit_status.failures, 0)
+    assert_equal(0, @submit_status.failures)
     assert(@submit_status.successes > 0)
 
-    assert_equal(@submit_status.tracks, tracks)
+    assert_equal(0, @now_playing_status.failures)
+    assert_equal(2, @now_playing_status.successes)
+
+    assert_equal(tracks, @submit_status.tracks)
+    assert_equal(now_playing, @now_playing_status.tracks)
   end  # test_audioscrobbler
 end  # TestAudioscrobbler

data/test/test_queue.rb

@@ -16,6 +16,8 @@
 # == License
 # GNU GPL; see COPYING
 
+$:.unshift File.join(File.dirname(__FILE__), "..", "lib")
+
 require 'audioscrobbler'
 require 'tempfile'
 require 'test/unit'
@@ -25,23 +27,37 @@ class Audioscrobbler
     class TestPlayedTrack < Test::Unit::TestCase
       def test_members
         t = PlayedTrack.new(
-          'Cylob', 'Stomping FM', 100, 1128285297, 'Lobster Tracks', nil)
-        assert_equal(t.artist, 'Cylob')
-        assert_equal(t.title, 'Stomping FM')
-        assert_equal(t.length, 100)
-        assert_equal(t.start_time, 1128285297)
-        assert_equal(t.album, 'Lobster Tracks')
-        assert_equal(t.mbid, '')  # nil should be converted to ''
+          'Cylob', 'Stomping FM', 100, 1128285297, 'Lobster Tracks',
+          'abc', 3)
+        assert_equal('Cylob', t.artist)
+        assert_equal('Stomping FM', t.title)
+        assert_equal(100, t.length)
+        assert_equal(1128285297, t.start_time)
+        assert_equal('Lobster Tracks', t.album)
+        assert_equal('abc', t.mbid)
+        assert_equal('3', t.track_num)
+      end
+
+      def test_empty_members
+        t = PlayedTrack.new(
+          'Cylob', 'Stomping FM', 200, 1128285298, nil, nil, nil)
+        assert_equal('Cylob', t.artist)
+        assert_equal('Stomping FM', t.title)
+        assert_equal(200, t.length)
+        assert_equal(1128285298, t.start_time)
+        assert_equal('', t.album)
+        assert_equal('', t.mbid)
+        assert_equal('', t.track_num)
       end
 
       def test_serialization
         t = PlayedTrack.new(
-          'Katamari Damacy', 'WANDA WANDA', 100, 1128285297, 'OST', 'blah')
+          'Katamari Damacy', 'WANDA WANDA', 100, 1128285297, 'OST', 'blah', 5)
         assert_equal(t,
           PlayedTrack.deserialize(t.serialize))
 
         t = PlayedTrack.new(
-          'Def Leppard', 'Photograph', 100, 1128285297, nil, 'blah')
+          'Def Leppard', 'Photograph', 100, 1128285297, nil, 'blah', 6)
         assert_equal(t,
           PlayedTrack.deserialize(t.serialize))
       end
@@ -69,14 +85,14 @@ class Audioscrobbler
       q = SubmissionQueue.new(@filename)
 
       tracks = q.peek(1)
-      assert_equal(tracks.length, 1)
-      assert_equal(tracks[0].artist, 'Kraftwerk')
+      assert_equal(1, tracks.length)
+      assert_equal('Kraftwerk', tracks[0].artist)
 
       q.delete(1)
       tracks = q.peek(5)
-      assert_equal(tracks.length, 2)
-      assert_equal(tracks[0].artist, 'Iron Maiden')
-      assert_equal(tracks[1].artist, 'Herbie Hancock')
+      assert_equal(2, tracks.length)
+      assert_equal('Iron Maiden', tracks[0].artist)
+      assert_equal('Herbie Hancock', tracks[1].artist)
     end
 
     def teardown

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.11
+rubygems_version: 0.9.3
 specification_version: 1
 name: audioscrobbler
 version: !ruby/object:Gem::Version 
-  version: 0.0.1
-date: 2005-10-02 00:00:00 -07:00
+  version: 0.0.2
+date: 2007-08-26 00:00:00 -07:00
 summary: Library to submit music playlists to Last.fm
 require_paths: 
-  - lib
+- lib
 email: dan-ruby@erat.org
 homepage: http://www.erat.org/ruby/
 rubyforge_project: 
@@ -18,34 +18,40 @@ bindir: bin
 has_rdoc: true
 required_ruby_version: !ruby/object:Gem::Version::Requirement 
   requirements: 
-    - 
-      - ">"
-      - !ruby/object:Gem::Version 
-        version: 0.0.0
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
   version: 
 platform: ruby
 signing_key: 
 cert_chain: 
+post_install_message: 
 authors: 
-  - Daniel Erat
+- Daniel Erat
 files: 
-  - MANIFEST
-  - COPYING
-  - INSTALL
-  - setup.rb
-  - README
-  - lib
-  - test
-  - audioscrobbler.gemspec
-  - lib/audioscrobbler.rb
-  - test/test_audioscrobbler.rb
-  - test/test_queue.rb
+- MANIFEST
+- COPYING
+- INSTALL
+- setup.rb
+- README
+- lib
+- test
+- audioscrobbler.gemspec
+- lib/audioscrobbler.rb
+- test/test_audioscrobbler.rb
+- test/test_queue.rb
 test_files: 
-  - test/test_audioscrobbler.rb
-  - test/test_queue.rb
+- test/test_audioscrobbler.rb
+- test/test_queue.rb
 rdoc_options: []
+
 extra_rdoc_files: []
+
 executables: []
+
 extensions: []
+
 requirements: []
-dependencies: []
+
+dependencies: []
+