diff --git a/src/adormit/adormit.go b/src/adormit/adormit.go
index a23e1530364449ca1154a1ce5933d0ac65426810..2db34a038c5e67a32d53c4e2397dde1f51055a1c 100644
--- a/src/adormit/adormit.go
+++ b/src/adormit/adormit.go
@@ -1,10 +1,12 @@
package adormit
import (
+ "encoding/hex"
"errors"
"fmt"
"github.com/godbus/dbus"
"github.com/gotk3/gotk3/glib"
+ "github.com/satori/go.uuid"
"os/exec"
"reflect"
"time"
@@ -19,7 +21,7 @@ var CurrentAlarms map[string]Alarm
func Init() {
CurrentAlarms = make(map[string]Alarm)
- CurrentTimers = make([]Timer, 2)
+ CurrentTimers = make([]Timer, 0)
}
type Alarm struct {
@@ -28,6 +30,7 @@ type Alarm struct {
Time time.Time
Active bool
Id string
+ Uuid uuid.UUID
}
func (alarm Alarm) SetAlarm() string {
@@ -35,6 +38,7 @@ func (alarm Alarm) SetAlarm() string {
a := make(map[string]dbus.Variant)
a["name"] = dbus.MakeVariant(alarm.Name)
a["active"] = dbus.MakeVariant(alarm.Active)
+ a["id"] = dbus.MakeVariant(alarm.Id)
existing_alarms := GetGnomeAlarms()
insert = append(insert, a)
for _, v := range existing_alarms {
@@ -79,22 +83,37 @@ func (alarm Alarm) ToVariant() map[string]dbus.Variant {
return a
}
+func (alarm *Alarm) MakeId() {
+ //id = uuid of name + time
+ slug := alarm.Name + "60 seconds uwu"
+ ns, err := uuid.FromString("e3d6232f-6c5c-4345-bbae-c82d07530216")
+ if err != nil {
+ panic(err)
+ }
+ u := uuid.NewV5(ns, slug)
+ alarm.Uuid = u
+ alarm.Id = hex.EncodeToString(u.Bytes())
+ fmt.Println(alarm)
+}
+
type Timer struct {
Name string
- start time.Time
+ Start time.Time
Duration time.Duration
- end time.Time
+ End time.Time
+ Uuid uuid.UUID
Command string
Args []string
}
-func (t Timer) Countdown() {
- CurrentTimers = append(CurrentTimers, t)
- t.start = time.Now()
+func (t *Timer) Countdown() {
+ t.Uuid = uuid.Must(uuid.NewV4())
+ CurrentTimers = append(CurrentTimers, *t)
+ t.Start = time.Now()
timer1 := time.NewTimer(t.Duration)
<-timer1.C
fmt.Println("Timer completed")
- t.end = time.Now()
+ t.End = time.Now()
cmd := exec.Command(t.Command, t.Args...)
cmd.Run()
}
diff --git a/src/cmd/http.go b/src/cmd/http.go
index a38e437881de9fc71513e07e3b53ccb4965af0fd..d4f8ff3407cadf9eb283ae783ed8eddb7c90904f 100644
--- a/src/cmd/http.go
+++ b/src/cmd/http.go
@@ -4,6 +4,7 @@ import (
"adormit"
"github.com/spf13/cobra"
"gopkg.in/macaron.v1"
+ "log"
"net/http"
"strconv"
"time"
@@ -54,9 +55,21 @@ func listTimers(ctx *macaron.Context) {
return
}
-func newAlarm(req *http.Request) string {
+func newAlarm(req *http.Request, log *log.Logger) string {
//insert new alarm locally
- return "OK"
+ name := req.FormValue("name")
+ early, err := strconv.ParseBool(req.FormValue("early"))
+ // time, err := time.Parse("Mon Jan 2 15:04:05 -0700 MST 2006", req.FormValue("time"))
+ active, err := strconv.ParseBool(req.FormValue("active"))
+ if err != nil {
+ panic(err)
+ }
+ // id := adormit.MakeAlarmId()
+ a := adormit.Alarm{Active: active, Early: early, Name: name}
+ a.MakeId()
+ g := a.SetAlarm()
+ log.Printf("http/newAlarm: %s", a.Uuid)
+ return g
}
func delAlarm(req *http.Request) string {
// take id remove it from madormit.CurrentAlarms[:i]ap & gnome-clocks
diff --git a/src/cmd/version.go b/src/cmd/version.go
new file mode 100644
index 0000000000000000000000000000000000000000..2261f2cbc312e17cb154eed73dc798ad10c8a9da
--- /dev/null
+++ b/src/cmd/version.go
@@ -0,0 +1,20 @@
+package cmd
+
+import (
+ "adormit"
+ "fmt"
+ "github.com/spf13/cobra"
+)
+
+func init() {
+ RootCmd.AddCommand(versionCmd)
+}
+
+var versionCmd = &cobra.Command{
+ Use: "version",
+ Short: "Output the version of adormit",
+ Long: `Output the version of adormit `,
+ Run: func(cmd *cobra.Command, args []string) {
+ fmt.Println(adormit.Version())
+ },
+}
diff --git a/vendor/manifest b/vendor/manifest
index 00bdfb18cfa4dcb60755e4ed2a62c068972dbb83..beb0a8c23a8b50768a9d6f28047d30a4eedf9a22 100644
--- a/vendor/manifest
+++ b/vendor/manifest
@@ -93,6 +93,12 @@
"revision": "6d1ef893fcb01b4f50cb6e57ed7df3e2e627b6b2",
"branch": "master"
},
+ {
+ "importpath": "github.com/satori/go.uuid",
+ "repository": "https://github.com/satori/go.uuid",
+ "revision": "36e9d2ebbde5e3f13ab2e25625fd453271d6522e",
+ "branch": "master"
+ },
{
"importpath": "github.com/spf13/afero",
"repository": "https://github.com/spf13/afero",
diff --git a/vendor/src/github.com/satori/go.uuid/LICENSE b/vendor/src/github.com/satori/go.uuid/LICENSE
new file mode 100644
index 0000000000000000000000000000000000000000..926d5498702943ebb736819bb393159e5f84634b
--- /dev/null
+++ b/vendor/src/github.com/satori/go.uuid/LICENSE
@@ -0,0 +1,20 @@
+Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
diff --git a/vendor/src/github.com/satori/go.uuid/README.md b/vendor/src/github.com/satori/go.uuid/README.md
new file mode 100644
index 0000000000000000000000000000000000000000..770284969a8af7c5f5881e0e72ce4b63dcf61c57
--- /dev/null
+++ b/vendor/src/github.com/satori/go.uuid/README.md
@@ -0,0 +1,74 @@
+# UUID package for Go language
+
+[](https://travis-ci.org/satori/go.uuid)
+[](https://coveralls.io/github/satori/go.uuid)
+[](http://godoc.org/github.com/satori/go.uuid)
+
+This package provides pure Go implementation of Universally Unique Identifier (UUID). Supported both creation and parsing of UUIDs.
+
+With 100% test coverage and benchmarks out of box.
+
+Supported versions:
+* Version 1, based on timestamp and MAC address (RFC 4122)
+* Version 2, based on timestamp, MAC address and POSIX UID/GID (DCE 1.1)
+* Version 3, based on MD5 hashing (RFC 4122)
+* Version 4, based on random numbers (RFC 4122)
+* Version 5, based on SHA-1 hashing (RFC 4122)
+
+## Installation
+
+Use the `go` command:
+
+ $ go get github.com/satori/go.uuid
+
+## Requirements
+
+UUID package requires Go >= 1.2.
+
+## Example
+
+```go
+package main
+
+import (
+ "fmt"
+ "github.com/satori/go.uuid"
+)
+
+func main() {
+ // Creating UUID Version 4
+ // panic on error
+ u1 := uuid.Must(uuid.NewV4())
+ fmt.Printf("UUIDv4: %s\n", u1)
+
+ // or error handling
+ u2, err := uuid.NewV4()
+ if err != nil {
+ fmt.Printf("Something went wrong: %s", err)
+ return
+ }
+ fmt.Printf("UUIDv4: %s\n", u2)
+
+ // Parsing UUID from string input
+ u2, err := uuid.FromString("6ba7b810-9dad-11d1-80b4-00c04fd430c8")
+ if err != nil {
+ fmt.Printf("Something went wrong: %s", err)
+ }
+ fmt.Printf("Successfully parsed: %s", u2)
+}
+```
+
+## Documentation
+
+[Documentation](http://godoc.org/github.com/satori/go.uuid) is hosted at GoDoc project.
+
+## Links
+* [RFC 4122](http://tools.ietf.org/html/rfc4122)
+* [DCE 1.1: Authentication and Security Services](http://pubs.opengroup.org/onlinepubs/9696989899/chap5.htm#tagcjh_08_02_01_01)
+
+## Copyright
+
+Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>.
+
+UUID package released under MIT License.
+See [LICENSE](https://github.com/satori/go.uuid/blob/master/LICENSE) for details.
diff --git a/vendor/src/github.com/satori/go.uuid/codec.go b/vendor/src/github.com/satori/go.uuid/codec.go
new file mode 100644
index 0000000000000000000000000000000000000000..656892c53e071eb7756f9c4d4f02f72ffa4cb608
--- /dev/null
+++ b/vendor/src/github.com/satori/go.uuid/codec.go
@@ -0,0 +1,206 @@
+// Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+package uuid
+
+import (
+ "bytes"
+ "encoding/hex"
+ "fmt"
+)
+
+// FromBytes returns UUID converted from raw byte slice input.
+// It will return error if the slice isn't 16 bytes long.
+func FromBytes(input []byte) (u UUID, err error) {
+ err = u.UnmarshalBinary(input)
+ return
+}
+
+// FromBytesOrNil returns UUID converted from raw byte slice input.
+// Same behavior as FromBytes, but returns a Nil UUID on error.
+func FromBytesOrNil(input []byte) UUID {
+ uuid, err := FromBytes(input)
+ if err != nil {
+ return Nil
+ }
+ return uuid
+}
+
+// FromString returns UUID parsed from string input.
+// Input is expected in a form accepted by UnmarshalText.
+func FromString(input string) (u UUID, err error) {
+ err = u.UnmarshalText([]byte(input))
+ return
+}
+
+// FromStringOrNil returns UUID parsed from string input.
+// Same behavior as FromString, but returns a Nil UUID on error.
+func FromStringOrNil(input string) UUID {
+ uuid, err := FromString(input)
+ if err != nil {
+ return Nil
+ }
+ return uuid
+}
+
+// MarshalText implements the encoding.TextMarshaler interface.
+// The encoding is the same as returned by String.
+func (u UUID) MarshalText() (text []byte, err error) {
+ text = []byte(u.String())
+ return
+}
+
+// UnmarshalText implements the encoding.TextUnmarshaler interface.
+// Following formats are supported:
+// "6ba7b810-9dad-11d1-80b4-00c04fd430c8",
+// "{6ba7b810-9dad-11d1-80b4-00c04fd430c8}",
+// "urn:uuid:6ba7b810-9dad-11d1-80b4-00c04fd430c8"
+// "6ba7b8109dad11d180b400c04fd430c8"
+// ABNF for supported UUID text representation follows:
+// uuid := canonical | hashlike | braced | urn
+// plain := canonical | hashlike
+// canonical := 4hexoct '-' 2hexoct '-' 2hexoct '-' 6hexoct
+// hashlike := 12hexoct
+// braced := '{' plain '}'
+// urn := URN ':' UUID-NID ':' plain
+// URN := 'urn'
+// UUID-NID := 'uuid'
+// 12hexoct := 6hexoct 6hexoct
+// 6hexoct := 4hexoct 2hexoct
+// 4hexoct := 2hexoct 2hexoct
+// 2hexoct := hexoct hexoct
+// hexoct := hexdig hexdig
+// hexdig := '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9' |
+// 'a' | 'b' | 'c' | 'd' | 'e' | 'f' |
+// 'A' | 'B' | 'C' | 'D' | 'E' | 'F'
+func (u *UUID) UnmarshalText(text []byte) (err error) {
+ switch len(text) {
+ case 32:
+ return u.decodeHashLike(text)
+ case 36:
+ return u.decodeCanonical(text)
+ case 38:
+ return u.decodeBraced(text)
+ case 41:
+ fallthrough
+ case 45:
+ return u.decodeURN(text)
+ default:
+ return fmt.Errorf("uuid: incorrect UUID length: %s", text)
+ }
+}
+
+// decodeCanonical decodes UUID string in format
+// "6ba7b810-9dad-11d1-80b4-00c04fd430c8".
+func (u *UUID) decodeCanonical(t []byte) (err error) {
+ if t[8] != '-' || t[13] != '-' || t[18] != '-' || t[23] != '-' {
+ return fmt.Errorf("uuid: incorrect UUID format %s", t)
+ }
+
+ src := t[:]
+ dst := u[:]
+
+ for i, byteGroup := range byteGroups {
+ if i > 0 {
+ src = src[1:] // skip dash
+ }
+ _, err = hex.Decode(dst[:byteGroup/2], src[:byteGroup])
+ if err != nil {
+ return
+ }
+ src = src[byteGroup:]
+ dst = dst[byteGroup/2:]
+ }
+
+ return
+}
+
+// decodeHashLike decodes UUID string in format
+// "6ba7b8109dad11d180b400c04fd430c8".
+func (u *UUID) decodeHashLike(t []byte) (err error) {
+ src := t[:]
+ dst := u[:]
+
+ if _, err = hex.Decode(dst, src); err != nil {
+ return err
+ }
+ return
+}
+
+// decodeBraced decodes UUID string in format
+// "{6ba7b810-9dad-11d1-80b4-00c04fd430c8}" or in format
+// "{6ba7b8109dad11d180b400c04fd430c8}".
+func (u *UUID) decodeBraced(t []byte) (err error) {
+ l := len(t)
+
+ if t[0] != '{' || t[l-1] != '}' {
+ return fmt.Errorf("uuid: incorrect UUID format %s", t)
+ }
+
+ return u.decodePlain(t[1 : l-1])
+}
+
+// decodeURN decodes UUID string in format
+// "urn:uuid:6ba7b810-9dad-11d1-80b4-00c04fd430c8" or in format
+// "urn:uuid:6ba7b8109dad11d180b400c04fd430c8".
+func (u *UUID) decodeURN(t []byte) (err error) {
+ total := len(t)
+
+ urn_uuid_prefix := t[:9]
+
+ if !bytes.Equal(urn_uuid_prefix, urnPrefix) {
+ return fmt.Errorf("uuid: incorrect UUID format: %s", t)
+ }
+
+ return u.decodePlain(t[9:total])
+}
+
+// decodePlain decodes UUID string in canonical format
+// "6ba7b810-9dad-11d1-80b4-00c04fd430c8" or in hash-like format
+// "6ba7b8109dad11d180b400c04fd430c8".
+func (u *UUID) decodePlain(t []byte) (err error) {
+ switch len(t) {
+ case 32:
+ return u.decodeHashLike(t)
+ case 36:
+ return u.decodeCanonical(t)
+ default:
+ return fmt.Errorf("uuid: incorrrect UUID length: %s", t)
+ }
+}
+
+// MarshalBinary implements the encoding.BinaryMarshaler interface.
+func (u UUID) MarshalBinary() (data []byte, err error) {
+ data = u.Bytes()
+ return
+}
+
+// UnmarshalBinary implements the encoding.BinaryUnmarshaler interface.
+// It will return error if the slice isn't 16 bytes long.
+func (u *UUID) UnmarshalBinary(data []byte) (err error) {
+ if len(data) != Size {
+ err = fmt.Errorf("uuid: UUID must be exactly 16 bytes long, got %d bytes", len(data))
+ return
+ }
+ copy(u[:], data)
+
+ return
+}
diff --git a/vendor/src/github.com/satori/go.uuid/codec_test.go b/vendor/src/github.com/satori/go.uuid/codec_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..7158c095a336175941ba51b7749b1db72e00ee9d
--- /dev/null
+++ b/vendor/src/github.com/satori/go.uuid/codec_test.go
@@ -0,0 +1,251 @@
+// Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+package uuid
+
+import (
+ "bytes"
+
+ . "gopkg.in/check.v1"
+)
+
+type codecTestSuite struct{}
+
+var _ = Suite(&codecTestSuite{})
+
+func (s *codecTestSuite) TestFromBytes(c *C) {
+ u := UUID{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
+ b1 := []byte{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
+
+ u1, err := FromBytes(b1)
+ c.Assert(err, IsNil)
+ c.Assert(u1, Equals, u)
+
+ b2 := []byte{}
+ _, err = FromBytes(b2)
+ c.Assert(err, NotNil)
+}
+
+func (s *codecTestSuite) BenchmarkFromBytes(c *C) {
+ bytes := []byte{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
+ for i := 0; i < c.N; i++ {
+ FromBytes(bytes)
+ }
+}
+
+func (s *codecTestSuite) TestMarshalBinary(c *C) {
+ u := UUID{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
+ b1 := []byte{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
+
+ b2, err := u.MarshalBinary()
+ c.Assert(err, IsNil)
+ c.Assert(bytes.Equal(b1, b2), Equals, true)
+}
+
+func (s *codecTestSuite) BenchmarkMarshalBinary(c *C) {
+ u, err := NewV4()
+ c.Assert(err, IsNil)
+ for i := 0; i < c.N; i++ {
+ u.MarshalBinary()
+ }
+}
+
+func (s *codecTestSuite) TestUnmarshalBinary(c *C) {
+ u := UUID{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
+ b1 := []byte{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
+
+ u1 := UUID{}
+ err := u1.UnmarshalBinary(b1)
+ c.Assert(err, IsNil)
+ c.Assert(u1, Equals, u)
+
+ b2 := []byte{}
+ u2 := UUID{}
+ err = u2.UnmarshalBinary(b2)
+ c.Assert(err, NotNil)
+}
+
+func (s *codecTestSuite) TestFromString(c *C) {
+ u := UUID{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
+
+ s1 := "6ba7b810-9dad-11d1-80b4-00c04fd430c8"
+ s2 := "{6ba7b810-9dad-11d1-80b4-00c04fd430c8}"
+ s3 := "urn:uuid:6ba7b810-9dad-11d1-80b4-00c04fd430c8"
+ s4 := "6ba7b8109dad11d180b400c04fd430c8"
+ s5 := "urn:uuid:6ba7b8109dad11d180b400c04fd430c8"
+
+ _, err := FromString("")
+ c.Assert(err, NotNil)
+
+ u1, err := FromString(s1)
+ c.Assert(err, IsNil)
+ c.Assert(u1, Equals, u)
+
+ u2, err := FromString(s2)
+ c.Assert(err, IsNil)
+ c.Assert(u2, Equals, u)
+
+ u3, err := FromString(s3)
+ c.Assert(err, IsNil)
+ c.Assert(u3, Equals, u)
+
+ u4, err := FromString(s4)
+ c.Assert(err, IsNil)
+ c.Assert(u4, Equals, u)
+
+ u5, err := FromString(s5)
+ c.Assert(err, IsNil)
+ c.Assert(u5, Equals, u)
+}
+
+func (s *codecTestSuite) BenchmarkFromString(c *C) {
+ str := "6ba7b810-9dad-11d1-80b4-00c04fd430c8"
+ for i := 0; i < c.N; i++ {
+ FromString(str)
+ }
+}
+
+func (s *codecTestSuite) BenchmarkFromStringUrn(c *C) {
+ str := "urn:uuid:6ba7b810-9dad-11d1-80b4-00c04fd430c8"
+ for i := 0; i < c.N; i++ {
+ FromString(str)
+ }
+}
+
+func (s *codecTestSuite) BenchmarkFromStringWithBrackets(c *C) {
+ str := "{6ba7b810-9dad-11d1-80b4-00c04fd430c8}"
+ for i := 0; i < c.N; i++ {
+ FromString(str)
+ }
+}
+
+func (s *codecTestSuite) TestFromStringShort(c *C) {
+ // Invalid 35-character UUID string
+ s1 := "6ba7b810-9dad-11d1-80b4-00c04fd430c"
+
+ for i := len(s1); i >= 0; i-- {
+ _, err := FromString(s1[:i])
+ c.Assert(err, NotNil)
+ }
+}
+
+func (s *codecTestSuite) TestFromStringLong(c *C) {
+ // Invalid 37+ character UUID string
+ strings := []string{
+ "6ba7b810-9dad-11d1-80b4-00c04fd430c8=",
+ "6ba7b810-9dad-11d1-80b4-00c04fd430c8}",
+ "{6ba7b810-9dad-11d1-80b4-00c04fd430c8}f",
+ "6ba7b810-9dad-11d1-80b4-00c04fd430c800c04fd430c8",
+ }
+
+ for _, str := range strings {
+ _, err := FromString(str)
+ c.Assert(err, NotNil)
+ }
+}
+
+func (s *codecTestSuite) TestFromStringInvalid(c *C) {
+ // Invalid UUID string formats
+ strings := []string{
+ "6ba7b8109dad11d180b400c04fd430c86ba7b8109dad11d180b400c04fd430c8",
+ "urn:uuid:{6ba7b810-9dad-11d1-80b4-00c04fd430c8}",
+ "uuid:urn:6ba7b810-9dad-11d1-80b4-00c04fd430c8",
+ "uuid:urn:6ba7b8109dad11d180b400c04fd430c8",
+ "6ba7b8109-dad-11d1-80b4-00c04fd430c8",
+ "6ba7b810-9dad1-1d1-80b4-00c04fd430c8",
+ "6ba7b810-9dad-11d18-0b4-00c04fd430c8",
+ "6ba7b810-9dad-11d1-80b40-0c04fd430c8",
+ "6ba7b810+9dad+11d1+80b4+00c04fd430c8",
+ "(6ba7b810-9dad-11d1-80b4-00c04fd430c8}",
+ "{6ba7b810-9dad-11d1-80b4-00c04fd430c8>",
+ "zba7b810-9dad-11d1-80b4-00c04fd430c8",
+ "6ba7b810-9dad11d180b400c04fd430c8",
+ "6ba7b8109dad-11d180b400c04fd430c8",
+ "6ba7b8109dad11d1-80b400c04fd430c8",
+ "6ba7b8109dad11d180b4-00c04fd430c8",
+ }
+
+ for _, str := range strings {
+ _, err := FromString(str)
+ c.Assert(err, NotNil)
+ }
+}
+
+func (s *codecTestSuite) TestFromStringOrNil(c *C) {
+ u := FromStringOrNil("")
+ c.Assert(u, Equals, Nil)
+}
+
+func (s *codecTestSuite) TestFromBytesOrNil(c *C) {
+ b := []byte{}
+ u := FromBytesOrNil(b)
+ c.Assert(u, Equals, Nil)
+}
+
+func (s *codecTestSuite) TestMarshalText(c *C) {
+ u := UUID{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
+ b1 := []byte("6ba7b810-9dad-11d1-80b4-00c04fd430c8")
+
+ b2, err := u.MarshalText()
+ c.Assert(err, IsNil)
+ c.Assert(bytes.Equal(b1, b2), Equals, true)
+}
+
+func (s *codecTestSuite) BenchmarkMarshalText(c *C) {
+ u, err := NewV4()
+ c.Assert(err, IsNil)
+ for i := 0; i < c.N; i++ {
+ u.MarshalText()
+ }
+}
+
+func (s *codecTestSuite) TestUnmarshalText(c *C) {
+ u := UUID{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
+ b1 := []byte("6ba7b810-9dad-11d1-80b4-00c04fd430c8")
+
+ u1 := UUID{}
+ err := u1.UnmarshalText(b1)
+ c.Assert(err, IsNil)
+ c.Assert(u1, Equals, u)
+
+ b2 := []byte("")
+ u2 := UUID{}
+ err = u2.UnmarshalText(b2)
+ c.Assert(err, NotNil)
+}
+
+func (s *codecTestSuite) BenchmarkUnmarshalText(c *C) {
+ bytes := []byte("6ba7b810-9dad-11d1-80b4-00c04fd430c8")
+ u := UUID{}
+ for i := 0; i < c.N; i++ {
+ u.UnmarshalText(bytes)
+ }
+}
+
+var sink string
+
+func (s *codecTestSuite) BenchmarkMarshalToString(c *C) {
+ u, err := NewV4()
+ c.Assert(err, IsNil)
+ for i := 0; i < c.N; i++ {
+ sink = u.String()
+ }
+}
diff --git a/vendor/src/github.com/satori/go.uuid/generator.go b/vendor/src/github.com/satori/go.uuid/generator.go
new file mode 100644
index 0000000000000000000000000000000000000000..499dc35fb729dcb7e5453f56aaf3ad8a9ee2803d
--- /dev/null
+++ b/vendor/src/github.com/satori/go.uuid/generator.go
@@ -0,0 +1,265 @@
+// Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+package uuid
+
+import (
+ "crypto/md5"
+ "crypto/rand"
+ "crypto/sha1"
+ "encoding/binary"
+ "fmt"
+ "hash"
+ "io"
+ "net"
+ "os"
+ "sync"
+ "time"
+)
+
+// Difference in 100-nanosecond intervals between
+// UUID epoch (October 15, 1582) and Unix epoch (January 1, 1970).
+const epochStart = 122192928000000000
+
+type epochFunc func() time.Time
+type hwAddrFunc func() (net.HardwareAddr, error)
+
+var (
+ global = newRFC4122Generator()
+
+ posixUID = uint32(os.Getuid())
+ posixGID = uint32(os.Getgid())
+)
+
+// NewV1 returns UUID based on current timestamp and MAC address.
+func NewV1() (UUID, error) {
+ return global.NewV1()
+}
+
+// NewV2 returns DCE Security UUID based on POSIX UID/GID.
+func NewV2(domain byte) (UUID, error) {
+ return global.NewV2(domain)
+}
+
+// NewV3 returns UUID based on MD5 hash of namespace UUID and name.
+func NewV3(ns UUID, name string) UUID {
+ return global.NewV3(ns, name)
+}
+
+// NewV4 returns random generated UUID.
+func NewV4() (UUID, error) {
+ return global.NewV4()
+}
+
+// NewV5 returns UUID based on SHA-1 hash of namespace UUID and name.
+func NewV5(ns UUID, name string) UUID {
+ return global.NewV5(ns, name)
+}
+
+// Generator provides interface for generating UUIDs.
+type Generator interface {
+ NewV1() (UUID, error)
+ NewV2(domain byte) (UUID, error)
+ NewV3(ns UUID, name string) UUID
+ NewV4() (UUID, error)
+ NewV5(ns UUID, name string) UUID
+}
+
+// Default generator implementation.
+type rfc4122Generator struct {
+ clockSequenceOnce sync.Once
+ hardwareAddrOnce sync.Once
+ storageMutex sync.Mutex
+
+ rand io.Reader
+
+ epochFunc epochFunc
+ hwAddrFunc hwAddrFunc
+ lastTime uint64
+ clockSequence uint16
+ hardwareAddr [6]byte
+}
+
+func newRFC4122Generator() Generator {
+ return &rfc4122Generator{
+ epochFunc: time.Now,
+ hwAddrFunc: defaultHWAddrFunc,
+ rand: rand.Reader,
+ }
+}
+
+// NewV1 returns UUID based on current timestamp and MAC address.
+func (g *rfc4122Generator) NewV1() (UUID, error) {
+ u := UUID{}
+
+ timeNow, clockSeq, err := g.getClockSequence()
+ if err != nil {
+ return Nil, err
+ }
+ binary.BigEndian.PutUint32(u[0:], uint32(timeNow))
+ binary.BigEndian.PutUint16(u[4:], uint16(timeNow>>32))
+ binary.BigEndian.PutUint16(u[6:], uint16(timeNow>>48))
+ binary.BigEndian.PutUint16(u[8:], clockSeq)
+
+ hardwareAddr, err := g.getHardwareAddr()
+ if err != nil {
+ return Nil, err
+ }
+ copy(u[10:], hardwareAddr)
+
+ u.SetVersion(V1)
+ u.SetVariant(VariantRFC4122)
+
+ return u, nil
+}
+
+// NewV2 returns DCE Security UUID based on POSIX UID/GID.
+func (g *rfc4122Generator) NewV2(domain byte) (UUID, error) {
+ u, err := g.NewV1()
+ if err != nil {
+ return Nil, err
+ }
+
+ switch domain {
+ case DomainPerson:
+ binary.BigEndian.PutUint32(u[:], posixUID)
+ case DomainGroup:
+ binary.BigEndian.PutUint32(u[:], posixGID)
+ }
+
+ u[9] = domain
+
+ u.SetVersion(V2)
+ u.SetVariant(VariantRFC4122)
+
+ return u, nil
+}
+
+// NewV3 returns UUID based on MD5 hash of namespace UUID and name.
+func (g *rfc4122Generator) NewV3(ns UUID, name string) UUID {
+ u := newFromHash(md5.New(), ns, name)
+ u.SetVersion(V3)
+ u.SetVariant(VariantRFC4122)
+
+ return u
+}
+
+// NewV4 returns random generated UUID.
+func (g *rfc4122Generator) NewV4() (UUID, error) {
+ u := UUID{}
+ if _, err := g.rand.Read(u[:]); err != nil {
+ return Nil, err
+ }
+ u.SetVersion(V4)
+ u.SetVariant(VariantRFC4122)
+
+ return u, nil
+}
+
+// NewV5 returns UUID based on SHA-1 hash of namespace UUID and name.
+func (g *rfc4122Generator) NewV5(ns UUID, name string) UUID {
+ u := newFromHash(sha1.New(), ns, name)
+ u.SetVersion(V5)
+ u.SetVariant(VariantRFC4122)
+
+ return u
+}
+
+// Returns epoch and clock sequence.
+func (g *rfc4122Generator) getClockSequence() (uint64, uint16, error) {
+ var err error
+ g.clockSequenceOnce.Do(func() {
+ buf := make([]byte, 2)
+ if _, err = g.rand.Read(buf); err != nil {
+ return
+ }
+ g.clockSequence = binary.BigEndian.Uint16(buf)
+ })
+ if err != nil {
+ return 0, 0, err
+ }
+
+ g.storageMutex.Lock()
+ defer g.storageMutex.Unlock()
+
+ timeNow := g.getEpoch()
+ // Clock didn't change since last UUID generation.
+ // Should increase clock sequence.
+ if timeNow <= g.lastTime {
+ g.clockSequence++
+ }
+ g.lastTime = timeNow
+
+ return timeNow, g.clockSequence, nil
+}
+
+// Returns hardware address.
+func (g *rfc4122Generator) getHardwareAddr() ([]byte, error) {
+ var err error
+ g.hardwareAddrOnce.Do(func() {
+ if hwAddr, err := g.hwAddrFunc(); err == nil {
+ copy(g.hardwareAddr[:], hwAddr)
+ return
+ }
+
+ // Initialize hardwareAddr randomly in case
+ // of real network interfaces absence.
+ if _, err = g.rand.Read(g.hardwareAddr[:]); err != nil {
+ return
+ }
+ // Set multicast bit as recommended by RFC 4122
+ g.hardwareAddr[0] |= 0x01
+ })
+ if err != nil {
+ return []byte{}, err
+ }
+ return g.hardwareAddr[:], nil
+}
+
+// Returns difference in 100-nanosecond intervals between
+// UUID epoch (October 15, 1582) and current time.
+func (g *rfc4122Generator) getEpoch() uint64 {
+ return epochStart + uint64(g.epochFunc().UnixNano()/100)
+}
+
+// Returns UUID based on hashing of namespace UUID and name.
+func newFromHash(h hash.Hash, ns UUID, name string) UUID {
+ u := UUID{}
+ h.Write(ns[:])
+ h.Write([]byte(name))
+ copy(u[:], h.Sum(nil))
+
+ return u
+}
+
+// Returns hardware address.
+func defaultHWAddrFunc() (net.HardwareAddr, error) {
+ ifaces, err := net.Interfaces()
+ if err != nil {
+ return []byte{}, err
+ }
+ for _, iface := range ifaces {
+ if len(iface.HardwareAddr) >= 6 {
+ return iface.HardwareAddr, nil
+ }
+ }
+ return []byte{}, fmt.Errorf("uuid: no HW address found")
+}
diff --git a/vendor/src/github.com/satori/go.uuid/generator_test.go b/vendor/src/github.com/satori/go.uuid/generator_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..82a236a37dd95dacdb4c8b42aaff2ced2b0c6d46
--- /dev/null
+++ b/vendor/src/github.com/satori/go.uuid/generator_test.go
@@ -0,0 +1,224 @@
+// Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+package uuid
+
+import (
+ "crypto/rand"
+ "fmt"
+ "net"
+ "time"
+
+ . "gopkg.in/check.v1"
+)
+
+type faultyReader struct {
+ callsNum int
+ readToFail int // Read call number to fail
+}
+
+func (r *faultyReader) Read(dest []byte) (int, error) {
+ r.callsNum++
+ if (r.callsNum - 1) == r.readToFail {
+ return 0, fmt.Errorf("io: reader is faulty")
+ }
+ return rand.Read(dest)
+}
+
+type genTestSuite struct{}
+
+var _ = Suite(&genTestSuite{})
+
+func (s *genTestSuite) TestNewV1(c *C) {
+ u1, err := NewV1()
+ c.Assert(err, IsNil)
+ c.Assert(u1.Version(), Equals, V1)
+ c.Assert(u1.Variant(), Equals, VariantRFC4122)
+
+ u2, err := NewV1()
+ c.Assert(err, IsNil)
+ c.Assert(u1, Not(Equals), u2)
+}
+
+func (s *genTestSuite) TestNewV1EpochStale(c *C) {
+ g := &rfc4122Generator{
+ epochFunc: func() time.Time {
+ return time.Unix(0, 0)
+ },
+ hwAddrFunc: defaultHWAddrFunc,
+ rand: rand.Reader,
+ }
+ u1, err := g.NewV1()
+ c.Assert(err, IsNil)
+ u2, err := g.NewV1()
+ c.Assert(err, IsNil)
+ c.Assert(u1, Not(Equals), u2)
+}
+
+func (s *genTestSuite) TestNewV1FaultyRand(c *C) {
+ g := &rfc4122Generator{
+ epochFunc: time.Now,
+ hwAddrFunc: defaultHWAddrFunc,
+ rand: &faultyReader{},
+ }
+ u1, err := g.NewV1()
+ c.Assert(err, NotNil)
+ c.Assert(u1, Equals, Nil)
+}
+
+func (s *genTestSuite) TestNewV1MissingNetworkInterfaces(c *C) {
+ g := &rfc4122Generator{
+ epochFunc: time.Now,
+ hwAddrFunc: func() (net.HardwareAddr, error) {
+ return []byte{}, fmt.Errorf("uuid: no hw address found")
+ },
+ rand: rand.Reader,
+ }
+ _, err := g.NewV1()
+ c.Assert(err, IsNil)
+}
+
+func (s *genTestSuite) TestNewV1MissingNetInterfacesAndFaultyRand(c *C) {
+ g := &rfc4122Generator{
+ epochFunc: time.Now,
+ hwAddrFunc: func() (net.HardwareAddr, error) {
+ return []byte{}, fmt.Errorf("uuid: no hw address found")
+ },
+ rand: &faultyReader{
+ readToFail: 1,
+ },
+ }
+ u1, err := g.NewV1()
+ c.Assert(err, NotNil)
+ c.Assert(u1, Equals, Nil)
+}
+
+func (s *genTestSuite) BenchmarkNewV1(c *C) {
+ for i := 0; i < c.N; i++ {
+ NewV1()
+ }
+}
+
+func (s *genTestSuite) TestNewV2(c *C) {
+ u1, err := NewV2(DomainPerson)
+ c.Assert(err, IsNil)
+ c.Assert(u1.Version(), Equals, V2)
+ c.Assert(u1.Variant(), Equals, VariantRFC4122)
+
+ u2, err := NewV2(DomainGroup)
+ c.Assert(err, IsNil)
+ c.Assert(u2.Version(), Equals, V2)
+ c.Assert(u2.Variant(), Equals, VariantRFC4122)
+
+ u3, err := NewV2(DomainOrg)
+ c.Assert(err, IsNil)
+ c.Assert(u3.Version(), Equals, V2)
+ c.Assert(u3.Variant(), Equals, VariantRFC4122)
+}
+
+func (s *genTestSuite) TestNewV2FaultyRand(c *C) {
+ g := &rfc4122Generator{
+ epochFunc: time.Now,
+ hwAddrFunc: defaultHWAddrFunc,
+ rand: &faultyReader{},
+ }
+ u1, err := g.NewV2(DomainPerson)
+ c.Assert(err, NotNil)
+ c.Assert(u1, Equals, Nil)
+}
+
+func (s *genTestSuite) BenchmarkNewV2(c *C) {
+ for i := 0; i < c.N; i++ {
+ NewV2(DomainPerson)
+ }
+}
+
+func (s *genTestSuite) TestNewV3(c *C) {
+ u1 := NewV3(NamespaceDNS, "www.example.com")
+ c.Assert(u1.Version(), Equals, V3)
+ c.Assert(u1.Variant(), Equals, VariantRFC4122)
+ c.Assert(u1.String(), Equals, "5df41881-3aed-3515-88a7-2f4a814cf09e")
+
+ u2 := NewV3(NamespaceDNS, "example.com")
+ c.Assert(u2, Not(Equals), u1)
+
+ u3 := NewV3(NamespaceDNS, "example.com")
+ c.Assert(u3, Equals, u2)
+
+ u4 := NewV3(NamespaceURL, "example.com")
+ c.Assert(u4, Not(Equals), u3)
+}
+
+func (s *genTestSuite) BenchmarkNewV3(c *C) {
+ for i := 0; i < c.N; i++ {
+ NewV3(NamespaceDNS, "www.example.com")
+ }
+}
+
+func (s *genTestSuite) TestNewV4(c *C) {
+ u1, err := NewV4()
+ c.Assert(err, IsNil)
+ c.Assert(u1.Version(), Equals, V4)
+ c.Assert(u1.Variant(), Equals, VariantRFC4122)
+
+ u2, err := NewV4()
+ c.Assert(err, IsNil)
+ c.Assert(u1, Not(Equals), u2)
+}
+
+func (s *genTestSuite) TestNewV4FaultyRand(c *C) {
+ g := &rfc4122Generator{
+ epochFunc: time.Now,
+ hwAddrFunc: defaultHWAddrFunc,
+ rand: &faultyReader{},
+ }
+ u1, err := g.NewV4()
+ c.Assert(err, NotNil)
+ c.Assert(u1, Equals, Nil)
+}
+
+func (s *genTestSuite) BenchmarkNewV4(c *C) {
+ for i := 0; i < c.N; i++ {
+ NewV4()
+ }
+}
+
+func (s *genTestSuite) TestNewV5(c *C) {
+ u1 := NewV5(NamespaceDNS, "www.example.com")
+ c.Assert(u1.Version(), Equals, V5)
+ c.Assert(u1.Variant(), Equals, VariantRFC4122)
+ c.Assert(u1.String(), Equals, "2ed6657d-e927-568b-95e1-2665a8aea6a2")
+
+ u2 := NewV5(NamespaceDNS, "example.com")
+ c.Assert(u2, Not(Equals), u1)
+
+ u3 := NewV5(NamespaceDNS, "example.com")
+ c.Assert(u3, Equals, u2)
+
+ u4 := NewV5(NamespaceURL, "example.com")
+ c.Assert(u4, Not(Equals), u3)
+}
+
+func (s *genTestSuite) BenchmarkNewV5(c *C) {
+ for i := 0; i < c.N; i++ {
+ NewV5(NamespaceDNS, "www.example.com")
+ }
+}
diff --git a/vendor/src/github.com/satori/go.uuid/sql.go b/vendor/src/github.com/satori/go.uuid/sql.go
new file mode 100644
index 0000000000000000000000000000000000000000..56759d3905099b72cf57e47c71994f37ee810066
--- /dev/null
+++ b/vendor/src/github.com/satori/go.uuid/sql.go
@@ -0,0 +1,78 @@
+// Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+package uuid
+
+import (
+ "database/sql/driver"
+ "fmt"
+)
+
+// Value implements the driver.Valuer interface.
+func (u UUID) Value() (driver.Value, error) {
+ return u.String(), nil
+}
+
+// Scan implements the sql.Scanner interface.
+// A 16-byte slice is handled by UnmarshalBinary, while
+// a longer byte slice or a string is handled by UnmarshalText.
+func (u *UUID) Scan(src interface{}) error {
+ switch src := src.(type) {
+ case []byte:
+ if len(src) == Size {
+ return u.UnmarshalBinary(src)
+ }
+ return u.UnmarshalText(src)
+
+ case string:
+ return u.UnmarshalText([]byte(src))
+ }
+
+ return fmt.Errorf("uuid: cannot convert %T to UUID", src)
+}
+
+// NullUUID can be used with the standard sql package to represent a
+// UUID value that can be NULL in the database
+type NullUUID struct {
+ UUID UUID
+ Valid bool
+}
+
+// Value implements the driver.Valuer interface.
+func (u NullUUID) Value() (driver.Value, error) {
+ if !u.Valid {
+ return nil, nil
+ }
+ // Delegate to UUID Value function
+ return u.UUID.Value()
+}
+
+// Scan implements the sql.Scanner interface.
+func (u *NullUUID) Scan(src interface{}) error {
+ if src == nil {
+ u.UUID, u.Valid = Nil, false
+ return nil
+ }
+
+ // Delegate to UUID Scan function
+ u.Valid = true
+ return u.UUID.Scan(src)
+}
diff --git a/vendor/src/github.com/satori/go.uuid/sql_test.go b/vendor/src/github.com/satori/go.uuid/sql_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..74255f50d97525269e2f13fe5a5b099e7b756744
--- /dev/null
+++ b/vendor/src/github.com/satori/go.uuid/sql_test.go
@@ -0,0 +1,136 @@
+// Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+package uuid
+
+import (
+ . "gopkg.in/check.v1"
+)
+
+type sqlTestSuite struct{}
+
+var _ = Suite(&sqlTestSuite{})
+
+func (s *sqlTestSuite) TestValue(c *C) {
+ u, err := FromString("6ba7b810-9dad-11d1-80b4-00c04fd430c8")
+ c.Assert(err, IsNil)
+
+ val, err := u.Value()
+ c.Assert(err, IsNil)
+ c.Assert(val, Equals, u.String())
+}
+
+func (s *sqlTestSuite) TestValueNil(c *C) {
+ u := UUID{}
+
+ val, err := u.Value()
+ c.Assert(err, IsNil)
+ c.Assert(val, Equals, Nil.String())
+}
+
+func (s *sqlTestSuite) TestNullUUIDValueNil(c *C) {
+ u := NullUUID{}
+
+ val, err := u.Value()
+ c.Assert(err, IsNil)
+ c.Assert(val, IsNil)
+}
+
+func (s *sqlTestSuite) TestScanBinary(c *C) {
+ u := UUID{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
+ b1 := []byte{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
+
+ u1 := UUID{}
+ err := u1.Scan(b1)
+ c.Assert(err, IsNil)
+ c.Assert(u, Equals, u1)
+
+ b2 := []byte{}
+ u2 := UUID{}
+
+ err = u2.Scan(b2)
+ c.Assert(err, NotNil)
+}
+
+func (s *sqlTestSuite) TestScanString(c *C) {
+ u := UUID{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
+ s1 := "6ba7b810-9dad-11d1-80b4-00c04fd430c8"
+
+ u1 := UUID{}
+ err := u1.Scan(s1)
+ c.Assert(err, IsNil)
+ c.Assert(u, Equals, u1)
+
+ s2 := ""
+ u2 := UUID{}
+
+ err = u2.Scan(s2)
+ c.Assert(err, NotNil)
+}
+
+func (s *sqlTestSuite) TestScanText(c *C) {
+ u := UUID{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
+ b1 := []byte("6ba7b810-9dad-11d1-80b4-00c04fd430c8")
+
+ u1 := UUID{}
+ err := u1.Scan(b1)
+ c.Assert(err, IsNil)
+ c.Assert(u, Equals, u1)
+
+ b2 := []byte("")
+ u2 := UUID{}
+ err = u2.Scan(b2)
+ c.Assert(err, NotNil)
+}
+
+func (s *sqlTestSuite) TestScanUnsupported(c *C) {
+ u := UUID{}
+
+ err := u.Scan(true)
+ c.Assert(err, NotNil)
+}
+
+func (s *sqlTestSuite) TestScanNil(c *C) {
+ u := UUID{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
+
+ err := u.Scan(nil)
+ c.Assert(err, NotNil)
+}
+
+func (s *sqlTestSuite) TestNullUUIDScanValid(c *C) {
+ u := UUID{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
+ s1 := "6ba7b810-9dad-11d1-80b4-00c04fd430c8"
+
+ u1 := NullUUID{}
+ err := u1.Scan(s1)
+ c.Assert(err, IsNil)
+ c.Assert(u1.Valid, Equals, true)
+ c.Assert(u1.UUID, Equals, u)
+}
+
+func (s *sqlTestSuite) TestNullUUIDScanNil(c *C) {
+ u := NullUUID{UUID{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}, true}
+
+ err := u.Scan(nil)
+ c.Assert(err, IsNil)
+ c.Assert(u.Valid, Equals, false)
+ c.Assert(u.UUID, Equals, Nil)
+}
diff --git a/vendor/src/github.com/satori/go.uuid/uuid.go b/vendor/src/github.com/satori/go.uuid/uuid.go
new file mode 100644
index 0000000000000000000000000000000000000000..a2b8e2ca2a1e0a5ccbd14b077e04390a93ac9a14
--- /dev/null
+++ b/vendor/src/github.com/satori/go.uuid/uuid.go
@@ -0,0 +1,161 @@
+// Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+// Package uuid provides implementation of Universally Unique Identifier (UUID).
+// Supported versions are 1, 3, 4 and 5 (as specified in RFC 4122) and
+// version 2 (as specified in DCE 1.1).
+package uuid
+
+import (
+ "bytes"
+ "encoding/hex"
+)
+
+// Size of a UUID in bytes.
+const Size = 16
+
+// UUID representation compliant with specification
+// described in RFC 4122.
+type UUID [Size]byte
+
+// UUID versions
+const (
+ _ byte = iota
+ V1
+ V2
+ V3
+ V4
+ V5
+)
+
+// UUID layout variants.
+const (
+ VariantNCS byte = iota
+ VariantRFC4122
+ VariantMicrosoft
+ VariantFuture
+)
+
+// UUID DCE domains.
+const (
+ DomainPerson = iota
+ DomainGroup
+ DomainOrg
+)
+
+// String parse helpers.
+var (
+ urnPrefix = []byte("urn:uuid:")
+ byteGroups = []int{8, 4, 4, 4, 12}
+)
+
+// Nil is special form of UUID that is specified to have all
+// 128 bits set to zero.
+var Nil = UUID{}
+
+// Predefined namespace UUIDs.
+var (
+ NamespaceDNS = Must(FromString("6ba7b810-9dad-11d1-80b4-00c04fd430c8"))
+ NamespaceURL = Must(FromString("6ba7b811-9dad-11d1-80b4-00c04fd430c8"))
+ NamespaceOID = Must(FromString("6ba7b812-9dad-11d1-80b4-00c04fd430c8"))
+ NamespaceX500 = Must(FromString("6ba7b814-9dad-11d1-80b4-00c04fd430c8"))
+)
+
+// Equal returns true if u1 and u2 equals, otherwise returns false.
+func Equal(u1 UUID, u2 UUID) bool {
+ return bytes.Equal(u1[:], u2[:])
+}
+
+// Version returns algorithm version used to generate UUID.
+func (u UUID) Version() byte {
+ return u[6] >> 4
+}
+
+// Variant returns UUID layout variant.
+func (u UUID) Variant() byte {
+ switch {
+ case (u[8] >> 7) == 0x00:
+ return VariantNCS
+ case (u[8] >> 6) == 0x02:
+ return VariantRFC4122
+ case (u[8] >> 5) == 0x06:
+ return VariantMicrosoft
+ case (u[8] >> 5) == 0x07:
+ fallthrough
+ default:
+ return VariantFuture
+ }
+}
+
+// Bytes returns bytes slice representation of UUID.
+func (u UUID) Bytes() []byte {
+ return u[:]
+}
+
+// Returns canonical string representation of UUID:
+// xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.
+func (u UUID) String() string {
+ buf := make([]byte, 36)
+
+ hex.Encode(buf[0:8], u[0:4])
+ buf[8] = '-'
+ hex.Encode(buf[9:13], u[4:6])
+ buf[13] = '-'
+ hex.Encode(buf[14:18], u[6:8])
+ buf[18] = '-'
+ hex.Encode(buf[19:23], u[8:10])
+ buf[23] = '-'
+ hex.Encode(buf[24:], u[10:])
+
+ return string(buf)
+}
+
+// SetVersion sets version bits.
+func (u *UUID) SetVersion(v byte) {
+ u[6] = (u[6] & 0x0f) | (v << 4)
+}
+
+// SetVariant sets variant bits.
+func (u *UUID) SetVariant(v byte) {
+ switch v {
+ case VariantNCS:
+ u[8] = (u[8]&(0xff>>1) | (0x00 << 7))
+ case VariantRFC4122:
+ u[8] = (u[8]&(0xff>>2) | (0x02 << 6))
+ case VariantMicrosoft:
+ u[8] = (u[8]&(0xff>>3) | (0x06 << 5))
+ case VariantFuture:
+ fallthrough
+ default:
+ u[8] = (u[8]&(0xff>>3) | (0x07 << 5))
+ }
+}
+
+// Must is a helper that wraps a call to a function returning (UUID, error)
+// and panics if the error is non-nil. It is intended for use in variable
+// initializations such as
+// var packageUUID = uuid.Must(uuid.FromString("123e4567-e89b-12d3-a456-426655440000"));
+func Must(u UUID, err error) UUID {
+ if err != nil {
+ panic(err)
+ }
+ return u
+}
diff --git a/vendor/src/github.com/satori/go.uuid/uuid_test.go b/vendor/src/github.com/satori/go.uuid/uuid_test.go
new file mode 100644
index 0000000000000000000000000000000000000000..fa40280a2ac69393db027683d5a9763107353d75
--- /dev/null
+++ b/vendor/src/github.com/satori/go.uuid/uuid_test.go
@@ -0,0 +1,100 @@
+// Copyright (C) 2013-2018 by Maxim Bublis <b@codemonkey.ru>
+//
+// Permission is hereby granted, free of charge, to any person obtaining
+// a copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to
+// permit persons to whom the Software is furnished to do so, subject to
+// the following conditions:
+//
+// The above copyright notice and this permission notice shall be
+// included in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+package uuid
+
+import (
+ "bytes"
+ "fmt"
+ "testing"
+
+ . "gopkg.in/check.v1"
+)
+
+// Hook up gocheck into the "go test" runner.
+func TestUUID(t *testing.T) { TestingT(t) }
+
+type testSuite struct{}
+
+var _ = Suite(&testSuite{})
+
+func (s *testSuite) TestBytes(c *C) {
+ u := UUID{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
+
+ bytes1 := []byte{0x6b, 0xa7, 0xb8, 0x10, 0x9d, 0xad, 0x11, 0xd1, 0x80, 0xb4, 0x00, 0xc0, 0x4f, 0xd4, 0x30, 0xc8}
+
+ c.Assert(bytes.Equal(u.Bytes(), bytes1), Equals, true)
+}
+
+func (s *testSuite) TestString(c *C) {
+ c.Assert(NamespaceDNS.String(), Equals, "6ba7b810-9dad-11d1-80b4-00c04fd430c8")
+}
+
+func (s *testSuite) TestEqual(c *C) {
+ c.Assert(Equal(NamespaceDNS, NamespaceDNS), Equals, true)
+ c.Assert(Equal(NamespaceDNS, NamespaceURL), Equals, false)
+}
+
+func (s *testSuite) TestVersion(c *C) {
+ u := UUID{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
+ c.Assert(u.Version(), Equals, V1)
+}
+
+func (s *testSuite) TestSetVersion(c *C) {
+ u := UUID{}
+ u.SetVersion(4)
+ c.Assert(u.Version(), Equals, V4)
+}
+
+func (s *testSuite) TestVariant(c *C) {
+ u1 := UUID{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
+ c.Assert(u1.Variant(), Equals, VariantNCS)
+
+ u2 := UUID{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
+ c.Assert(u2.Variant(), Equals, VariantRFC4122)
+
+ u3 := UUID{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
+ c.Assert(u3.Variant(), Equals, VariantMicrosoft)
+
+ u4 := UUID{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xe0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}
+ c.Assert(u4.Variant(), Equals, VariantFuture)
+}
+
+func (s *testSuite) TestSetVariant(c *C) {
+ u := UUID{}
+ u.SetVariant(VariantNCS)
+ c.Assert(u.Variant(), Equals, VariantNCS)
+ u.SetVariant(VariantRFC4122)
+ c.Assert(u.Variant(), Equals, VariantRFC4122)
+ u.SetVariant(VariantMicrosoft)
+ c.Assert(u.Variant(), Equals, VariantMicrosoft)
+ u.SetVariant(VariantFuture)
+ c.Assert(u.Variant(), Equals, VariantFuture)
+}
+
+func (s *testSuite) TestMust(c *C) {
+ defer func() {
+ c.Assert(recover(), NotNil)
+ }()
+ Must(func() (UUID, error) {
+ return Nil, fmt.Errorf("uuid: expected error")
+ }())
+}