@@ -9,7 +9,7 @@ source 'hack/.vendor-helpers.sh'

 clone git github.com/Azure/go-ansiterm 388960b655244e76e24c75f48631564eaefade62

 clone git github.com/Microsoft/hcsshim v0.2.2

 clone git github.com/Microsoft/go-winio v0.3.4

-clone git github.com/Sirupsen/logrus v0.9.0 # logrus is a common dependency among multiple deps

+clone git github.com/Sirupsen/logrus v0.10.0 # logrus is a common dependency among multiple deps

 clone git github.com/docker/libtrust 9cbd2a1374f46905c68a4eb3694a130610adc62a

 clone git github.com/go-check/check 03a4d9dcf2f92eae8e90ed42aa2656f63fdd0b14 https://github.com/cpuguy83/check.git

 clone git github.com/gorilla/context 14f550f51a

@@ -30,11 +30,14 @@ clone git github.com/imdario/mergo 0.2.1

 #get libnetwork packages

 clone git github.com/docker/libnetwork v0.8.0-dev.1

+clone git github.com/docker/go-events 2e7d352816128aa84f4d29b2a21d400133701a0d

+clone git github.com/armon/go-radix e39d623f12e8e41c7b5529e9a9dd67a1e2261f80

 clone git github.com/armon/go-metrics eb0af217e5e9747e41dd5303755356b62d28e3ec

 clone git github.com/hashicorp/go-msgpack 71c2886f5a673a35f909803f38ece5810165097b

-clone git github.com/hashicorp/memberlist 9a1e242e454d2443df330bdd51a436d5a9058fc4

-clone git github.com/hashicorp/serf 7151adcef72687bf95f451a2e0ba15cb19412bf2

-clone git github.com/docker/libkv c2aac5dbbaa5c872211edea7c0f32b3bd67e7410

+clone git github.com/hashicorp/memberlist 88ac4de0d1a0ca6def284b571342db3b777a4c37

+clone git github.com/hashicorp/go-multierror fcdddc395df1ddf4247c69bd436e84cfa0733f7e

+clone git github.com/hashicorp/serf 598c54895cc5a7b1a24a398d635e8c0ea0959870

+clone git github.com/docker/libkv 7283ef27ed32fe267388510a91709b307bb9942c

 clone git github.com/vishvananda/netns 604eaf189ee867d8c147fafc28def2394e878d25

 clone git github.com/vishvananda/netlink 631962935bff4f3d20ff32a72e8944f6d2836a26

 clone git github.com/BurntSushi/toml f706d00e3de6abe700c994cdd545a1a4915af060

@@ -1,3 +1,10 @@

+# 0.10.0

+

+* feature: Add a test hook (#180)

+* feature: `ParseLevel` is now case-insensitive (#326)

+* feature: `FieldLogger` interface that generalizes `Logger` and `Entry` (#308)

+* performance: avoid re-allocations on `WithFields` (#335)

+

 # 0.9.0

 * logrus/text_formatter: don't emit empty msg

@@ -1,4 +1,4 @@

-# Logrus <img src="http://i.imgur.com/hTeVwmJ.png" width="40" height="40" alt=":walrus:" class="emoji" title=":walrus:"/>&nbsp;[![Build Status](https://travis-ci.org/Sirupsen/logrus.svg?branch=master)](https://travis-ci.org/Sirupsen/logrus)&nbsp;[![godoc reference](https://godoc.org/github.com/Sirupsen/logrus?status.png)][godoc]

+# Logrus <img src="http://i.imgur.com/hTeVwmJ.png" width="40" height="40" alt=":walrus:" class="emoji" title=":walrus:"/>&nbsp;[![Build Status](https://travis-ci.org/Sirupsen/logrus.svg?branch=master)](https://travis-ci.org/Sirupsen/logrus)&nbsp;[![GoDoc](https://godoc.org/github.com/Sirupsen/logrus?status.svg)](https://godoc.org/github.com/Sirupsen/logrus)

 Logrus is a structured logger for Go (golang), completely API compatible with

 the standard library logger. [Godoc][godoc]. **Please note the Logrus API is not

@@ -12,7 +12,7 @@ plain text):

 ![Colored](http://i.imgur.com/PY7qMwd.png)

-With `log.Formatter = new(logrus.JSONFormatter)`, for easy parsing by logstash

+With `log.SetFormatter(&log.JSONFormatter{})`, for easy parsing by logstash

 or Splunk:

 ```json

@@ -32,7 +32,7 @@ ocean","size":10,"time":"2014-03-10 19:57:38.562264131 -0400 EDT"}

 "time":"2014-03-10 19:57:38.562543128 -0400 EDT"}

 ```

-With the default `log.Formatter = new(&log.TextFormatter{})` when a TTY is not

+With the default `log.SetFormatter(&log.TextFormatter{})` when a TTY is not

 attached, the output is compatible with the

 [logfmt](http://godoc.org/github.com/kr/logfmt) format:

@@ -222,6 +222,11 @@ Note: Syslog hook also support connecting to local syslog (Ex. "/dev/log" or "/v

 | [Octokit](https://github.com/dorajistyle/logrus-octokit-hook) | Hook for logging to github via octokit |

 | [DeferPanic](https://github.com/deferpanic/dp-logrus) | Hook for logging to DeferPanic |

 | [Redis-Hook](https://github.com/rogierlommers/logrus-redis-hook) | Hook for logging to a ELK stack (through Redis) |

+| [Amqp-Hook](https://github.com/vladoatanasov/logrus_amqp) | Hook for logging to Amqp broker (Like RabbitMQ) |

+| [KafkaLogrus](https://github.com/goibibo/KafkaLogrus) | Hook for logging to kafka |

+| [Typetalk](https://github.com/dragon3/logrus-typetalk-hook) | Hook for logging to [Typetalk](https://www.typetalk.in/) |

+| [ElasticSearch](https://github.com/sohlich/elogrus) | Hook for logging to ElasticSearch|

+

 #### Level logging

@@ -363,4 +368,21 @@ entries. It should not be a feature of the application-level logger.

 | ---- | ----------- |

 |[Logrus Mate](https://github.com/gogap/logrus_mate)|Logrus mate is a tool for Logrus to manage loggers, you can initial logger's level, hook and formatter by config file, the logger will generated with different config at different environment.|

-[godoc]: https://godoc.org/github.com/Sirupsen/logrus

+#### Testing

+

+Logrus has a built in facility for asserting the presence of log messages. This is implemented through the `test` hook and provides:

+

+* decorators for existing logger (`test.NewLocal` and `test.NewGlobal`) which basically just add the `test` hook

+* a test logger (`test.NewNullLogger`) that just records log messages (and does not output any):

+

+```go

+logger, hook := NewNullLogger()

+logger.Error("Hello error")

+

+assert.Equal(1, len(hook.Entries))

+assert.Equal(logrus.ErrorLevel, hook.LastEntry().Level)

+assert.Equal("Hello error", hook.LastEntry().Message)

+

+hook.Reset()

+assert.Nil(hook.LastEntry())

+```

@@ -68,7 +68,7 @@ func (entry *Entry) WithField(key string, value interface{}) *Entry {

 // Add a map of fields to the Entry.

 func (entry *Entry) WithFields(fields Fields) *Entry {

-	data := Fields{}

+	data := make(Fields, len(entry.Data)+len(fields))

 	for k, v := range entry.Data {

 		data[k] = v

 	}

@@ -3,6 +3,7 @@ package logrus

 import (

 	"fmt"

 	"log"

+	"strings"

 )

 // Fields type, used to pass to `WithFields`.

@@ -33,7 +34,7 @@ func (level Level) String() string {

 // ParseLevel takes a string level and returns the Logrus log level constant.

 func ParseLevel(lvl string) (Level, error) {

-	switch lvl {

+	switch strings.ToLower(lvl) {

 	case "panic":

 		return PanicLevel, nil

 	case "fatal":

@@ -52,6 +53,16 @@ func ParseLevel(lvl string) (Level, error) {

 	return l, fmt.Errorf("not a valid logrus Level: %q", lvl)

 }

+// A constant exposing all logging levels

+var AllLevels = []Level{

+	PanicLevel,

+	FatalLevel,

+	ErrorLevel,

+	WarnLevel,

+	InfoLevel,

+	DebugLevel,

+}

+

 // These are the different logging levels. You can set the logging level to log

 // on your instance of logger, obtained with `logrus.New()`.

 const (

@@ -96,3 +107,37 @@ type StdLogger interface {

 	Panicf(string, ...interface{})

 	Panicln(...interface{})

 }

+

+// The FieldLogger interface generalizes the Entry and Logger types

+type FieldLogger interface {

+	WithField(key string, value interface{}) *Entry

+	WithFields(fields Fields) *Entry

+	WithError(err error) *Entry

+

+	Debugf(format string, args ...interface{})

+	Infof(format string, args ...interface{})

+	Printf(format string, args ...interface{})

+	Warnf(format string, args ...interface{})

+	Warningf(format string, args ...interface{})

+	Errorf(format string, args ...interface{})

+	Fatalf(format string, args ...interface{})

+	Panicf(format string, args ...interface{})

+

+	Debug(args ...interface{})

+	Info(args ...interface{})

+	Print(args ...interface{})

+	Warn(args ...interface{})

+	Warning(args ...interface{})

+	Error(args ...interface{})

+	Fatal(args ...interface{})

+	Panic(args ...interface{})

+

+	Debugln(args ...interface{})

+	Infoln(args ...interface{})

+	Println(args ...interface{})

+	Warnln(args ...interface{})

+	Warningln(args ...interface{})

+	Errorln(args ...interface{})

+	Fatalln(args ...interface{})

+	Panicln(args ...interface{})

+}

new file mode 100644

@@ -0,0 +1,22 @@

+# Compiled Object files, Static and Dynamic libs (Shared Objects)

+*.o

+*.a

+*.so

+

+# Folders

+_obj

+_test

+

+# Architecture specific extensions/prefixes

+*.[568vq]

+[568vq].out

+

+*.cgo1.go

+*.cgo2.c

+_cgo_defun.c

+_cgo_gotypes.go

+_cgo_export.*

+

+_testmain.go

+

+*.exe

new file mode 100644

@@ -0,0 +1,3 @@

+language: go

+go:

+  - tip

new file mode 100644

@@ -0,0 +1,20 @@

+The MIT License (MIT)

+

+Copyright (c) 2014 Armon Dadgar

+

+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.

new file mode 100644

@@ -0,0 +1,36 @@

+go-radix [![Build Status](https://travis-ci.org/armon/go-radix.png)](https://travis-ci.org/armon/go-radix)

+=========

+

+Provides the `radix` package that implements a [radix tree](http://en.wikipedia.org/wiki/Radix_tree).

+The package only provides a single `Tree` implementation, optimized for sparse nodes.

+

+As a radix tree, it provides the following:

+ * O(k) operations. In many cases, this can be faster than a hash table since

+   the hash function is an O(k) operation, and hash tables have very poor cache locality.

+ * Minimum / Maximum value lookups

+ * Ordered iteration

+

+Documentation

+=============

+

+The full documentation is available on [Godoc](http://godoc.org/github.com/armon/go-radix).

+

+Example

+=======

+

+Below is a simple example of usage

+

+```go

+// Create a tree

+r := radix.New()

+r.Insert("foo", 1)

+r.Insert("bar", 2)

+r.Insert("foobar", 2)

+

+// Find the longest prefix match

+m, _, _ := r.LongestPrefix("foozip")

+if m != "foo" {

+    panic("should be foo")

+}

+```

+

new file mode 100644

@@ -0,0 +1,467 @@

+package radix

+

+import (

+	"sort"

+	"strings"

+)

+

+// WalkFn is used when walking the tree. Takes a

+// key and value, returning if iteration should

+// be terminated.

+type WalkFn func(s string, v interface{}) bool

+

+// leafNode is used to represent a value

+type leafNode struct {

+	key string

+	val interface{}

+}

+

+// edge is used to represent an edge node

+type edge struct {

+	label byte

+	node  *node

+}

+

+type node struct {

+	// leaf is used to store possible leaf

+	leaf *leafNode

+

+	// prefix is the common prefix we ignore

+	prefix string

+

+	// Edges should be stored in-order for iteration.

+	// We avoid a fully materialized slice to save memory,

+	// since in most cases we expect to be sparse

+	edges edges

+}

+

+func (n *node) isLeaf() bool {

+	return n.leaf != nil

+}

+

+func (n *node) addEdge(e edge) {

+	n.edges = append(n.edges, e)

+	n.edges.Sort()

+}

+

+func (n *node) replaceEdge(e edge) {

+	num := len(n.edges)

+	idx := sort.Search(num, func(i int) bool {

+		return n.edges[i].label >= e.label

+	})

+	if idx < num && n.edges[idx].label == e.label {

+		n.edges[idx].node = e.node

+		return

+	}

+	panic("replacing missing edge")

+}

+

+func (n *node) getEdge(label byte) *node {

+	num := len(n.edges)

+	idx := sort.Search(num, func(i int) bool {

+		return n.edges[i].label >= label

+	})

+	if idx < num && n.edges[idx].label == label {

+		return n.edges[idx].node

+	}

+	return nil

+}

+

+type edges []edge

+

+func (e edges) Len() int {

+	return len(e)

+}

+

+func (e edges) Less(i, j int) bool {

+	return e[i].label < e[j].label

+}

+

+func (e edges) Swap(i, j int) {

+	e[i], e[j] = e[j], e[i]

+}

+

+func (e edges) Sort() {

+	sort.Sort(e)

+}

+

+// Tree implements a radix tree. This can be treated as a

+// Dictionary abstract data type. The main advantage over

+// a standard hash map is prefix-based lookups and

+// ordered iteration,

+type Tree struct {

+	root *node

+	size int

+}

+

+// New returns an empty Tree

+func New() *Tree {

+	return NewFromMap(nil)

+}

+

+// NewFromMap returns a new tree containing the keys

+// from an existing map

+func NewFromMap(m map[string]interface{}) *Tree {

+	t := &Tree{root: &node{}}

+	for k, v := range m {

+		t.Insert(k, v)

+	}

+	return t

+}

+

+// Len is used to return the number of elements in the tree

+func (t *Tree) Len() int {

+	return t.size

+}

+

+// longestPrefix finds the length of the shared prefix

+// of two strings

+func longestPrefix(k1, k2 string) int {

+	max := len(k1)

+	if l := len(k2); l < max {

+		max = l

+	}

+	var i int

+	for i = 0; i < max; i++ {

+		if k1[i] != k2[i] {

+			break

+		}

+	}

+	return i

+}

+

+// Insert is used to add a newentry or update

+// an existing entry. Returns if updated.

+func (t *Tree) Insert(s string, v interface{}) (interface{}, bool) {

+	var parent *node

+	n := t.root

+	search := s

+	for {

+		// Handle key exhaution

+		if len(search) == 0 {

+			if n.isLeaf() {

+				old := n.leaf.val

+				n.leaf.val = v

+				return old, true

+			} else {

+				n.leaf = &leafNode{

+					key: s,

+					val: v,

+				}

+				t.size++

+				return nil, false

+			}

+		}

+

+		// Look for the edge

+		parent = n

+		n = n.getEdge(search[0])

+

+		// No edge, create one

+		if n == nil {

+			e := edge{

+				label: search[0],

+				node: &node{

+					leaf: &leafNode{

+						key: s,

+						val: v,

+					},

+					prefix: search,

+				},

+			}

+			parent.addEdge(e)

+			t.size++

+			return nil, false

+		}

+

+		// Determine longest prefix of the search key on match

+		commonPrefix := longestPrefix(search, n.prefix)

+		if commonPrefix == len(n.prefix) {

+			search = search[commonPrefix:]

+			continue

+		}

+

+		// Split the node

+		t.size++

+		child := &node{

+			prefix: search[:commonPrefix],

+		}

+		parent.replaceEdge(edge{

+			label: search[0],

+			node:  child,

+		})

+

+		// Restore the existing node

+		child.addEdge(edge{

+			label: n.prefix[commonPrefix],

+			node:  n,

+		})

+		n.prefix = n.prefix[commonPrefix:]

+

+		// Create a new leaf node

+		leaf := &leafNode{

+			key: s,

+			val: v,

+		}

+

+		// If the new key is a subset, add to to this node

+		search = search[commonPrefix:]

+		if len(search) == 0 {

+			child.leaf = leaf

+			return nil, false

+		}

+

+		// Create a new edge for the node

+		child.addEdge(edge{

+			label: search[0],

+			node: &node{

+				leaf:   leaf,

+				prefix: search,

+			},

+		})

+		return nil, false

+	}

+	return nil, false

+}

+

+// Delete is used to delete a key, returning the previous

+// value and if it was deleted

+func (t *Tree) Delete(s string) (interface{}, bool) {

+	n := t.root

+	search := s

+	for {

+		// Check for key exhaution

+		if len(search) == 0 {

+			if !n.isLeaf() {

+				break

+			}

+			goto DELETE

+		}

+

+		// Look for an edge

+		n = n.getEdge(search[0])

+		if n == nil {

+			break

+		}

+

+		// Consume the search prefix

+		if strings.HasPrefix(search, n.prefix) {

+			search = search[len(n.prefix):]

+		} else {

+			break

+		}

+	}

+	return nil, false

+

+DELETE:

+	// Delete the leaf

+	leaf := n.leaf

+	n.leaf = nil

+	t.size--

+

+	// Check if we should merge this node

+	if len(n.edges) == 1 {

+		e := n.edges[0]

+		child := e.node

+		n.prefix = n.prefix + child.prefix

+		n.leaf = child.leaf

+		n.edges = child.edges

+	}

+	return leaf.val, true

+}

+

+// Get is used to lookup a specific key, returning

+// the value and if it was found

+func (t *Tree) Get(s string) (interface{}, bool) {

+	n := t.root

+	search := s

+	for {

+		// Check for key exhaution

+		if len(search) == 0 {

+			if n.isLeaf() {

+				return n.leaf.val, true

+			}

+			break

+		}

+

+		// Look for an edge

+		n = n.getEdge(search[0])

+		if n == nil {

+			break

+		}

+

+		// Consume the search prefix

+		if strings.HasPrefix(search, n.prefix) {

+			search = search[len(n.prefix):]

+		} else {

+			break

+		}

+	}

+	return nil, false

+}

+

+// LongestPrefix is like Get, but instead of an

+// exact match, it will return the longest prefix match.

+func (t *Tree) LongestPrefix(s string) (string, interface{}, bool) {

+	var last *leafNode

+	n := t.root

+	search := s

+	for {

+		// Look for a leaf node

+		if n.isLeaf() {

+			last = n.leaf

+		}

+

+		// Check for key exhaution

+		if len(search) == 0 {

+			break

+		}

+

+		// Look for an edge

+		n = n.getEdge(search[0])

+		if n == nil {

+			break

+		}

+

+		// Consume the search prefix

+		if strings.HasPrefix(search, n.prefix) {

+			search = search[len(n.prefix):]

+		} else {

+			break

+		}

+	}

+	if last != nil {

+		return last.key, last.val, true

+	}

+	return "", nil, false

+}

+

+// Minimum is used to return the minimum value in the tree

+func (t *Tree) Minimum() (string, interface{}, bool) {

+	n := t.root

+	for {

+		if n.isLeaf() {

+			return n.leaf.key, n.leaf.val, true

+		}

+		if len(n.edges) > 0 {

+			n = n.edges[0].node

+		} else {

+			break

+		}

+	}

+	return "", nil, false

+}

+

+// Maximum is used to return the maximum value in the tree

+func (t *Tree) Maximum() (string, interface{}, bool) {

+	n := t.root

+	for {

+		if num := len(n.edges); num > 0 {

+			n = n.edges[num-1].node

+			continue

+		}

+		if n.isLeaf() {

+			return n.leaf.key, n.leaf.val, true

+		} else {

+			break

+		}

+	}

+	return "", nil, false

+}

+

+// Walk is used to walk the tree

+func (t *Tree) Walk(fn WalkFn) {

+	recursiveWalk(t.root, fn)

+}

+

+// WalkPrefix is used to walk the tree under a prefix

+func (t *Tree) WalkPrefix(prefix string, fn WalkFn) {

+	n := t.root

+	search := prefix

+	for {

+		// Check for key exhaution

+		if len(search) == 0 {

+			recursiveWalk(n, fn)

+			return

+		}

+

+		// Look for an edge

+		n = n.getEdge(search[0])

+		if n == nil {

+			break

+		}

+

+		// Consume the search prefix

+		if strings.HasPrefix(search, n.prefix) {

+			search = search[len(n.prefix):]

+

+		} else if strings.HasPrefix(n.prefix, search) {

+			// Child may be under our search prefix

+			recursiveWalk(n, fn)

+			return

+		} else {

+			break

+		}

+	}

+

+}

+

+// WalkPath is used to walk the tree, but only visiting nodes

+// from the root down to a given leaf. Where WalkPrefix walks

+// all the entries *under* the given prefix, this walks the

+// entries *above* the given prefix.

+func (t *Tree) WalkPath(path string, fn WalkFn) {

+	n := t.root

+	search := path

+	for {

+		// Visit the leaf values if any

+		if n.leaf != nil && fn(n.leaf.key, n.leaf.val) {

+			return

+		}

+

+		// Check for key exhaution

+		if len(search) == 0 {

+			return

+		}

+

+		// Look for an edge

+		n = n.getEdge(search[0])

+		if n == nil {

+			return

+		}

+

+		// Consume the search prefix

+		if strings.HasPrefix(search, n.prefix) {

+			search = search[len(n.prefix):]

+		} else {

+			break

+		}

+	}

+}

+

+// recursiveWalk is used to do a pre-order walk of a node

+// recursively. Returns true if the walk should be aborted

+func recursiveWalk(n *node, fn WalkFn) bool {

+	// Visit the leaf values if any

+	if n.leaf != nil && fn(n.leaf.key, n.leaf.val) {

+		return true

+	}

+

+	// Recurse on the children

+	for _, e := range n.edges {

+		if recursiveWalk(e.node, fn) {

+			return true

+		}

+	}

+	return false

+}

+

+// ToMap is used to walk the tree and convert it into a map

+func (t *Tree) ToMap() map[string]interface{} {

+	out := make(map[string]interface{}, t.size)

+	t.Walk(func(k string, v interface{}) bool {

+		out[k] = v

+		return false

+	})

+	return out

+}

new file mode 100644

@@ -0,0 +1,24 @@

+# Compiled Object files, Static and Dynamic libs (Shared Objects)

+*.o

+*.a

+*.so

+

+# Folders

+_obj

+_test

+

+# Architecture specific extensions/prefixes

+*.[568vq]

+[568vq].out

+

+*.cgo1.go

+*.cgo2.c

+_cgo_defun.c

+_cgo_gotypes.go

+_cgo_export.*

+

+_testmain.go

+

+*.exe

+*.test

+*.prof

new file mode 100644

@@ -0,0 +1,201 @@

+                                 Apache License

+                           Version 2.0, January 2004

+                        http://www.apache.org/licenses/

+

+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION

+

+   1. Definitions.

+

+      "License" shall mean the terms and conditions for use, reproduction,

+      and distribution as defined by Sections 1 through 9 of this document.

+

+      "Licensor" shall mean the copyright owner or entity authorized by

+      the copyright owner that is granting the License.

+

+      "Legal Entity" shall mean the union of the acting entity and all

+      other entities that control, are controlled by, or are under common

+      control with that entity. For the purposes of this definition,

+      "control" means (i) the power, direct or indirect, to cause the

+      direction or management of such entity, whether by contract or

+      otherwise, or (ii) ownership of fifty percent (50%) or more of the

+      outstanding shares, or (iii) beneficial ownership of such entity.

+

+      "You" (or "Your") shall mean an individual or Legal Entity

+      exercising permissions granted by this License.

+

+      "Source" form shall mean the preferred form for making modifications,

+      including but not limited to software source code, documentation

+      source, and configuration files.

+

+      "Object" form shall mean any form resulting from mechanical

+      transformation or translation of a Source form, including but

+      not limited to compiled object code, generated documentation,

+      and conversions to other media types.

+

+      "Work" shall mean the work of authorship, whether in Source or

+      Object form, made available under the License, as indicated by a

+      copyright notice that is included in or attached to the work

+      (an example is provided in the Appendix below).

+

+      "Derivative Works" shall mean any work, whether in Source or Object

+      form, that is based on (or derived from) the Work and for which the

+      editorial revisions, annotations, elaborations, or other modifications

+      represent, as a whole, an original work of authorship. For the purposes

+      of this License, Derivative Works shall not include works that remain

+      separable from, or merely link (or bind by name) to the interfaces of,

+      the Work and Derivative Works thereof.

+

+      "Contribution" shall mean any work of authorship, including

+      the original version of the Work and any modifications or additions

+      to that Work or Derivative Works thereof, that is intentionally

+      submitted to Licensor for inclusion in the Work by the copyright owner

+      or by an individual or Legal Entity authorized to submit on behalf of

+      the copyright owner. For the purposes of this definition, "submitted"

+      means any form of electronic, verbal, or written communication sent

+      to the Licensor or its representatives, including but not limited to

+      communication on electronic mailing lists, source code control systems,

+      and issue tracking systems that are managed by, or on behalf of, the

+      Licensor for the purpose of discussing and improving the Work, but

+      excluding communication that is conspicuously marked or otherwise

+      designated in writing by the copyright owner as "Not a Contribution."

+

+      "Contributor" shall mean Licensor and any individual or Legal Entity

+      on behalf of whom a Contribution has been received by Licensor and

+      subsequently incorporated within the Work.

+

+   2. Grant of Copyright License. Subject to the terms and conditions of

+      this License, each Contributor hereby grants to You a perpetual,

+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable

+      copyright license to reproduce, prepare Derivative Works of,

+      publicly display, publicly perform, sublicense, and distribute the

+      Work and such Derivative Works in Source or Object form.

+

+   3. Grant of Patent License. Subject to the terms and conditions of

+      this License, each Contributor hereby grants to You a perpetual,

+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable

+      (except as stated in this section) patent license to make, have made,

+      use, offer to sell, sell, import, and otherwise transfer the Work,

+      where such license applies only to those patent claims licensable

+      by such Contributor that are necessarily infringed by their

+      Contribution(s) alone or by combination of their Contribution(s)

+      with the Work to which such Contribution(s) was submitted. If You

+      institute patent litigation against any entity (including a

+      cross-claim or counterclaim in a lawsuit) alleging that the Work

+      or a Contribution incorporated within the Work constitutes direct