lib/rmpd/connection.rb in rmpd-1.0.5 vs lib/rmpd/connection.rb in rmpd-1.1.0

@@ -1,84 +1,81 @@
 require "socket"
 
 
 module Rmpd
   class Connection
-
-    include Rmpd::Commands
     include Socket::Constants
+    include Rmpd::Commands
 
-    attr_reader :error
 
-    def initialize(config_file=nil)
-      @config = Rmpd::Config.new(config_file)
-      @socket = nil
-    end
+    MAX_RETRIES = 5
 
-    def server_version
-      "#{@server_version_major}.#{@server_version_minor}.#{@server_version_patch}"
-    end
 
     attr_reader :socket
 
-    private
 
-    def authenticate
-      raise "Socket no good!" if (@socket.nil? || @socket.closed?)
-      send_command("password", @config.password)
-      read_response
-      true
+    def initialize(config_file=nil)
+      @config = Rmpd::Config.new(config_file)
+      @socket = nil
     end
 
+    def close
+      @socket.close
+    end
+
     def connect
       return unless @socket.nil? || @socket.closed?
-      error = nil
 
       Socket::getaddrinfo(@config.hostname, @config.port, nil, SOCK_STREAM).each do |info|
         begin
-          puts "args: #{info.inspect}" if $DEBUG
           sockaddr = Socket.pack_sockaddr_in(info[1], info[3])
           @socket = Socket.new(info[4], info[5], 0)
           @socket.connect(sockaddr)
         rescue StandardError => error
           $stderr.puts "Failed to connect to #{info[3]}: #{error}"
           @socket = nil
+          raise MpdConnRefusedError.new(error)
         else
           break
         end
       end
-      raise MpdConnRefusedError.new(error) if @socket.nil?
 
-      parse_server_version(@socket.readline)
-      authenticate if @config.password
+      read_response # protocol version, ignore for now
+      password(@config.password) if @config.password
     end
 
-    def parse_server_version(version)
-      /OK MPD (\d+)\.(\d+)\.(\d+)/.match(version.to_s)
-      @server_version_major = $~[1].to_i
-      @server_version_minor = $~[2].to_i
-      @server_version_patch = $~[3].to_i
-    end
+    def send_command(command, *args)
+      tries = 0
 
-    def read_response(klass=Response, *args)
-      x = klass.new(receive_server_response, *args)
-      @error = x.error
-      x
+      begin
+        connect
+        @socket.puts("#{command} #{quote(args).join(" ")}".strip)
+      rescue Errno::EPIPE, EOFError
+        @socket.close
+        if (tries += 1) < MAX_RETRIES
+          retry
+        else
+          raise MpdError.new("Retry count exceeded")
+        end
+      end
     end
 
-    def server_version_at_least(major, minor, patch)
-      connect
-      e = MpdError.new("Requires server version #{major}.#{minor}.#{patch}")
+    def read_response
+      response = []
 
-      raise e if major > @server_version_major
-      return true if major < @server_version_major
+      while (line = @socket.readline)
+        response << line.strip
+        break if END_RE === line
+      end
+      response
+    end
 
-      raise e if minor > @server_version_minor
-      return true if minor < @server_version_minor
+    def mpd
+      self
+    end
 
-      raise e if patch > @server_version_patch
-      return true if patch < @server_version_patch
-      true
+    def quote(args)
+      args.collect {|arg| "\"#{arg.to_s.gsub(/"/, "\\\"")}\""}
     end
 
   end
 end