Merge pull request #9 from jordansjones/serializable-exceptions

Serializable Exceptions
jordansjones · Aug 24, 2016 · 1a4d858 · 1a4d858
2 parents 79748e4 + 1965bcc
commit 1a4d858
Show file tree

Hide file tree

Showing 41 changed files with 415 additions and 16 deletions.
diff --git a/ReleaseNotes.md b/ReleaseNotes.md
@@ -1,3 +1,6 @@
+### New in 1.0.3 (Release 2016/08/24)
+* Fixed: All Exceptions are now `[Serializable]`
+
 ### New in 1.0.2 (Release 2016/08/01)
 * New: `IEtcdClient.Cluster.GetHealth()` - Retrieve the health status of the etcd cluster.
 

diff --git a/source/Draft/Draft-Net45.csproj b/source/Draft/Draft-Net45.csproj
@@ -118,6 +118,7 @@
     <Compile Include="Exceptions\ValueRequiredException.cs" />
     <Compile Include="Exceptions\WatcherClearedException.cs" />
     <Compile Include="Extensions\FormBodyBuilder.Extensions.cs" />
+    <Compile Include="Extensions\SerializationInfoExtensions.cs" />
     <Compile Include="Extensions\TimeToLiveExtensions.cs" />
     <Compile Include="Extensions\ValueConverter.RequestExtensions.cs" />
     <Compile Include="Extensions\ValueConverter.ResponseExtensions.cs" />

diff --git a/source/Draft/Exceptions/BadRequestException.cs b/source/Draft/Exceptions/BadRequestException.cs
@@ -1,11 +1,14 @@
 using System;
 using System.Linq;
+using System.Runtime.Serialization;
+using System.Security.Permissions;
 
 namespace Draft.Exceptions
 {
     /// <summary>
     ///     Represents a general problem with the requst to etcd.
     /// </summary>
+    [Serializable]
     public class BadRequestException : EtcdException
     {
 
@@ -18,6 +21,12 @@ public BadRequestException() {}
         ///     Initializes a new <see cref="BadRequestException" /> instance with a specified error message.
         /// </summary>
         public BadRequestException(string message) : base(message) {}
+
+        /// <summary>
+        ///     Initializes a new <see cref="BadRequestException" /> instance for use in BCL deserialization
+        /// </summary>
+        [SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)]
+        protected BadRequestException(SerializationInfo info, StreamingContext context) : base(info, context) {}
 
         /// <summary>
         ///     Indicates that this exception is due to a general problem with the request to etcd.

diff --git a/source/Draft/Exceptions/ClientInternalException.cs b/source/Draft/Exceptions/ClientInternalException.cs
@@ -1,11 +1,14 @@
 using System;
 using System.Linq;
+using System.Runtime.Serialization;
+using System.Security.Permissions;
 
 namespace Draft.Exceptions
 {
     /// <summary>
     ///     Represents an internal client error.
     /// </summary>
+    [Serializable]
     public class ClientInternalException : EtcdException
     {
 
@@ -18,6 +21,12 @@ public ClientInternalException() {}
         ///     Initializes a new <see cref="ClientInternalException" /> instance with a specified error message.
         /// </summary>
         public ClientInternalException(string message) : base(message) {}
+
+        /// <summary>
+        ///     Initializes a new <see cref="ClientInternalException" /> instance for use in BCL deserialization
+        /// </summary>
+        [SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)]
+        protected ClientInternalException(SerializationInfo info, StreamingContext context) : base(info, context) {}
 
         /// <summary>
         ///     Indicates that this exception is due to an internal client error

diff --git a/source/Draft/Exceptions/DirectoryNotEmptyException.cs b/source/Draft/Exceptions/DirectoryNotEmptyException.cs
@@ -1,11 +1,14 @@
 using System;
 using System.Linq;
+using System.Runtime.Serialization;
+using System.Security.Permissions;
 
 namespace Draft.Exceptions
 {
     /// <summary>
     ///     Represents an error where the directory operation failed due to still present children.
     /// </summary>
+    [Serializable]
     public class DirectoryNotEmptyException : EtcdException
     {
 
@@ -18,6 +21,12 @@ public DirectoryNotEmptyException() {}
         ///     Initializes a new <see cref="DirectoryNotEmptyException" /> instance with a specified error message.
         /// </summary>
         public DirectoryNotEmptyException(string message) : base(message) {}
+
+        /// <summary>
+        ///     Initializes a new <see cref="DirectoryNotEmptyException" /> instance for use in BCL deserialization
+        /// </summary>
+        [SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)]
+        protected DirectoryNotEmptyException(SerializationInfo info, StreamingContext context) : base(info, context) {}
 
         /// <summary>
         ///     Indicates that this exception is due to the passed directory still containing children.

diff --git a/source/Draft/Exceptions/EtcdException.cs b/source/Draft/Exceptions/EtcdException.cs
@@ -3,27 +3,47 @@
 using System.Linq;
 using System.Net;
 using System.Net.Http;
+using System.Runtime.Serialization;
+using System.Security.Permissions;
 
 using Draft.Responses;
 
+using Newtonsoft.Json;
+
 namespace Draft.Exceptions
 {
     /// <summary>
     ///     Base exception that is thrown when etcd returns an error response.
     /// </summary>
     [ExcludeFromCodeCoverage]
+    [Serializable]
     public abstract class EtcdException : Exception
     {
-
         /// <summary>
         ///     Initializes a new <see cref="EtcdException" /> instance.
         /// </summary>
-        protected EtcdException() {}
+        protected EtcdException()
+        {
+        }
 
         /// <summary>
         ///     Initializes a new <see cref="EtcdException" /> instance with a specified error message.
         /// </summary>
-        protected EtcdException(string message) : base(message) {}
+        protected EtcdException(string message) : base(message)
+        {
+        }
+
+        /// <summary>
+        ///     Initializes a new <see cref="EtcdException" /> instance for use in BCL deserialization
+        /// </summary>
+        [SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)]
+        protected EtcdException(SerializationInfo info, StreamingContext context) : base(info, context)
+        {
+            info.TryGetString(nameof(EtcdError), x => EtcdError = JsonConvert.DeserializeObject<EtcdError>(x));
+            info.TryGetString(nameof(EtcdError), x => HttpStatusCode = (HttpStatusCode) Enum.Parse(typeof(HttpStatusCode), x, true));
+            info.TryGetString(nameof(RequestMethod), x => RequestMethod = new HttpMethod(x));
+            info.TryGetString(nameof(RequestUrl), x => RequestUrl = x);
+        }
 
         /// <summary>
         ///     The parsed etcd error message if available.
@@ -334,5 +354,34 @@ public virtual bool IsWatcherCleared
         /// </summary>
         public string RequestUrl { get; internal set; }
 
+        /// <inheritdoc />
+        [SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)]
+        public override void GetObjectData(SerializationInfo info, StreamingContext context)
+        {
+            if (info == null)
+            {
+                throw new ArgumentNullException(nameof(info));
+            }
+
+            if (EtcdError != null)
+            {
+                info.AddValue(nameof(EtcdError), JsonConvert.SerializeObject(EtcdError));
+            }
+            if (HttpStatusCode != null)
+            {
+                info.AddValue(nameof(HttpStatusCode), HttpStatusCode.Value.ToString());
+            }
+            if (RequestMethod != null)
+            {
+                info.AddValue(nameof(RequestMethod), RequestMethod.Method);
+            }
+            if (RequestUrl != null)
+            {
+                info.AddValue(nameof(RequestUrl), RequestUrl);
+            }
+
+            // Must call through to the base class to let it save it's own state
+            base.GetObjectData(info, context);
+        }
     }
-}
+}
diff --git a/source/Draft/Exceptions/EtcdTimeoutException.cs b/source/Draft/Exceptions/EtcdTimeoutException.cs
@@ -1,14 +1,33 @@
 using System;
 using System.Linq;
+using System.Runtime.Serialization;
+using System.Security.Permissions;
 
 namespace Draft.Exceptions
 {
     /// <summary>
     /// Represents an error due to an HTTP request/response timeout.
     /// </summary>
+    [Serializable]
     public class EtcdTimeoutException : EtcdException
     {
-
+
+        /// <summary>
+        ///     Initializes a new <see cref="EtcdTimeoutException" /> instance.
+        /// </summary>
+        public EtcdTimeoutException() {}
+
+        /// <summary>
+        ///     Initializes a new <see cref="EtcdTimeoutException" /> instance with a specified error message.
+        /// </summary>
+        public EtcdTimeoutException(string message) : base(message) {}
+
+        /// <summary>
+        ///     Initializes a new <see cref="DirectoryNotEmptyException" /> instance for use in BCL deserialization
+        /// </summary>
+        [SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)]
+        protected EtcdTimeoutException(SerializationInfo info, StreamingContext context) : base(info, context) {}
+
         /// <summary>
         ///     Indicates that this exception is due to an HTTP timeout error.
         /// </summary>

diff --git a/source/Draft/Exceptions/EventIndexClearedException.cs b/source/Draft/Exceptions/EventIndexClearedException.cs
@@ -1,11 +1,14 @@
 using System;
 using System.Linq;
+using System.Runtime.Serialization;
+using System.Security.Permissions;
 
 namespace Draft.Exceptions
 {
     /// <summary>
     ///     Represents an error where the event in the requested index is outdated and cleared.
     /// </summary>
+    [Serializable]
     public class EventIndexClearedException : EtcdException
     {
 
@@ -19,6 +22,12 @@ public EventIndexClearedException() {}
         /// </summary>
         public EventIndexClearedException(string message) : base(message) {}
 
+        /// <summary>
+        ///     Initializes a new <see cref="EventIndexClearedException" /> instance for use in BCL deserialization
+        /// </summary>
+        [SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)]
+        protected EventIndexClearedException(SerializationInfo info, StreamingContext context) : base(info, context) {}
+
         /// <summary>
         ///     Indicates that this exception is due to the event in the requested index is outdated and cleared.
         /// </summary>

diff --git a/source/Draft/Exceptions/ExistingPeerAddressException.cs b/source/Draft/Exceptions/ExistingPeerAddressException.cs
@@ -1,11 +1,14 @@
 using System;
 using System.Linq;
+using System.Runtime.Serialization;
+using System.Security.Permissions;
 
 namespace Draft.Exceptions
 {
     /// <summary>
     ///     Represents an error where the operation's passed peer address value matched an existing peer address in etcd.
     /// </summary>
+    [Serializable]
     public class ExistingPeerAddressException : EtcdException
     {
 
@@ -18,6 +21,12 @@ public ExistingPeerAddressException() {}
         ///     Initializes a new <see cref="ExistingPeerAddressException" /> instance with a specified error message.
         /// </summary>
         public ExistingPeerAddressException(string message) : base(message) {}
+
+        /// <summary>
+        ///     Initializes a new <see cref="ExistingPeerAddressException" /> instance for use in BCL deserialization
+        /// </summary>
+        [SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)]
+        protected ExistingPeerAddressException(SerializationInfo info, StreamingContext context) : base(info, context) {}
 
         /// <summary>
         ///     Indicates that this exception is due to there being an existing peer address that matches the value passed.

diff --git a/source/Draft/Exceptions/HttpConnectionException.cs b/source/Draft/Exceptions/HttpConnectionException.cs
@@ -1,11 +1,14 @@
 using System;
 using System.Linq;
+using System.Runtime.Serialization;
+using System.Security.Permissions;
 
 namespace Draft.Exceptions
 {
     /// <summary>
     ///     Represents an error with the underlying http client when attempting to connect to an etcd endpoint.
     /// </summary>
+    [Serializable]
     public class HttpConnectionException : EtcdException
     {
 
@@ -18,6 +21,12 @@ public HttpConnectionException() {}
         ///     Initializes a new <see cref="HttpConnectionException" /> instance with a specified error message.
         /// </summary>
         public HttpConnectionException(string message) : base(message) {}
+
+        /// <summary>
+        ///     Initializes a new <see cref="HttpConnectionException" /> instance for use in BCL deserialization
+        /// </summary>
+        [SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)]
+        protected HttpConnectionException(SerializationInfo info, StreamingContext context) : base(info, context) {}
 
         /// <summary>
         ///     Indicates that this exception is due to an underlying http client connection error.

diff --git a/source/Draft/Exceptions/IndexNotANumberException.cs b/source/Draft/Exceptions/IndexNotANumberException.cs
@@ -1,11 +1,14 @@
 using System;
 using System.Linq;
+using System.Runtime.Serialization;
+using System.Security.Permissions;
 
 namespace Draft.Exceptions
 {
     /// <summary>
     ///     Represents an error where etcd was unable parse the passed index value into a number.
     /// </summary>
+    [Serializable]
     public class IndexNotANumberException : EtcdException
     {
 
@@ -18,6 +21,12 @@ public IndexNotANumberException() {}
         ///     Initializes a new <see cref="IndexNotANumberException" /> instance with a specified error message.
         /// </summary>
         public IndexNotANumberException(string message) : base(message) {}
+
+        /// <summary>
+        ///     Initializes a new <see cref="IndexNotANumberException" /> instance for use in BCL deserialization
+        /// </summary>
+        [SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)]
+        protected IndexNotANumberException(SerializationInfo info, StreamingContext context) : base(info, context) {}
 
         /// <summary>
         ///     Indicates that this exception is due to etcd being unable to parse the passed index value as a number.

diff --git a/source/Draft/Exceptions/IndexOrValueRequiredException.cs b/source/Draft/Exceptions/IndexOrValueRequiredException.cs
@@ -1,11 +1,14 @@
 using System;
 using System.Linq;
+using System.Runtime.Serialization;
+using System.Security.Permissions;
 
 namespace Draft.Exceptions
 {
     /// <summary>
     ///     Represents an error where the etcd operation requires an index or value parameter, but neither was provided.
     /// </summary>
+    [Serializable]
     public class IndexOrValueRequiredException : EtcdException
     {
 
@@ -18,6 +21,12 @@ public IndexOrValueRequiredException() {}
         ///     Initializes a new <see cref="IndexOrValueRequiredException" /> instance with a specified error message.
         /// </summary>
         public IndexOrValueRequiredException(string message) : base(message) {}
+
+        /// <summary>
+        ///     Initializes a new <see cref="IndexOrValueRequiredException" /> instance for use in BCL deserialization
+        /// </summary>
+        [SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)]
+        protected IndexOrValueRequiredException(SerializationInfo info, StreamingContext context) : base(info, context) {}
 
         /// <summary>
         ///     Indicates that this exception is due to the request missing the index or value property.

diff --git a/source/Draft/Exceptions/IndexValueMutexException.cs b/source/Draft/Exceptions/IndexValueMutexException.cs
@@ -1,11 +1,14 @@
 using System;
 using System.Linq;
+using System.Runtime.Serialization;
+using System.Security.Permissions;
 
 namespace Draft.Exceptions
 {
     /// <summary>
     ///     Represents an error where the etcd operation requires an index or value parameter, but both was provided.
     /// </summary>
+    [Serializable]
     public class IndexValueMutexException : EtcdException
     {
 
@@ -18,6 +21,12 @@ public IndexValueMutexException() {}
         ///     Initializes a new <see cref="IndexValueMutexException" /> instance with a specified error message.
         /// </summary>
         public IndexValueMutexException(string message) : base(message) {}
+
+        /// <summary>
+        ///     Initializes a new <see cref="IndexValueMutexException" /> instance for use in BCL deserialization
+        /// </summary>
+        [SecurityPermission(SecurityAction.Demand, SerializationFormatter = true)]
+        protected IndexValueMutexException(SerializationInfo info, StreamingContext context) : base(info, context) {}
 
         /// <summary>
         ///     Indicates that this exception is due to "Index and value cannot both be specified."