- using TimeSpan where appropriate in API signatures

- implemented Release

Author: sdether

Beanstalk.Client/BeanstalkClient.cs

@@ -114,7 +114,7 @@ public string CurrentTube {
             }
         }
 
-        public PutResponse Put(uint priority, uint delay, uint timeToRun, Stream request, long length) {
+        public PutResponse Put(uint priority, TimeSpan delay, TimeSpan timeToRun, Stream request, long length) {
             var response = Exec(Request.Create(RequestCommand.Put)
                 .AppendArgument(priority)
                 .AppendArgument(delay)
@@ -142,8 +142,19 @@ public Job Reserve() {
             throw new ShouldNeverHappenException();
         }
 
-        public Job Reserve(uint timeout) {
-            throw new NotImplementedException();
+        public Job Reserve(TimeSpan timeout) {
+            var response = Exec(Request.Create(RequestCommand.Reserve)
+                .AppendArgument(timeout)
+                .ExpectStatuses(ResponseStatus.DeadlineSoon | ResponseStatus.TimedOut| ResponseStatus.Reserved));
+            switch(response.Status) {
+                case ResponseStatus.Reserved:
+                    return new Job(uint.Parse(response.Arguments[0]), response.Data, long.Parse(response.Arguments[1]));
+                case ResponseStatus.TimedOut:
+                    throw new TimedoutException();
+                case ResponseStatus.DeadlineSoon:
+                    throw new DeadlineSoonException();
+            }
+            throw new ShouldNeverHappenException();
         }
 
         public bool Delete(uint jobId) {
@@ -153,8 +164,13 @@ public bool Delete(uint jobId) {
             return response.Status == ResponseStatus.Deleted;
         }
 
-        public ReleaseStatus Release(uint jobId, uint priority, uint delay) {
-            throw new NotImplementedException();
+        public ReleaseStatus Release(uint jobId, uint priority, TimeSpan delay) {
+            var response = Exec(Request.Create(RequestCommand.Release)
+                .AppendArgument(jobId)
+                .AppendArgument(priority)
+                .AppendArgument(delay)
+                .ExpectStatuses(ResponseStatus.Released | ResponseStatus.Buried | ResponseStatus.NotFound));
+            return response.Status.ToReleaseStatus();
         }
 
         public bool Bury(uint jobId, uint priority) {

Beanstalk.Client/BeanstalkClientExceptions.cs

@@ -21,14 +21,14 @@
 using Droog.Beanstalk.Client.Protocol;
 
 namespace Droog.Beanstalk.Client {
-    public abstract class BeanstalkClientExceptions : Exception {
-        protected BeanstalkClientExceptions() { }
-        protected BeanstalkClientExceptions(string message) : base(message) { }
-        protected BeanstalkClientExceptions(string message, Exception exception) : base(message, exception) { }
+    public abstract class BeanstalkClientException : Exception {
+        protected BeanstalkClientException() { }
+        protected BeanstalkClientException(string message) : base(message) { }
+        protected BeanstalkClientException(string message, Exception exception) : base(message, exception) { }
     }
 
     public class EmptyResponseException : ConnectionException { }
-    public abstract class ConnectionException : BeanstalkClientExceptions {
+    public abstract class ConnectionException : BeanstalkClientException {
         protected ConnectionException() { }
         protected ConnectionException(string message) : base(message) { }
 
@@ -37,24 +37,25 @@ public class ReadException : ConnectionException {
         public ReadException(string message) : base(message) { }
     }
     public class WriteException : ConnectionException { }
-    public class DeadlineSoonException : BeanstalkClientExceptions { }
-    public class ShouldNeverHappenException : BeanstalkClientExceptions { }
+    public class TimedoutException : BeanstalkClientException { }
+    public class DeadlineSoonException : BeanstalkClientException { }
+    public class ShouldNeverHappenException : BeanstalkClientException { }
 
-    public class ConnectException : BeanstalkClientExceptions {
+    public class ConnectException : BeanstalkClientException {
         public ConnectException(Exception exception)
             : base("Unable to Connect to Beanstalk server", exception) {
         }
     }
 
-    public class UnknowResponseException : BeanstalkClientExceptions {
+    public class UnknowResponseException : BeanstalkClientException {
         public readonly string Response;
         public UnknowResponseException(string response)
             : base(string.Format("Response '{0}' is not supported by this client", response)) {
             Response = response;
         }
     }
 
-    public class InvalidStatusException : BeanstalkClientExceptions {
+    public class InvalidStatusException : BeanstalkClientException {
         public readonly RequestCommand Command;
         public readonly ResponseStatus Status;
 
@@ -65,12 +66,20 @@ public InvalidStatusException(RequestCommand command, ResponseStatus status)
         }
     }
 
-    public class PutFailedException : BeanstalkClientExceptions {
+    public class PutFailedException : BeanstalkClientException {
         public readonly ResponseStatus Status;
 
         public PutFailedException(ResponseStatus status)
             : base(string.Format("Put failed with response '{0}'", status)) {
             Status = status;
         }
     }
+
+    public class InvalidReleaseStatusException : BeanstalkClientException {
+        public readonly ResponseStatus Status;
+        public InvalidReleaseStatusException(ResponseStatus status)
+            : base(string.Format("Unable to convert response status '{0}' to ReleaseStatus", status)) {
+            Status = status;
+        }
+    }
 }

Beanstalk.Client/IBeanstalkClient.cs

@@ -35,15 +35,15 @@ public interface IBeanstalkClient : IDisposable
         // Consumer related
         string CurrentTube { get; set; }
 
-        PutResponse Put(uint priority, uint delay, uint timeToRun, Stream request, long length);
+        PutResponse Put(uint priority, TimeSpan delay, TimeSpan timeToRun, Stream request, long length);
 
         // Producer related
         ICollection<string> WatchedTubes { get; }
 
         Job Reserve();
-        Job Reserve(uint timeout);
+        Job Reserve(TimeSpan timeout);
         bool Delete(uint jobId);
-        ReleaseStatus Release(uint jobId, uint priority, uint delay);
+        ReleaseStatus Release(uint jobId, uint priority, TimeSpan delay);
         bool Bury(uint jobId, uint priority);
         bool Touch(uint jobId);
 

Beanstalk.Client/Protocol/Extensions.cs

@@ -48,7 +48,7 @@ public static void SendRequest(this ISocket socket, Request request, byte[] buff
         private static void SendBuffer(this ISocket socket, byte[] buffer, int count) {
             var offset = 0;
             while(count > 0) {
-                Console.WriteLine(Encoding.ASCII.GetString(buffer,offset,count));
+                Console.WriteLine(Encoding.ASCII.GetString(buffer, offset, count));
                 var sent = socket.Send(buffer, offset, count);
                 offset += sent;
                 count -= sent;
@@ -126,5 +126,14 @@ public static Response ReceiveResponse(this ISocket socket, byte[] buffer) {
             }
             return response;
         }
+
+        public static ReleaseStatus ToReleaseStatus(this ResponseStatus status) {
+            try {
+                Enum.Parse(typeof(ReleaseStatus), status.ToString());
+            } catch {
+                throw new InvalidReleaseStatusException(status);
+            }
+        }
     }
+
 }

Beanstalk.Client/Protocol/Request.cs

@@ -82,6 +82,13 @@ public Request AppendArgument(uint arg) {
             return this;
         }
 
+        public Request AppendArgument(TimeSpan arg) {
+            ThrowIfDone();
+            _request.WriteByte((byte)' ');
+            _request.Write(Encoding.ASCII.GetBytes(((uint)arg.TotalSeconds).ToString()));
+            return this;
+        }
+
         public Request WithData(Stream data, long dataLength) {
             ThrowIfDone();
             _data = data;