Prepare for crates

See CHANGELOG as there may be breaking changes with this Update.

Closes #71

Author: jrconlin

rust/vapid/CHANGELOG.md

@@ -0,0 +1,20 @@
+# 0.2.0
+
+Due to changes in the OpenSSL library, several calls changed form from `0.1.0`
+
+Most calls now return as a `Result<_, VapidError>`. `VapidError` is a type of `failure` call, so it should make logging and error handling a bit easier.
+
+This does mean that
+
+```rust, no_run
+let key = Key::generate();
+```
+is now
+```rust, no_run
+let key = Key.generate().unwrap();
+```
+
+The `.group()` method for `Key` has been removed. It was a convenience function. You can replace it with generating the group directly
+`ec::EcGroup::from_curve_name(nid::Nid::X9_62_PRIME256V1)?`
+
+There are now `VapidErrors`

rust/vapid/Cargo.toml

@@ -1,10 +1,15 @@
 [package]
 name = "vapid"
-version = "0.1.0"
+version = "0.2.0"
 authors = ["jrconlin <[email protected]>"]
+edition = "2018"
+description = "An implementation of the RFC 8292 Voluntary Application Server Identification (VAPID) Auth header generator"
+repository = "https://github.com/web-push-libs/vapid"
+license = "MPL 2.0"
 
 [dependencies]
-openssl = "0.9.16"
-serde_json = "1.0.2"
-base64 = "0.6.0"
+openssl = "0.10"
+serde_json = "1.0"
+base64 = "0.10"
 time = "0.1"
+failure = "0.1"

rust/vapid/src/error.rs

@@ -0,0 +1,65 @@
+// Error handling based on the failure crate
+
+use std::fmt;
+use std::result;
+
+use failure::{Backtrace, Context, Error, Fail};
+
+pub type VapidResult<T> = result::Result<T, Error>;
+
+#[derive(Debug)]
+pub struct VapidError {
+    inner: Context<VapidErrorKind>,
+}
+
+#[derive(Clone, Eq, PartialEq, Debug, Fail)]
+pub enum VapidErrorKind {
+    #[fail(display = "Invalid public key")]
+    PublicKeyError,
+    #[fail(display = "VAPID error: {}", _0)]
+    VapidError(String),
+    #[fail(display = "Internal Error {:?}", _0)]
+    InternalError(String),
+}
+
+/*
+impl VapidError {
+    pub fn kind(&self) -> &VapidErrorKind {
+        self.inner.get_context()
+    }
+}
+*/
+
+impl Fail for VapidError {
+    fn cause(&self) -> Option<&Fail> {
+        self.inner.cause()
+    }
+
+    fn backtrace(&self) -> Option<&Backtrace> {
+        self.inner.backtrace()
+    }
+}
+
+impl fmt::Display for VapidError {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        fmt::Display::fmt(&self.inner, f)
+    }
+}
+
+impl From<VapidErrorKind> for VapidError {
+    fn from(kind: VapidErrorKind) -> VapidError {
+        Context::new(kind).into()
+    }
+}
+
+impl From<Context<VapidErrorKind>> for VapidError {
+    fn from(inner: Context<VapidErrorKind>) -> VapidError {
+        VapidError { inner }
+    }
+}
+
+impl From<Error> for VapidError {
+    fn from(err: Error) -> VapidError {
+        VapidErrorKind::InternalError(format!("Error: {:?}", err)).into()
+    }
+}