add vendor

vendor/github.com/StackExchange/wmi/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Stack Exchange
+
+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.

vendor/github.com/StackExchange/wmi/README.md

@@ -0,0 +1,6 @@
+wmi
+===
+
+Package wmi provides a WQL interface to Windows WMI.
+
+Note: It interfaces with WMI on the local machine, therefore it only runs on Windows.

vendor/github.com/StackExchange/wmi/swbemservices.go

@@ -0,0 +1,260 @@
+// +build windows
+
+package wmi
+
+import (
+	"fmt"
+	"reflect"
+	"runtime"
+	"sync"
+
+	"github.com/go-ole/go-ole"
+	"github.com/go-ole/go-ole/oleutil"
+)
+
+// SWbemServices is used to access wmi. See https://msdn.microsoft.com/en-us/library/aa393719(v=vs.85).aspx
+type SWbemServices struct {
+	//TODO: track namespace. Not sure if we can re connect to a different namespace using the same instance
+	cWMIClient            *Client //This could also be an embedded struct, but then we would need to branch on Client vs SWbemServices in the Query method
+	sWbemLocatorIUnknown  *ole.IUnknown
+	sWbemLocatorIDispatch *ole.IDispatch
+	queries               chan *queryRequest
+	closeError            chan error
+	lQueryorClose         sync.Mutex
+}
+
+type queryRequest struct {
+	query    string
+	dst      interface{}
+	args     []interface{}
+	finished chan error
+}
+
+// InitializeSWbemServices will return a new SWbemServices object that can be used to query WMI
+func InitializeSWbemServices(c *Client, connectServerArgs ...interface{}) (*SWbemServices, error) {
+	//fmt.Println("InitializeSWbemServices: Starting")
+	//TODO: implement connectServerArgs as optional argument for init with connectServer call
+	s := new(SWbemServices)
+	s.cWMIClient = c
+	s.queries = make(chan *queryRequest)
+	initError := make(chan error)
+	go s.process(initError)
+
+	err, ok := <-initError
+	if ok {
+		return nil, err //Send error to caller
+	}
+	//fmt.Println("InitializeSWbemServices: Finished")
+	return s, nil
+}
+
+// Close will clear and release all of the SWbemServices resources
+func (s *SWbemServices) Close() error {
+	s.lQueryorClose.Lock()
+	if s == nil || s.sWbemLocatorIDispatch == nil {
+		s.lQueryorClose.Unlock()
+		return fmt.Errorf("SWbemServices is not Initialized")
+	}
+	if s.queries == nil {
+		s.lQueryorClose.Unlock()
+		return fmt.Errorf("SWbemServices has been closed")
+	}
+	//fmt.Println("Close: sending close request")
+	var result error
+	ce := make(chan error)
+	s.closeError = ce //Race condition if multiple callers to close. May need to lock here
+	close(s.queries)  //Tell background to shut things down
+	s.lQueryorClose.Unlock()
+	err, ok := <-ce
+	if ok {
+		result = err
+	}
+	//fmt.Println("Close: finished")
+	return result
+}
+
+func (s *SWbemServices) process(initError chan error) {
+	//fmt.Println("process: starting background thread initialization")
+	//All OLE/WMI calls must happen on the same initialized thead, so lock this goroutine
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	err := ole.CoInitializeEx(0, ole.COINIT_MULTITHREADED)
+	if err != nil {
+		oleCode := err.(*ole.OleError).Code()
+		if oleCode != ole.S_OK && oleCode != S_FALSE {
+			initError <- fmt.Errorf("ole.CoInitializeEx error: %v", err)
+			return
+		}
+	}
+	defer ole.CoUninitialize()
+
+	unknown, err := oleutil.CreateObject("WbemScripting.SWbemLocator")
+	if err != nil {
+		initError <- fmt.Errorf("CreateObject SWbemLocator error: %v", err)
+		return
+	} else if unknown == nil {
+		initError <- ErrNilCreateObject
+		return
+	}
+	defer unknown.Release()
+	s.sWbemLocatorIUnknown = unknown
+
+	dispatch, err := s.sWbemLocatorIUnknown.QueryInterface(ole.IID_IDispatch)
+	if err != nil {
+		initError <- fmt.Errorf("SWbemLocator QueryInterface error: %v", err)
+		return
+	}
+	defer dispatch.Release()
+	s.sWbemLocatorIDispatch = dispatch
+
+	// we can't do the ConnectServer call outside the loop unless we find a way to track and re-init the connectServerArgs
+	//fmt.Println("process: initialized. closing initError")
+	close(initError)
+	//fmt.Println("process: waiting for queries")
+	for q := range s.queries {
+		//fmt.Printf("process: new query: len(query)=%d\n", len(q.query))
+		errQuery := s.queryBackground(q)
+		//fmt.Println("process: s.queryBackground finished")
+		if errQuery != nil {
+			q.finished <- errQuery
+		}
+		close(q.finished)
+	}
+	//fmt.Println("process: queries channel closed")
+	s.queries = nil //set channel to nil so we know it is closed
+	//TODO: I think the Release/Clear calls can panic if things are in a bad state.
+	//TODO: May need to recover from panics and send error to method caller instead.
+	close(s.closeError)
+}
+
+// Query runs the WQL query using a SWbemServices instance and appends the values to dst.
+//
+// dst must have type *[]S or *[]*S, for some struct type S. Fields selected in
+// the query must have the same name in dst. Supported types are all signed and
+// unsigned integers, time.Time, string, bool, or a pointer to one of those.
+// Array types are not supported.
+//
+// By default, the local machine and default namespace are used. These can be
+// changed using connectServerArgs. See
+// http://msdn.microsoft.com/en-us/library/aa393720.aspx for details.
+func (s *SWbemServices) Query(query string, dst interface{}, connectServerArgs ...interface{}) error {
+	s.lQueryorClose.Lock()
+	if s == nil || s.sWbemLocatorIDispatch == nil {
+		s.lQueryorClose.Unlock()
+		return fmt.Errorf("SWbemServices is not Initialized")
+	}
+	if s.queries == nil {
+		s.lQueryorClose.Unlock()
+		return fmt.Errorf("SWbemServices has been closed")
+	}
+
+	//fmt.Println("Query: Sending query request")
+	qr := queryRequest{
+		query:    query,
+		dst:      dst,
+		args:     connectServerArgs,
+		finished: make(chan error),
+	}
+	s.queries <- &qr
+	s.lQueryorClose.Unlock()
+	err, ok := <-qr.finished
+	if ok {
+		//fmt.Println("Query: Finished with error")
+		return err //Send error to caller
+	}
+	//fmt.Println("Query: Finished")
+	return nil
+}
+
+func (s *SWbemServices) queryBackground(q *queryRequest) error {
+	if s == nil || s.sWbemLocatorIDispatch == nil {
+		return fmt.Errorf("SWbemServices is not Initialized")
+	}
+	wmi := s.sWbemLocatorIDispatch //Should just rename in the code, but this will help as we break things apart
+	//fmt.Println("queryBackground: Starting")
+
+	dv := reflect.ValueOf(q.dst)
+	if dv.Kind() != reflect.Ptr || dv.IsNil() {
+		return ErrInvalidEntityType
+	}
+	dv = dv.Elem()
+	mat, elemType := checkMultiArg(dv)
+	if mat == multiArgTypeInvalid {
+		return ErrInvalidEntityType
+	}
+
+	// service is a SWbemServices
+	serviceRaw, err := oleutil.CallMethod(wmi, "ConnectServer", q.args...)
+	if err != nil {
+		return err
+	}
+	service := serviceRaw.ToIDispatch()
+	defer serviceRaw.Clear()
+
+	// result is a SWBemObjectSet
+	resultRaw, err := oleutil.CallMethod(service, "ExecQuery", q.query)
+	if err != nil {
+		return err
+	}
+	result := resultRaw.ToIDispatch()
+	defer resultRaw.Clear()
+
+	count, err := oleInt64(result, "Count")
+	if err != nil {
+		return err
+	}
+
+	enumProperty, err := result.GetProperty("_NewEnum")
+	if err != nil {
+		return err
+	}
+	defer enumProperty.Clear()
+
+	enum, err := enumProperty.ToIUnknown().IEnumVARIANT(ole.IID_IEnumVariant)
+	if err != nil {
+		return err
+	}
+	if enum == nil {
+		return fmt.Errorf("can't get IEnumVARIANT, enum is nil")
+	}
+	defer enum.Release()
+
+	// Initialize a slice with Count capacity
+	dv.Set(reflect.MakeSlice(dv.Type(), 0, int(count)))
+
+	var errFieldMismatch error
+	for itemRaw, length, err := enum.Next(1); length > 0; itemRaw, length, err = enum.Next(1) {
+		if err != nil {
+			return err
+		}
+
+		err := func() error {
+			// item is a SWbemObject, but really a Win32_Process
+			item := itemRaw.ToIDispatch()
+			defer item.Release()
+
+			ev := reflect.New(elemType)
+			if err = s.cWMIClient.loadEntity(ev.Interface(), item); err != nil {
+				if _, ok := err.(*ErrFieldMismatch); ok {
+					// We continue loading entities even in the face of field mismatch errors.
+					// If we encounter any other error, that other error is returned. Otherwise,
+					// an ErrFieldMismatch is returned.
+					errFieldMismatch = err
+				} else {
+					return err
+				}
+			}
+			if mat != multiArgTypeStructPtr {
+				ev = ev.Elem()
+			}
+			dv.Set(reflect.Append(dv, ev))
+			return nil
+		}()
+		if err != nil {
+			return err
+		}
+	}
+	//fmt.Println("queryBackground: Finished")
+	return errFieldMismatch
+}

vendor/github.com/StackExchange/wmi/wmi.go

@@ -0,0 +1,587 @@
+// +build windows
+
+/*
+Package wmi provides a WQL interface for WMI on Windows.
+
+Example code to print names of running processes:
+
+	type Win32_Process struct {
+		Name string
+	}
+
+	func main() {
+		var dst []Win32_Process
+		q := wmi.CreateQuery(&dst, "")
+		err := wmi.Query(q, &dst)
+		if err != nil {
+			log.Fatal(err)
+		}
+		for i, v := range dst {
+			println(i, v.Name)
+		}
+	}
+
+*/
+package wmi
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"log"
+	"os"
+	"reflect"
+	"runtime"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/go-ole/go-ole"
+	"github.com/go-ole/go-ole/oleutil"
+)
+
+var l = log.New(os.Stdout, "", log.LstdFlags)
+
+var (
+	ErrInvalidEntityType = errors.New("wmi: invalid entity type")
+	// ErrNilCreateObject is the error returned if CreateObject returns nil even
+	// if the error was nil.
+	ErrNilCreateObject = errors.New("wmi: create object returned nil")
+	lock               sync.Mutex
+)
+
+// S_FALSE is returned by CoInitializeEx if it was already called on this thread.
+const S_FALSE = 0x00000001
+
+// QueryNamespace invokes Query with the given namespace on the local machine.
+func QueryNamespace(query string, dst interface{}, namespace string) error {
+	return Query(query, dst, nil, namespace)
+}
+
+// Query runs the WQL query and appends the values to dst.
+//
+// dst must have type *[]S or *[]*S, for some struct type S. Fields selected in
+// the query must have the same name in dst. Supported types are all signed and
+// unsigned integers, time.Time, string, bool, or a pointer to one of those.
+// Array types are not supported.
+//
+// By default, the local machine and default namespace are used. These can be
+// changed using connectServerArgs. See
+// https://docs.microsoft.com/en-us/windows/desktop/WmiSdk/swbemlocator-connectserver
+// for details.
+//
+// Query is a wrapper around DefaultClient.Query.
+func Query(query string, dst interface{}, connectServerArgs ...interface{}) error {
+	if DefaultClient.SWbemServicesClient == nil {
+		return DefaultClient.Query(query, dst, connectServerArgs...)
+	}
+	return DefaultClient.SWbemServicesClient.Query(query, dst, connectServerArgs...)
+}
+
+// CallMethod calls a method named methodName on an instance of the class named
+// className, with the given params.
+//
+// CallMethod is a wrapper around DefaultClient.CallMethod.
+func CallMethod(connectServerArgs []interface{}, className, methodName string, params []interface{}) (int32, error) {
+	return DefaultClient.CallMethod(connectServerArgs, className, methodName, params)
+}
+
+// A Client is an WMI query client.
+//
+// Its zero value (DefaultClient) is a usable client.
+type Client struct {
+	// NonePtrZero specifies if nil values for fields which aren't pointers
+	// should be returned as the field types zero value.
+	//
+	// Setting this to true allows stucts without pointer fields to be used
+	// without the risk failure should a nil value returned from WMI.
+	NonePtrZero bool
+
+	// PtrNil specifies if nil values for pointer fields should be returned
+	// as nil.
+	//
+	// Setting this to true will set pointer fields to nil where WMI
+	// returned nil, otherwise the types zero value will be returned.
+	PtrNil bool
+
+	// AllowMissingFields specifies that struct fields not present in the
+	// query result should not result in an error.
+	//
+	// Setting this to true allows custom queries to be used with full
+	// struct definitions instead of having to define multiple structs.
+	AllowMissingFields bool
+
+	// SWbemServiceClient is an optional SWbemServices object that can be
+	// initialized and then reused across multiple queries. If it is null
+	// then the method will initialize a new temporary client each time.
+	SWbemServicesClient *SWbemServices
+}
+
+// DefaultClient is the default Client and is used by Query, QueryNamespace, and CallMethod.
+var DefaultClient = &Client{}
+
+// coinitService coinitializes WMI service. If no error is returned, a cleanup function
+// is returned which must be executed (usually deferred) to clean up allocated resources.
+func (c *Client) coinitService(connectServerArgs ...interface{}) (*ole.IDispatch, func(), error) {
+	var unknown *ole.IUnknown
+	var wmi *ole.IDispatch
+	var serviceRaw *ole.VARIANT
+
+	// be sure teardown happens in the reverse
+	// order from that which they were created
+	deferFn := func() {
+		if serviceRaw != nil {
+			serviceRaw.Clear()
+		}
+		if wmi != nil {
+			wmi.Release()
+		}
+		if unknown != nil {
+			unknown.Release()
+		}
+		ole.CoUninitialize()
+	}
+
+	// if we error'ed here, clean up immediately
+	var err error
+	defer func() {
+		if err != nil {
+			deferFn()
+		}
+	}()
+
+	err = ole.CoInitializeEx(0, ole.COINIT_MULTITHREADED)
+	if err != nil {
+		oleCode := err.(*ole.OleError).Code()
+		if oleCode != ole.S_OK && oleCode != S_FALSE {
+			return nil, nil, err
+		}
+	}
+
+	unknown, err = oleutil.CreateObject("WbemScripting.SWbemLocator")
+	if err != nil {
+		return nil, nil, err
+	} else if unknown == nil {
+		return nil, nil, ErrNilCreateObject
+	}
+
+	wmi, err = unknown.QueryInterface(ole.IID_IDispatch)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	// service is a SWbemServices
+	serviceRaw, err = oleutil.CallMethod(wmi, "ConnectServer", connectServerArgs...)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	return serviceRaw.ToIDispatch(), deferFn, nil
+}
+
+// CallMethod calls a WMI method named methodName on an instance
+// of the class named className. It passes in the arguments given
+// in params. Use connectServerArgs to customize the machine and
+// namespace; by default, the local machine and default namespace
+// are used. See
+// https://docs.microsoft.com/en-us/windows/desktop/WmiSdk/swbemlocator-connectserver
+// for details.
+func (c *Client) CallMethod(connectServerArgs []interface{}, className, methodName string, params []interface{}) (int32, error) {
+	service, cleanup, err := c.coinitService(connectServerArgs...)
+	if err != nil {
+		return 0, fmt.Errorf("coinit: %v", err)
+	}
+	defer cleanup()
+
+	// Get class
+	classRaw, err := oleutil.CallMethod(service, "Get", className)
+	if err != nil {
+		return 0, fmt.Errorf("CallMethod Get class %s: %v", className, err)
+	}
+	class := classRaw.ToIDispatch()
+	defer classRaw.Clear()
+
+	// Run method
+	resultRaw, err := oleutil.CallMethod(class, methodName, params...)
+	if err != nil {
+		return 0, fmt.Errorf("CallMethod %s.%s: %v", className, methodName, err)
+	}
+	resultInt, ok := resultRaw.Value().(int32)
+	if !ok {
+		return 0, fmt.Errorf("return value was not an int32: %v (%T)", resultRaw, resultRaw)
+	}
+
+	return resultInt, nil
+}
+
+// Query runs the WQL query and appends the values to dst.
+//
+// dst must have type *[]S or *[]*S, for some struct type S. Fields selected in
+// the query must have the same name in dst. Supported types are all signed and
+// unsigned integers, time.Time, string, bool, or a pointer to one of those.
+// Array types are not supported.
+//
+// By default, the local machine and default namespace are used. These can be
+// changed using connectServerArgs. See
+// https://docs.microsoft.com/en-us/windows/desktop/WmiSdk/swbemlocator-connectserver
+// for details.
+func (c *Client) Query(query string, dst interface{}, connectServerArgs ...interface{}) error {
+	dv := reflect.ValueOf(dst)
+	if dv.Kind() != reflect.Ptr || dv.IsNil() {
+		return ErrInvalidEntityType
+	}
+	dv = dv.Elem()
+	mat, elemType := checkMultiArg(dv)
+	if mat == multiArgTypeInvalid {
+		return ErrInvalidEntityType
+	}
+
+	lock.Lock()
+	defer lock.Unlock()
+	runtime.LockOSThread()
+	defer runtime.UnlockOSThread()
+
+	service, cleanup, err := c.coinitService(connectServerArgs...)
+	if err != nil {
+		return err
+	}
+	defer cleanup()
+
+	// result is a SWBemObjectSet
+	resultRaw, err := oleutil.CallMethod(service, "ExecQuery", query)
+	if err != nil {
+		return err
+	}
+	result := resultRaw.ToIDispatch()
+	defer resultRaw.Clear()
+
+	count, err := oleInt64(result, "Count")
+	if err != nil {
+		return err
+	}
+
+	enumProperty, err := result.GetProperty("_NewEnum")
+	if err != nil {
+		return err
+	}
+	defer enumProperty.Clear()
+
+	enum, err := enumProperty.ToIUnknown().IEnumVARIANT(ole.IID_IEnumVariant)
+	if err != nil {
+		return err
+	}
+	if enum == nil {
+		return fmt.Errorf("can't get IEnumVARIANT, enum is nil")
+	}
+	defer enum.Release()
+
+	// Initialize a slice with Count capacity
+	dv.Set(reflect.MakeSlice(dv.Type(), 0, int(count)))
+
+	var errFieldMismatch error
+	for itemRaw, length, err := enum.Next(1); length > 0; itemRaw, length, err = enum.Next(1) {
+		if err != nil {
+			return err
+		}
+
+		err := func() error {
+			// item is a SWbemObject, but really a Win32_Process
+			item := itemRaw.ToIDispatch()
+			defer item.Release()
+
+			ev := reflect.New(elemType)
+			if err = c.loadEntity(ev.Interface(), item); err != nil {
+				if _, ok := err.(*ErrFieldMismatch); ok {
+					// We continue loading entities even in the face of field mismatch errors.
+					// If we encounter any other error, that other error is returned. Otherwise,
+					// an ErrFieldMismatch is returned.
+					errFieldMismatch = err
+				} else {
+					return err
+				}
+			}
+			if mat != multiArgTypeStructPtr {
+				ev = ev.Elem()
+			}
+			dv.Set(reflect.Append(dv, ev))
+			return nil
+		}()
+		if err != nil {
+			return err
+		}
+	}
+	return errFieldMismatch
+}
+
+// ErrFieldMismatch is returned when a field is to be loaded into a different
+// type than the one it was stored from, or when a field is missing or
+// unexported in the destination struct.
+// StructType is the type of the struct pointed to by the destination argument.
+type ErrFieldMismatch struct {
+	StructType reflect.Type
+	FieldName  string
+	Reason     string
+}
+
+func (e *ErrFieldMismatch) Error() string {
+	return fmt.Sprintf("wmi: cannot load field %q into a %q: %s",
+		e.FieldName, e.StructType, e.Reason)
+}
+
+var timeType = reflect.TypeOf(time.Time{})
+
+// loadEntity loads a SWbemObject into a struct pointer.
+func (c *Client) loadEntity(dst interface{}, src *ole.IDispatch) (errFieldMismatch error) {
+	v := reflect.ValueOf(dst).Elem()
+	for i := 0; i < v.NumField(); i++ {
+		f := v.Field(i)
+		of := f
+		isPtr := f.Kind() == reflect.Ptr
+		if isPtr {
+			ptr := reflect.New(f.Type().Elem())
+			f.Set(ptr)
+			f = f.Elem()
+		}
+		n := v.Type().Field(i).Name
+		if !f.CanSet() {
+			return &ErrFieldMismatch{
+				StructType: of.Type(),
+				FieldName:  n,
+				Reason:     "CanSet() is false",
+			}
+		}
+		prop, err := oleutil.GetProperty(src, n)
+		if err != nil {
+			if !c.AllowMissingFields {
+				errFieldMismatch = &ErrFieldMismatch{
+					StructType: of.Type(),
+					FieldName:  n,
+					Reason:     "no such struct field",
+				}
+			}
+			continue
+		}
+		defer prop.Clear()
+
+		if prop.VT == 0x1 { //VT_NULL
+			continue
+		}
+
+		switch val := prop.Value().(type) {
+		case int8, int16, int32, int64, int:
+			v := reflect.ValueOf(val).Int()
+			switch f.Kind() {
+			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+				f.SetInt(v)
+			case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+				f.SetUint(uint64(v))
+			default:
+				return &ErrFieldMismatch{
+					StructType: of.Type(),
+					FieldName:  n,
+					Reason:     "not an integer class",
+				}
+			}
+		case uint8, uint16, uint32, uint64:
+			v := reflect.ValueOf(val).Uint()
+			switch f.Kind() {
+			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+				f.SetInt(int64(v))
+			case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+				f.SetUint(v)
+			default:
+				return &ErrFieldMismatch{
+					StructType: of.Type(),
+					FieldName:  n,
+					Reason:     "not an integer class",
+				}
+			}
+		case string:
+			switch f.Kind() {
+			case reflect.String:
+				f.SetString(val)
+			case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+				iv, err := strconv.ParseInt(val, 10, 64)
+				if err != nil {
+					return err
+				}
+				f.SetInt(iv)
+			case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+				uv, err := strconv.ParseUint(val, 10, 64)
+				if err != nil {
+					return err
+				}
+				f.SetUint(uv)
+			case reflect.Struct:
+				switch f.Type() {
+				case timeType:
+					if len(val) == 25 {
+						mins, err := strconv.Atoi(val[22:])
+						if err != nil {
+							return err
+						}
+						val = val[:22] + fmt.Sprintf("%02d%02d", mins/60, mins%60)
+					}
+					t, err := time.Parse("20060102150405.000000-0700", val)
+					if err != nil {
+						return err
+					}
+					f.Set(reflect.ValueOf(t))
+				}
+			}
+		case bool:
+			switch f.Kind() {
+			case reflect.Bool:
+				f.SetBool(val)
+			default:
+				return &ErrFieldMismatch{
+					StructType: of.Type(),
+					FieldName:  n,
+					Reason:     "not a bool",
+				}
+			}
+		case float32:
+			switch f.Kind() {
+			case reflect.Float32:
+				f.SetFloat(float64(val))
+			default:
+				return &ErrFieldMismatch{
+					StructType: of.Type(),
+					FieldName:  n,
+					Reason:     "not a Float32",
+				}
+			}
+		default:
+			if f.Kind() == reflect.Slice {
+				switch f.Type().Elem().Kind() {
+				case reflect.String:
+					safeArray := prop.ToArray()
+					if safeArray != nil {
+						arr := safeArray.ToValueArray()
+						fArr := reflect.MakeSlice(f.Type(), len(arr), len(arr))
+						for i, v := range arr {
+							s := fArr.Index(i)
+							s.SetString(v.(string))
+						}
+						f.Set(fArr)
+					}
+				case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uint:
+					safeArray := prop.ToArray()
+					if safeArray != nil {
+						arr := safeArray.ToValueArray()
+						fArr := reflect.MakeSlice(f.Type(), len(arr), len(arr))
+						for i, v := range arr {
+							s := fArr.Index(i)
+							s.SetUint(reflect.ValueOf(v).Uint())
+						}
+						f.Set(fArr)
+					}
+				case reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Int:
+					safeArray := prop.ToArray()
+					if safeArray != nil {
+						arr := safeArray.ToValueArray()
+						fArr := reflect.MakeSlice(f.Type(), len(arr), len(arr))
+						for i, v := range arr {
+							s := fArr.Index(i)
+							s.SetInt(reflect.ValueOf(v).Int())
+						}
+						f.Set(fArr)
+					}
+				default:
+					return &ErrFieldMismatch{
+						StructType: of.Type(),
+						FieldName:  n,
+						Reason:     fmt.Sprintf("unsupported slice type (%T)", val),
+					}
+				}
+			} else {
+				typeof := reflect.TypeOf(val)
+				if typeof == nil && (isPtr || c.NonePtrZero) {
+					if (isPtr && c.PtrNil) || (!isPtr && c.NonePtrZero) {
+						of.Set(reflect.Zero(of.Type()))
+					}
+					break
+				}
+				return &ErrFieldMismatch{
+					StructType: of.Type(),
+					FieldName:  n,
+					Reason:     fmt.Sprintf("unsupported type (%T)", val),
+				}
+			}
+		}
+	}
+	return errFieldMismatch
+}
+
+type multiArgType int
+
+const (
+	multiArgTypeInvalid multiArgType = iota
+	multiArgTypeStruct
+	multiArgTypeStructPtr
+)
+
+// checkMultiArg checks that v has type []S, []*S for some struct type S.
+//
+// It returns what category the slice's elements are, and the reflect.Type
+// that represents S.
+func checkMultiArg(v reflect.Value) (m multiArgType, elemType reflect.Type) {
+	if v.Kind() != reflect.Slice {
+		return multiArgTypeInvalid, nil
+	}
+	elemType = v.Type().Elem()
+	switch elemType.Kind() {
+	case reflect.Struct:
+		return multiArgTypeStruct, elemType
+	case reflect.Ptr:
+		elemType = elemType.Elem()
+		if elemType.Kind() == reflect.Struct {
+			return multiArgTypeStructPtr, elemType
+		}
+	}
+	return multiArgTypeInvalid, nil
+}
+
+func oleInt64(item *ole.IDispatch, prop string) (int64, error) {
+	v, err := oleutil.GetProperty(item, prop)
+	if err != nil {
+		return 0, err
+	}
+	defer v.Clear()
+
+	i := int64(v.Val)
+	return i, nil
+}
+
+// CreateQuery returns a WQL query string that queries all columns of src. where
+// is an optional string that is appended to the query, to be used with WHERE
+// clauses. In such a case, the "WHERE" string should appear at the beginning.
+// The wmi class is obtained by the name of the type. You can pass a optional
+// class throught the variadic class parameter which is useful for anonymous
+// structs.
+func CreateQuery(src interface{}, where string, class ...string) string {
+	var b bytes.Buffer
+	b.WriteString("SELECT ")
+	s := reflect.Indirect(reflect.ValueOf(src))
+	t := s.Type()
+	if s.Kind() == reflect.Slice {
+		t = t.Elem()
+	}
+	if t.Kind() != reflect.Struct {
+		return ""
+	}
+	var fields []string
+	for i := 0; i < t.NumField(); i++ {
+		fields = append(fields, t.Field(i).Name)
+	}
+	b.WriteString(strings.Join(fields, ", "))
+	b.WriteString(" FROM ")
+	if len(class) > 0{
+		b.WriteString(class[0])
+	} else {
+		b.WriteString(t.Name())
+	}
+	b.WriteString(" " + where)
+	return b.String()
+}

vendor/github.com/astaxie/beego/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2014 astaxie
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

vendor/github.com/astaxie/beego/httplib/README.md

@@ -0,0 +1,97 @@
+# httplib
+httplib is an libs help you to curl remote url.
+
+# How to use?
+
+## GET
+you can use Get to crawl data.
+
+	import "github.com/astaxie/beego/httplib"
+	
+	str, err := httplib.Get("http://beego.me/").String()
+	if err != nil {
+        	// error
+	}
+	fmt.Println(str)
+	
+## POST
+POST data to remote url
+
+	req := httplib.Post("http://beego.me/")
+	req.Param("username","astaxie")
+	req.Param("password","123456")
+	str, err := req.String()
+	if err != nil {
+        	// error
+	}
+	fmt.Println(str)
+
+## Set timeout
+
+The default timeout is `60` seconds, function prototype:
+
+	SetTimeout(connectTimeout, readWriteTimeout time.Duration)
+
+Example:
+
+	// GET
+	httplib.Get("http://beego.me/").SetTimeout(100 * time.Second, 30 * time.Second)
+	
+	// POST
+	httplib.Post("http://beego.me/").SetTimeout(100 * time.Second, 30 * time.Second)
+
+
+## Debug
+
+If you want to debug the request info, set the debug on
+
+	httplib.Get("http://beego.me/").Debug(true)
+	
+## Set HTTP Basic Auth
+
+	str, err := Get("http://beego.me/").SetBasicAuth("user", "passwd").String()
+	if err != nil {
+        	// error
+	}
+	fmt.Println(str)
+	
+## Set HTTPS
+
+If request url is https, You can set the client support TSL:
+
+	httplib.SetTLSClientConfig(&tls.Config{InsecureSkipVerify: true})
+	
+More info about the `tls.Config` please visit http://golang.org/pkg/crypto/tls/#Config	
+
+## Set HTTP Version
+
+some servers need to specify the protocol version of HTTP
+
+	httplib.Get("http://beego.me/").SetProtocolVersion("HTTP/1.1")
+	
+## Set Cookie
+
+some http request need setcookie. So set it like this:
+
+	cookie := &http.Cookie{}
+	cookie.Name = "username"
+	cookie.Value  = "astaxie"
+	httplib.Get("http://beego.me/").SetCookie(cookie)
+
+## Upload file
+
+httplib support mutil file upload, use `req.PostFile()`
+
+	req := httplib.Post("http://beego.me/")
+	req.Param("username","astaxie")
+	req.PostFile("uploadfile1", "httplib.pdf")
+	str, err := req.String()
+	if err != nil {
+        	// error
+	}
+	fmt.Println(str)
+
+
+See godoc for further documentation and examples.
+
+* [godoc.org/github.com/astaxie/beego/httplib](https://godoc.org/github.com/astaxie/beego/httplib)

vendor/github.com/astaxie/beego/httplib/httplib.go

@@ -0,0 +1,654 @@
+// Copyright 2014 beego Author. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package httplib is used as http.Client
+// Usage:
+//
+// import "github.com/astaxie/beego/httplib"
+//
+//	b := httplib.Post("http://beego.me/")
+//	b.Param("username","astaxie")
+//	b.Param("password","123456")
+//	b.PostFile("uploadfile1", "httplib.pdf")
+//	b.PostFile("uploadfile2", "httplib.txt")
+//	str, err := b.String()
+//	if err != nil {
+//		t.Fatal(err)
+//	}
+//	fmt.Println(str)
+//
+//  more docs http://beego.me/docs/module/httplib.md
+package httplib
+
+import (
+	"bytes"
+	"compress/gzip"
+	"crypto/tls"
+	"encoding/json"
+	"encoding/xml"
+	"io"
+	"io/ioutil"
+	"log"
+	"mime/multipart"
+	"net"
+	"net/http"
+	"net/http/cookiejar"
+	"net/http/httputil"
+	"net/url"
+	"os"
+	"path"
+	"strings"
+	"sync"
+	"time"
+
+	"gopkg.in/yaml.v2"
+)
+
+var defaultSetting = BeegoHTTPSettings{
+	UserAgent:        "beegoServer",
+	ConnectTimeout:   60 * time.Second,
+	ReadWriteTimeout: 60 * time.Second,
+	Gzip:             true,
+	DumpBody:         true,
+}
+
+var defaultCookieJar http.CookieJar
+var settingMutex sync.Mutex
+
+// createDefaultCookie creates a global cookiejar to store cookies.
+func createDefaultCookie() {
+	settingMutex.Lock()
+	defer settingMutex.Unlock()
+	defaultCookieJar, _ = cookiejar.New(nil)
+}
+
+// SetDefaultSetting Overwrite default settings
+func SetDefaultSetting(setting BeegoHTTPSettings) {
+	settingMutex.Lock()
+	defer settingMutex.Unlock()
+	defaultSetting = setting
+}
+
+// NewBeegoRequest return *BeegoHttpRequest with specific method
+func NewBeegoRequest(rawurl, method string) *BeegoHTTPRequest {
+	var resp http.Response
+	u, err := url.Parse(rawurl)
+	if err != nil {
+		log.Println("Httplib:", err)
+	}
+	req := http.Request{
+		URL:        u,
+		Method:     method,
+		Header:     make(http.Header),
+		Proto:      "HTTP/1.1",
+		ProtoMajor: 1,
+		ProtoMinor: 1,
+	}
+	return &BeegoHTTPRequest{
+		url:     rawurl,
+		req:     &req,
+		params:  map[string][]string{},
+		files:   map[string]string{},
+		setting: defaultSetting,
+		resp:    &resp,
+	}
+}
+
+// Get returns *BeegoHttpRequest with GET method.
+func Get(url string) *BeegoHTTPRequest {
+	return NewBeegoRequest(url, "GET")
+}
+
+// Post returns *BeegoHttpRequest with POST method.
+func Post(url string) *BeegoHTTPRequest {
+	return NewBeegoRequest(url, "POST")
+}
+
+// Put returns *BeegoHttpRequest with PUT method.
+func Put(url string) *BeegoHTTPRequest {
+	return NewBeegoRequest(url, "PUT")
+}
+
+// Delete returns *BeegoHttpRequest DELETE method.
+func Delete(url string) *BeegoHTTPRequest {
+	return NewBeegoRequest(url, "DELETE")
+}
+
+// Head returns *BeegoHttpRequest with HEAD method.
+func Head(url string) *BeegoHTTPRequest {
+	return NewBeegoRequest(url, "HEAD")
+}
+
+// BeegoHTTPSettings is the http.Client setting
+type BeegoHTTPSettings struct {
+	ShowDebug        bool
+	UserAgent        string
+	ConnectTimeout   time.Duration
+	ReadWriteTimeout time.Duration
+	TLSClientConfig  *tls.Config
+	Proxy            func(*http.Request) (*url.URL, error)
+	Transport        http.RoundTripper
+	CheckRedirect    func(req *http.Request, via []*http.Request) error
+	EnableCookie     bool
+	Gzip             bool
+	DumpBody         bool
+	Retries          int // if set to -1 means will retry forever
+	RetryDelay       time.Duration
+}
+
+// BeegoHTTPRequest provides more useful methods for requesting one url than http.Request.
+type BeegoHTTPRequest struct {
+	url     string
+	req     *http.Request
+	params  map[string][]string
+	files   map[string]string
+	setting BeegoHTTPSettings
+	resp    *http.Response
+	body    []byte
+	dump    []byte
+}
+
+// GetRequest return the request object
+func (b *BeegoHTTPRequest) GetRequest() *http.Request {
+	return b.req
+}
+
+// Setting Change request settings
+func (b *BeegoHTTPRequest) Setting(setting BeegoHTTPSettings) *BeegoHTTPRequest {
+	b.setting = setting
+	return b
+}
+
+// SetBasicAuth sets the request's Authorization header to use HTTP Basic Authentication with the provided username and password.
+func (b *BeegoHTTPRequest) SetBasicAuth(username, password string) *BeegoHTTPRequest {
+	b.req.SetBasicAuth(username, password)
+	return b
+}
+
+// SetEnableCookie sets enable/disable cookiejar
+func (b *BeegoHTTPRequest) SetEnableCookie(enable bool) *BeegoHTTPRequest {
+	b.setting.EnableCookie = enable
+	return b
+}
+
+// SetUserAgent sets User-Agent header field
+func (b *BeegoHTTPRequest) SetUserAgent(useragent string) *BeegoHTTPRequest {
+	b.setting.UserAgent = useragent
+	return b
+}
+
+// Debug sets show debug or not when executing request.
+func (b *BeegoHTTPRequest) Debug(isdebug bool) *BeegoHTTPRequest {
+	b.setting.ShowDebug = isdebug
+	return b
+}
+
+// Retries sets Retries times.
+// default is 0 means no retried.
+// -1 means retried forever.
+// others means retried times.
+func (b *BeegoHTTPRequest) Retries(times int) *BeegoHTTPRequest {
+	b.setting.Retries = times
+	return b
+}
+
+func (b *BeegoHTTPRequest) RetryDelay(delay time.Duration) *BeegoHTTPRequest {
+	b.setting.RetryDelay = delay
+	return b
+}
+
+// DumpBody setting whether need to Dump the Body.
+func (b *BeegoHTTPRequest) DumpBody(isdump bool) *BeegoHTTPRequest {
+	b.setting.DumpBody = isdump
+	return b
+}
+
+// DumpRequest return the DumpRequest
+func (b *BeegoHTTPRequest) DumpRequest() []byte {
+	return b.dump
+}
+
+// SetTimeout sets connect time out and read-write time out for BeegoRequest.
+func (b *BeegoHTTPRequest) SetTimeout(connectTimeout, readWriteTimeout time.Duration) *BeegoHTTPRequest {
+	b.setting.ConnectTimeout = connectTimeout
+	b.setting.ReadWriteTimeout = readWriteTimeout
+	return b
+}
+
+// SetTLSClientConfig sets tls connection configurations if visiting https url.
+func (b *BeegoHTTPRequest) SetTLSClientConfig(config *tls.Config) *BeegoHTTPRequest {
+	b.setting.TLSClientConfig = config
+	return b
+}
+
+// Header add header item string in request.
+func (b *BeegoHTTPRequest) Header(key, value string) *BeegoHTTPRequest {
+	b.req.Header.Set(key, value)
+	return b
+}
+
+// SetHost set the request host
+func (b *BeegoHTTPRequest) SetHost(host string) *BeegoHTTPRequest {
+	b.req.Host = host
+	return b
+}
+
+// SetProtocolVersion Set the protocol version for incoming requests.
+// Client requests always use HTTP/1.1.
+func (b *BeegoHTTPRequest) SetProtocolVersion(vers string) *BeegoHTTPRequest {
+	if len(vers) == 0 {
+		vers = "HTTP/1.1"
+	}
+
+	major, minor, ok := http.ParseHTTPVersion(vers)
+	if ok {
+		b.req.Proto = vers
+		b.req.ProtoMajor = major
+		b.req.ProtoMinor = minor
+	}
+
+	return b
+}
+
+// SetCookie add cookie into request.
+func (b *BeegoHTTPRequest) SetCookie(cookie *http.Cookie) *BeegoHTTPRequest {
+	b.req.Header.Add("Cookie", cookie.String())
+	return b
+}
+
+// SetTransport set the setting transport
+func (b *BeegoHTTPRequest) SetTransport(transport http.RoundTripper) *BeegoHTTPRequest {
+	b.setting.Transport = transport
+	return b
+}
+
+// SetProxy set the http proxy
+// example:
+//
+//	func(req *http.Request) (*url.URL, error) {
+// 		u, _ := url.ParseRequestURI("http://127.0.0.1:8118")
+// 		return u, nil
+// 	}
+func (b *BeegoHTTPRequest) SetProxy(proxy func(*http.Request) (*url.URL, error)) *BeegoHTTPRequest {
+	b.setting.Proxy = proxy
+	return b
+}
+
+// SetCheckRedirect specifies the policy for handling redirects.
+//
+// If CheckRedirect is nil, the Client uses its default policy,
+// which is to stop after 10 consecutive requests.
+func (b *BeegoHTTPRequest) SetCheckRedirect(redirect func(req *http.Request, via []*http.Request) error) *BeegoHTTPRequest {
+	b.setting.CheckRedirect = redirect
+	return b
+}
+
+// Param adds query param in to request.
+// params build query string as ?key1=value1&key2=value2...
+func (b *BeegoHTTPRequest) Param(key, value string) *BeegoHTTPRequest {
+	if param, ok := b.params[key]; ok {
+		b.params[key] = append(param, value)
+	} else {
+		b.params[key] = []string{value}
+	}
+	return b
+}
+
+// PostFile add a post file to the request
+func (b *BeegoHTTPRequest) PostFile(formname, filename string) *BeegoHTTPRequest {
+	b.files[formname] = filename
+	return b
+}
+
+// Body adds request raw body.
+// it supports string and []byte.
+func (b *BeegoHTTPRequest) Body(data interface{}) *BeegoHTTPRequest {
+	switch t := data.(type) {
+	case string:
+		bf := bytes.NewBufferString(t)
+		b.req.Body = ioutil.NopCloser(bf)
+		b.req.ContentLength = int64(len(t))
+	case []byte:
+		bf := bytes.NewBuffer(t)
+		b.req.Body = ioutil.NopCloser(bf)
+		b.req.ContentLength = int64(len(t))
+	}
+	return b
+}
+
+// XMLBody adds request raw body encoding by XML.
+func (b *BeegoHTTPRequest) XMLBody(obj interface{}) (*BeegoHTTPRequest, error) {
+	if b.req.Body == nil && obj != nil {
+		byts, err := xml.Marshal(obj)
+		if err != nil {
+			return b, err
+		}
+		b.req.Body = ioutil.NopCloser(bytes.NewReader(byts))
+		b.req.ContentLength = int64(len(byts))
+		b.req.Header.Set("Content-Type", "application/xml")
+	}
+	return b, nil
+}
+
+// YAMLBody adds request raw body encoding by YAML.
+func (b *BeegoHTTPRequest) YAMLBody(obj interface{}) (*BeegoHTTPRequest, error) {
+	if b.req.Body == nil && obj != nil {
+		byts, err := yaml.Marshal(obj)
+		if err != nil {
+			return b, err
+		}
+		b.req.Body = ioutil.NopCloser(bytes.NewReader(byts))
+		b.req.ContentLength = int64(len(byts))
+		b.req.Header.Set("Content-Type", "application/x+yaml")
+	}
+	return b, nil
+}
+
+// JSONBody adds request raw body encoding by JSON.
+func (b *BeegoHTTPRequest) JSONBody(obj interface{}) (*BeegoHTTPRequest, error) {
+	if b.req.Body == nil && obj != nil {
+		byts, err := json.Marshal(obj)
+		if err != nil {
+			return b, err
+		}
+		b.req.Body = ioutil.NopCloser(bytes.NewReader(byts))
+		b.req.ContentLength = int64(len(byts))
+		b.req.Header.Set("Content-Type", "application/json")
+	}
+	return b, nil
+}
+
+func (b *BeegoHTTPRequest) buildURL(paramBody string) {
+	// build GET url with query string
+	if b.req.Method == "GET" && len(paramBody) > 0 {
+		if strings.Contains(b.url, "?") {
+			b.url += "&" + paramBody
+		} else {
+			b.url = b.url + "?" + paramBody
+		}
+		return
+	}
+
+	// build POST/PUT/PATCH url and body
+	if (b.req.Method == "POST" || b.req.Method == "PUT" || b.req.Method == "PATCH" || b.req.Method == "DELETE") && b.req.Body == nil {
+		// with files
+		if len(b.files) > 0 {
+			pr, pw := io.Pipe()
+			bodyWriter := multipart.NewWriter(pw)
+			go func() {
+				for formname, filename := range b.files {
+					fileWriter, err := bodyWriter.CreateFormFile(formname, filename)
+					if err != nil {
+						log.Println("Httplib:", err)
+					}
+					fh, err := os.Open(filename)
+					if err != nil {
+						log.Println("Httplib:", err)
+					}
+					//iocopy
+					_, err = io.Copy(fileWriter, fh)
+					fh.Close()
+					if err != nil {
+						log.Println("Httplib:", err)
+					}
+				}
+				for k, v := range b.params {
+					for _, vv := range v {
+						bodyWriter.WriteField(k, vv)
+					}
+				}
+				bodyWriter.Close()
+				pw.Close()
+			}()
+			b.Header("Content-Type", bodyWriter.FormDataContentType())
+			b.req.Body = ioutil.NopCloser(pr)
+			b.Header("Transfer-Encoding", "chunked")
+			return
+		}
+
+		// with params
+		if len(paramBody) > 0 {
+			b.Header("Content-Type", "application/x-www-form-urlencoded")
+			b.Body(paramBody)
+		}
+	}
+}
+
+func (b *BeegoHTTPRequest) getResponse() (*http.Response, error) {
+	if b.resp.StatusCode != 0 {
+		return b.resp, nil
+	}
+	resp, err := b.DoRequest()
+	if err != nil {
+		return nil, err
+	}
+	b.resp = resp
+	return resp, nil
+}
+
+// DoRequest will do the client.Do
+func (b *BeegoHTTPRequest) DoRequest() (resp *http.Response, err error) {
+	var paramBody string
+	if len(b.params) > 0 {
+		var buf bytes.Buffer
+		for k, v := range b.params {
+			for _, vv := range v {
+				buf.WriteString(url.QueryEscape(k))
+				buf.WriteByte('=')
+				buf.WriteString(url.QueryEscape(vv))
+				buf.WriteByte('&')
+			}
+		}
+		paramBody = buf.String()
+		paramBody = paramBody[0 : len(paramBody)-1]
+	}
+
+	b.buildURL(paramBody)
+	urlParsed, err := url.Parse(b.url)
+	if err != nil {
+		return nil, err
+	}
+
+	b.req.URL = urlParsed
+
+	trans := b.setting.Transport
+
+	if trans == nil {
+		// create default transport
+		trans = &http.Transport{
+			TLSClientConfig:     b.setting.TLSClientConfig,
+			Proxy:               b.setting.Proxy,
+			Dial:                TimeoutDialer(b.setting.ConnectTimeout, b.setting.ReadWriteTimeout),
+			MaxIdleConnsPerHost: 100,
+		}
+	} else {
+		// if b.transport is *http.Transport then set the settings.
+		if t, ok := trans.(*http.Transport); ok {
+			if t.TLSClientConfig == nil {
+				t.TLSClientConfig = b.setting.TLSClientConfig
+			}
+			if t.Proxy == nil {
+				t.Proxy = b.setting.Proxy
+			}
+			if t.Dial == nil {
+				t.Dial = TimeoutDialer(b.setting.ConnectTimeout, b.setting.ReadWriteTimeout)
+			}
+		}
+	}
+
+	var jar http.CookieJar
+	if b.setting.EnableCookie {
+		if defaultCookieJar == nil {
+			createDefaultCookie()
+		}
+		jar = defaultCookieJar
+	}
+
+	client := &http.Client{
+		Transport: trans,
+		Jar:       jar,
+	}
+
+	if b.setting.UserAgent != "" && b.req.Header.Get("User-Agent") == "" {
+		b.req.Header.Set("User-Agent", b.setting.UserAgent)
+	}
+
+	if b.setting.CheckRedirect != nil {
+		client.CheckRedirect = b.setting.CheckRedirect
+	}
+
+	if b.setting.ShowDebug {
+		dump, err := httputil.DumpRequest(b.req, b.setting.DumpBody)
+		if err != nil {
+			log.Println(err.Error())
+		}
+		b.dump = dump
+	}
+	// retries default value is 0, it will run once.
+	// retries equal to -1, it will run forever until success
+	// retries is setted, it will retries fixed times.
+	// Sleeps for a 400ms in between calls to reduce spam
+	for i := 0; b.setting.Retries == -1 || i <= b.setting.Retries; i++ {
+		resp, err = client.Do(b.req)
+		if err == nil {
+			break
+		}
+		time.Sleep(b.setting.RetryDelay)
+	}
+	return resp, err
+}
+
+// String returns the body string in response.
+// it calls Response inner.
+func (b *BeegoHTTPRequest) String() (string, error) {
+	data, err := b.Bytes()
+	if err != nil {
+		return "", err
+	}
+
+	return string(data), nil
+}
+
+// Bytes returns the body []byte in response.
+// it calls Response inner.
+func (b *BeegoHTTPRequest) Bytes() ([]byte, error) {
+	if b.body != nil {
+		return b.body, nil
+	}
+	resp, err := b.getResponse()
+	if err != nil {
+		return nil, err
+	}
+	if resp.Body == nil {
+		return nil, nil
+	}
+	defer resp.Body.Close()
+	if b.setting.Gzip && resp.Header.Get("Content-Encoding") == "gzip" {
+		reader, err := gzip.NewReader(resp.Body)
+		if err != nil {
+			return nil, err
+		}
+		b.body, err = ioutil.ReadAll(reader)
+		return b.body, err
+	}
+	b.body, err = ioutil.ReadAll(resp.Body)
+	return b.body, err
+}
+
+// ToFile saves the body data in response to one file.
+// it calls Response inner.
+func (b *BeegoHTTPRequest) ToFile(filename string) error {
+	resp, err := b.getResponse()
+	if err != nil {
+		return err
+	}
+	if resp.Body == nil {
+		return nil
+	}
+	defer resp.Body.Close()
+	err = pathExistAndMkdir(filename)
+	if err != nil {
+		return err
+	}
+	f, err := os.Create(filename)
+	if err != nil {
+		return err
+	}
+	defer f.Close()
+	_, err = io.Copy(f, resp.Body)
+	return err
+}
+
+//Check that the file directory exists, there is no automatically created
+func pathExistAndMkdir(filename string) (err error) {
+	filename = path.Dir(filename)
+	_, err = os.Stat(filename)
+	if err == nil {
+		return nil
+	}
+	if os.IsNotExist(err) {
+		err = os.MkdirAll(filename, os.ModePerm)
+		if err == nil {
+			return nil
+		}
+	}
+	return err
+}
+
+// ToJSON returns the map that marshals from the body bytes as json in response .
+// it calls Response inner.
+func (b *BeegoHTTPRequest) ToJSON(v interface{}) error {
+	data, err := b.Bytes()
+	if err != nil {
+		return err
+	}
+	return json.Unmarshal(data, v)
+}
+
+// ToXML returns the map that marshals from the body bytes as xml in response .
+// it calls Response inner.
+func (b *BeegoHTTPRequest) ToXML(v interface{}) error {
+	data, err := b.Bytes()
+	if err != nil {
+		return err
+	}
+	return xml.Unmarshal(data, v)
+}
+
+// ToYAML returns the map that marshals from the body bytes as yaml in response .
+// it calls Response inner.
+func (b *BeegoHTTPRequest) ToYAML(v interface{}) error {
+	data, err := b.Bytes()
+	if err != nil {
+		return err
+	}
+	return yaml.Unmarshal(data, v)
+}
+
+// Response executes request client gets response mannually.
+func (b *BeegoHTTPRequest) Response() (*http.Response, error) {
+	return b.getResponse()
+}
+
+// TimeoutDialer returns functions of connection dialer with timeout settings for http.Transport Dial field.
+func TimeoutDialer(cTimeout time.Duration, rwTimeout time.Duration) func(net, addr string) (c net.Conn, err error) {
+	return func(netw, addr string) (net.Conn, error) {
+		conn, err := net.DialTimeout(netw, addr, cTimeout)
+		if err != nil {
+			return nil, err
+		}
+		err = conn.SetDeadline(time.Now().Add(rwTimeout))
+		return conn, err
+	}
+}

vendor/github.com/bmizerany/pat/.gitignore

@@ -0,0 +1,3 @@
+*.prof
+*.out
+example/example

vendor/github.com/bmizerany/pat/README.md

@@ -0,0 +1,82 @@
+# pat (formerly pat.go) - A Sinatra style pattern muxer for Go's net/http library
+
+[![GoDoc](https://godoc.org/github.com/bmizerany/pat?status.svg)](https://godoc.org/github.com/bmizerany/pat) 
+
+## INSTALL
+
+	$ go get github.com/bmizerany/pat
+
+## USE
+
+```go
+package main
+
+import (
+	"io"
+	"net/http"
+	"github.com/bmizerany/pat"
+	"log"
+)
+
+// hello world, the web server
+func HelloServer(w http.ResponseWriter, req *http.Request) {
+	io.WriteString(w, "hello, "+req.URL.Query().Get(":name")+"!\n")
+}
+
+func main() {
+	m := pat.New()
+	m.Get("/hello/:name", http.HandlerFunc(HelloServer))
+
+	// Register this pat with the default serve mux so that other packages
+	// may also be exported. (i.e. /debug/pprof/*)
+	http.Handle("/", m)
+	err := http.ListenAndServe(":12345", nil)
+	if err != nil {
+		log.Fatal("ListenAndServe: ", err)
+	}
+}
+```
+
+It's that simple.
+
+For more information, see:
+http://godoc.org/github.com/bmizerany/pat
+
+## CONTRIBUTORS
+
+* Alexis Svinartchouk (@zvin)
+* Blake Mizerany (@bmizerany)
+* Brian Ketelsen (@bketelsen)
+* Bryan Matsuo (@bmatsuo)
+* Caleb Spare (@cespare)
+* Evan Shaw (@edsrzf)
+* Gary Burd (@garyburd)
+* George Rogers (@georgerogers42)
+* Keith Rarick (@kr)
+* Matt Williams (@mattyw)
+* Mike Stipicevic (@wickedchicken)
+* Nick Saika (@nesv)
+* Timothy Cyrus (@tcyrus)
+* binqin (@binku87)
+
+## LICENSE
+
+Copyright (C) 2012 by Keith Rarick, Blake Mizerany
+
+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.

vendor/github.com/bmizerany/pat/mux.go

@@ -0,0 +1,314 @@
+// Package pat implements a simple URL pattern muxer
+package pat
+
+import (
+	"net/http"
+	"net/url"
+	"strings"
+)
+
+// PatternServeMux is an HTTP request multiplexer. It matches the URL of each
+// incoming request against a list of registered patterns with their associated
+// methods and calls the handler for the pattern that most closely matches the
+// URL.
+//
+// Pattern matching attempts each pattern in the order in which they were
+// registered.
+//
+// Patterns may contain literals or captures. Capture names start with a colon
+// and consist of letters A-Z, a-z, _, and 0-9. The rest of the pattern
+// matches literally. The portion of the URL matching each name ends with an
+// occurrence of the character in the pattern immediately following the name,
+// or a /, whichever comes first. It is possible for a name to match the empty
+// string.
+//
+// Example pattern with one capture:
+//   /hello/:name
+// Will match:
+//   /hello/blake
+//   /hello/keith
+// Will not match:
+//   /hello/blake/
+//   /hello/blake/foo
+//   /foo
+//   /foo/bar
+//
+// Example 2:
+//    /hello/:name/
+// Will match:
+//   /hello/blake/
+//   /hello/keith/foo
+//   /hello/blake
+//   /hello/keith
+// Will not match:
+//   /foo
+//   /foo/bar
+//
+// A pattern ending with a slash will add an implicit redirect for its non-slash
+// version. For example: Get("/foo/", handler) also registers
+// Get("/foo", handler) as a redirect. You may override it by registering
+// Get("/foo", anotherhandler) before the slash version.
+//
+// Retrieve the capture from the r.URL.Query().Get(":name") in a handler (note
+// the colon). If a capture name appears more than once, the additional values
+// are appended to the previous values (see
+// http://golang.org/pkg/net/url/#Values)
+//
+// A trivial example server is:
+//
+//	package main
+//
+//	import (
+//		"io"
+//		"net/http"
+//		"github.com/bmizerany/pat"
+//		"log"
+//	)
+//
+//	// hello world, the web server
+//	func HelloServer(w http.ResponseWriter, req *http.Request) {
+//		io.WriteString(w, "hello, "+req.URL.Query().Get(":name")+"!\n")
+//	}
+//
+//	func main() {
+//		m := pat.New()
+//		m.Get("/hello/:name", http.HandlerFunc(HelloServer))
+//
+//		// Register this pat with the default serve mux so that other packages
+//		// may also be exported. (i.e. /debug/pprof/*)
+//		http.Handle("/", m)
+//		err := http.ListenAndServe(":12345", nil)
+//		if err != nil {
+//			log.Fatal("ListenAndServe: ", err)
+//		}
+//	}
+//
+// When "Method Not Allowed":
+//
+// Pat knows what methods are allowed given a pattern and a URI. For
+// convenience, PatternServeMux will add the Allow header for requests that
+// match a pattern for a method other than the method requested and set the
+// Status to "405 Method Not Allowed".
+//
+// If the NotFound handler is set, then it is used whenever the pattern doesn't
+// match the request path for the current method (and the Allow header is not
+// altered).
+type PatternServeMux struct {
+	// NotFound, if set, is used whenever the request doesn't match any
+	// pattern for its method. NotFound should be set before serving any
+	// requests.
+	NotFound http.Handler
+	handlers map[string][]*patHandler
+}
+
+// New returns a new PatternServeMux.
+func New() *PatternServeMux {
+	return &PatternServeMux{handlers: make(map[string][]*patHandler)}
+}
+
+// ServeHTTP matches r.URL.Path against its routing table using the rules
+// described above.
+func (p *PatternServeMux) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	for _, ph := range p.handlers[r.Method] {
+		if params, ok := ph.try(r.URL.EscapedPath()); ok {
+			if len(params) > 0 && !ph.redirect {
+				r.URL.RawQuery = url.Values(params).Encode() + "&" + r.URL.RawQuery
+			}
+			ph.ServeHTTP(w, r)
+			return
+		}
+	}
+
+	if p.NotFound != nil {
+		p.NotFound.ServeHTTP(w, r)
+		return
+	}
+
+	allowed := make([]string, 0, len(p.handlers))
+	for meth, handlers := range p.handlers {
+		if meth == r.Method {
+			continue
+		}
+
+		for _, ph := range handlers {
+			if _, ok := ph.try(r.URL.EscapedPath()); ok {
+				allowed = append(allowed, meth)
+			}
+		}
+	}
+
+	if len(allowed) == 0 {
+		http.NotFound(w, r)
+		return
+	}
+
+	w.Header().Add("Allow", strings.Join(allowed, ", "))
+	http.Error(w, "Method Not Allowed", 405)
+}
+
+// Head will register a pattern with a handler for HEAD requests.
+func (p *PatternServeMux) Head(pat string, h http.Handler) {
+	p.Add("HEAD", pat, h)
+}
+
+// Get will register a pattern with a handler for GET requests.
+// It also registers pat for HEAD requests. If this needs to be overridden, use
+// Head before Get with pat.
+func (p *PatternServeMux) Get(pat string, h http.Handler) {
+	p.Add("HEAD", pat, h)
+	p.Add("GET", pat, h)
+}
+
+// Post will register a pattern with a handler for POST requests.
+func (p *PatternServeMux) Post(pat string, h http.Handler) {
+	p.Add("POST", pat, h)
+}
+
+// Put will register a pattern with a handler for PUT requests.
+func (p *PatternServeMux) Put(pat string, h http.Handler) {
+	p.Add("PUT", pat, h)
+}
+
+// Del will register a pattern with a handler for DELETE requests.
+func (p *PatternServeMux) Del(pat string, h http.Handler) {
+	p.Add("DELETE", pat, h)
+}
+
+// Options will register a pattern with a handler for OPTIONS requests.
+func (p *PatternServeMux) Options(pat string, h http.Handler) {
+	p.Add("OPTIONS", pat, h)
+}
+
+// Patch will register a pattern with a handler for PATCH requests.
+func (p *PatternServeMux) Patch(pat string, h http.Handler) {
+	p.Add("PATCH", pat, h)
+}
+
+// Add will register a pattern with a handler for meth requests.
+func (p *PatternServeMux) Add(meth, pat string, h http.Handler) {
+	p.add(meth, pat, h, false)
+}
+
+func (p *PatternServeMux) add(meth, pat string, h http.Handler, redirect bool) {
+	handlers := p.handlers[meth]
+	for _, p1 := range handlers {
+		if p1.pat == pat {
+			return // found existing pattern; do nothing
+		}
+	}
+	handler := &patHandler{
+		pat:      pat,
+		Handler:  h,
+		redirect: redirect,
+	}
+	p.handlers[meth] = append(handlers, handler)
+
+	n := len(pat)
+	if n > 0 && pat[n-1] == '/' {
+		p.add(meth, pat[:n-1], http.HandlerFunc(addSlashRedirect), true)
+	}
+}
+
+func addSlashRedirect(w http.ResponseWriter, r *http.Request) {
+	u := *r.URL
+	u.Path += "/"
+	http.Redirect(w, r, u.String(), http.StatusMovedPermanently)
+}
+
+// Tail returns the trailing string in path after the final slash for a pat ending with a slash.
+//
+// Examples:
+//
+//	Tail("/hello/:title/", "/hello/mr/mizerany") == "mizerany"
+//	Tail("/:a/", "/x/y/z")                       == "y/z"
+//
+func Tail(pat, path string) string {
+	var i, j int
+	for i < len(path) {
+		switch {
+		case j >= len(pat):
+			if pat[len(pat)-1] == '/' {
+				return path[i:]
+			}
+			return ""
+		case pat[j] == ':':
+			var nextc byte
+			_, nextc, j = match(pat, isAlnum, j+1)
+			_, _, i = match(path, matchPart(nextc), i)
+		case path[i] == pat[j]:
+			i++
+			j++
+		default:
+			return ""
+		}
+	}
+	return ""
+}
+
+type patHandler struct {
+	pat string
+	http.Handler
+	redirect bool
+}
+
+func (ph *patHandler) try(path string) (url.Values, bool) {
+	p := make(url.Values)
+	var i, j int
+	for i < len(path) {
+		switch {
+		case j >= len(ph.pat):
+			if ph.pat != "/" && len(ph.pat) > 0 && ph.pat[len(ph.pat)-1] == '/' {
+				return p, true
+			}
+			return nil, false
+		case ph.pat[j] == ':':
+			var name, val string
+			var nextc byte
+			name, nextc, j = match(ph.pat, isAlnum, j+1)
+			val, _, i = match(path, matchPart(nextc), i)
+			escval, err := url.QueryUnescape(val)
+			if err != nil {
+				return nil, false
+			}
+			p.Add(":"+name, escval)
+		case path[i] == ph.pat[j]:
+			i++
+			j++
+		default:
+			return nil, false
+		}
+	}
+	if j != len(ph.pat) {
+		return nil, false
+	}
+	return p, true
+}
+
+func matchPart(b byte) func(byte) bool {
+	return func(c byte) bool {
+		return c != b && c != '/'
+	}
+}
+
+func match(s string, f func(byte) bool, i int) (matched string, next byte, j int) {
+	j = i
+	for j < len(s) && f(s[j]) {
+		j++
+	}
+	if j < len(s) {
+		next = s[j]
+	}
+	return s[i:j], next, j
+}
+
+func isAlpha(ch byte) bool {
+	return 'a' <= ch && ch <= 'z' || 'A' <= ch && ch <= 'Z' || ch == '_'
+}
+
+func isDigit(ch byte) bool {
+	return '0' <= ch && ch <= '9'
+}
+
+func isAlnum(ch byte) bool {
+	return isAlpha(ch) || isDigit(ch)
+}

vendor/github.com/busyfree/tusd/LICENSE.txt

@@ -0,0 +1,19 @@
+Copyright (c) 2013-2017 Transloadit Ltd and Contributors
+
+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.

vendor/github.com/busyfree/tusd/internal/uid/uid.go

@@ -0,0 +1,23 @@
+package uid
+
+import (
+	"crypto/rand"
+	"encoding/hex"
+	"io"
+)
+
+// uid returns a unique id. These ids consist of 128 bits from a
+// cryptographically strong pseudo-random generator and are like uuids, but
+// without the dashes and significant bits.
+//
+// See: http://en.wikipedia.org/wiki/UUID#Random_UUID_probability_of_duplicates
+func Uid() string {
+	id := make([]byte, 16)
+	_, err := io.ReadFull(rand.Reader, id)
+	if err != nil {
+		// This is probably an appropriate way to handle errors from our source
+		// for random bits.
+		panic(err)
+	}
+	return hex.EncodeToString(id)
+}

vendor/github.com/busyfree/tusd/pkg/filestore/filestore.go

@@ -0,0 +1,240 @@
+// Package filestore provide a storage backend based on the local file system.
+//
+// FileStore is a storage backend used as a handler.DataStore in handler.NewHandler.
+// It stores the uploads in a directory specified in two different files: The
+// `[id].info` files are used to store the fileinfo in JSON format. The
+// `[id]` files without an extension contain the raw binary data uploaded.
+// No cleanup is performed so you may want to run a cronjob to ensure your disk
+// is not filled up with old and finished uploads.
+package filestore
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+
+	"github.com/busyfree/tusd/internal/uid"
+	"github.com/busyfree/tusd/pkg/handler"
+)
+
+var defaultFilePerm = os.FileMode(0664)
+
+// See the handler.DataStore interface for documentation about the different
+// methods.
+type FileStore struct {
+	// Relative or absolute path to store files in. FileStore does not check
+	// whether the path exists, use os.MkdirAll in this case on your own.
+	Path string
+
+	// modify by sjqzhang
+	GetReaderExt func(id string) (io.Reader, error)
+}
+
+// New creates a new file based storage backend. The directory specified will
+// be used as the only storage entry. This method does not check
+// whether the path exists, use os.MkdirAll to ensure.
+// In addition, a locking mechanism is provided.
+func New(path string) FileStore {
+	store:= FileStore{Path:path}
+	//modify by sjqzhang
+	store.GetReaderExt= func(id string) (io.Reader, error) {
+		return os.Open(store.binPath(id))
+	}
+	return store
+}
+
+// UseIn sets this store as the core data store in the passed composer and adds
+// all possible extension to it.
+func (store FileStore) UseIn(composer *handler.StoreComposer) {
+	composer.UseCore(store)
+	composer.UseTerminater(store)
+	composer.UseConcater(store)
+	composer.UseLengthDeferrer(store)
+}
+
+func (store FileStore) NewUpload(ctx context.Context, info handler.FileInfo) (handler.Upload, error) {
+	id := uid.Uid()
+	binPath := store.binPath(id)
+	info.ID = id
+	info.Storage = map[string]string{
+		"Type": "filestore",
+		"Path": binPath,
+	}
+
+	// Create binary file with no content
+	file, err := os.OpenFile(binPath, os.O_CREATE|os.O_WRONLY, defaultFilePerm)
+	if err != nil {
+		if os.IsNotExist(err) {
+			err = fmt.Errorf("upload directory does not exist: %s", store.Path)
+		}
+		return nil, err
+	}
+	err = file.Close()
+	if err != nil {
+		return nil, err
+	}
+
+	upload := &fileUpload{
+		info:     info,
+		infoPath: store.infoPath(id),
+		binPath:  store.binPath(id),
+	}
+
+	// writeInfo creates the file by itself if necessary
+	err = upload.writeInfo()
+	if err != nil {
+		return nil, err
+	}
+
+	return upload, nil
+}
+
+func (store FileStore) GetUpload(ctx context.Context, id string) (handler.Upload, error) {
+	info := handler.FileInfo{}
+	data, err := ioutil.ReadFile(store.infoPath(id))
+	if err != nil {
+		if os.IsNotExist(err) {
+			// Interpret os.ErrNotExist as 404 Not Found
+			err = handler.ErrNotFound
+		}
+		return nil, err
+	}
+	if err := json.Unmarshal(data, &info); err != nil {
+		return nil, err
+	}
+
+	binPath := store.binPath(id)
+	infoPath := store.infoPath(id)
+	stat, err := os.Stat(binPath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			// Interpret os.ErrNotExist as 404 Not Found
+			err = handler.ErrNotFound
+		}
+		return nil, err
+	}
+
+	info.Offset = stat.Size()
+
+	return &fileUpload{
+		info:     info,
+		binPath:  binPath,
+		infoPath: infoPath,
+	}, nil
+}
+
+func (store FileStore) AsTerminatableUpload(upload handler.Upload) handler.TerminatableUpload {
+	return upload.(*fileUpload)
+}
+
+func (store FileStore) AsLengthDeclarableUpload(upload handler.Upload) handler.LengthDeclarableUpload {
+	return upload.(*fileUpload)
+}
+
+func (store FileStore) AsConcatableUpload(upload handler.Upload) handler.ConcatableUpload {
+	return upload.(*fileUpload)
+}
+
+// binPath returns the path to the file storing the binary data.
+func (store FileStore) binPath(id string) string {
+	return filepath.Join(store.Path, id)
+}
+
+// infoPath returns the path to the .info file storing the file's info.
+func (store FileStore) infoPath(id string) string {
+	return filepath.Join(store.Path, id+".info")
+}
+
+// modify by sjqzhang
+func (store FileStore) GetReader(id string) (io.Reader, error) {
+	if store.GetReaderExt!=nil {
+		return store.GetReaderExt(id)
+	}
+	return os.Open(store.binPath(id))
+}
+
+type fileUpload struct {
+	// info stores the current information about the upload
+	info handler.FileInfo
+	// infoPath is the path to the .info file
+	infoPath string
+	// binPath is the path to the binary file (which has no extension)
+	binPath string
+}
+
+func (upload *fileUpload) GetInfo(ctx context.Context) (handler.FileInfo, error) {
+	return upload.info, nil
+}
+
+func (upload *fileUpload) WriteChunk(ctx context.Context, offset int64, src io.Reader) (int64, error) {
+	file, err := os.OpenFile(upload.binPath, os.O_WRONLY|os.O_APPEND, defaultFilePerm)
+	if err != nil {
+		return 0, err
+	}
+	defer file.Close()
+
+	n, err := io.Copy(file, src)
+
+	upload.info.Offset += n
+	return n, err
+}
+
+func (upload *fileUpload) GetReader(ctx context.Context) (io.Reader, error) {
+	return os.Open(upload.binPath)
+}
+
+func (upload *fileUpload) Terminate(ctx context.Context) error {
+	if err := os.Remove(upload.infoPath); err != nil {
+		return err
+	}
+	if err := os.Remove(upload.binPath); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (upload *fileUpload) ConcatUploads(ctx context.Context, uploads []handler.Upload) (err error) {
+	file, err := os.OpenFile(upload.binPath, os.O_WRONLY|os.O_APPEND, defaultFilePerm)
+	if err != nil {
+		return err
+	}
+	defer file.Close()
+
+	for _, partialUpload := range uploads {
+		fileUpload := partialUpload.(*fileUpload)
+
+		src, err := os.Open(fileUpload.binPath)
+		if err != nil {
+			return err
+		}
+
+		if _, err := io.Copy(file, src); err != nil {
+			return err
+		}
+	}
+
+	return
+}
+
+func (upload *fileUpload) DeclareLength(ctx context.Context, length int64) error {
+	upload.info.Size = length
+	upload.info.SizeIsDeferred = false
+	return upload.writeInfo()
+}
+
+// writeInfo updates the entire information. Everything will be overwritten.
+func (upload *fileUpload) writeInfo() error {
+	data, err := json.Marshal(upload.info)
+	if err != nil {
+		return err
+	}
+	return ioutil.WriteFile(upload.infoPath, data, defaultFilePerm)
+}
+
+func (upload *fileUpload) FinishUpload(ctx context.Context) error {
+	return nil
+}

vendor/github.com/busyfree/tusd/pkg/handler/body_reader.go

@@ -0,0 +1,53 @@
+package handler
+
+import (
+	"io"
+	"sync/atomic"
+)
+
+// bodyReader is an io.Reader, which is intended to wrap the request
+// body reader. If an error occurr during reading the request body, it
+// will not return this error to the reading entity, but instead store
+// the error and close the io.Reader, so that the error can be checked
+// afterwards. This is helpful, so that the stores do not have to handle
+// the error but this can instead be done in the handler.
+// In addition, the bodyReader keeps track of how many bytes were read.
+type bodyReader struct {
+	reader       io.Reader
+	err          error
+	bytesCounter int64
+}
+
+func newBodyReader(r io.Reader) *bodyReader {
+	return &bodyReader{
+		reader: r,
+	}
+}
+
+func (r *bodyReader) Read(b []byte) (int, error) {
+	if r.err != nil {
+		return 0, io.EOF
+	}
+
+	n, err := r.reader.Read(b)
+	atomic.AddInt64(&r.bytesCounter, int64(n))
+	r.err = err
+
+	if err == io.EOF {
+		return n, io.EOF
+	} else {
+		return n, nil
+	}
+}
+
+func (r bodyReader) hasError() error {
+	if r.err == io.EOF {
+		return nil
+	}
+
+	return r.err
+}
+
+func (r *bodyReader) bytesRead() int64 {
+	return atomic.LoadInt64(&r.bytesCounter)
+}

vendor/github.com/busyfree/tusd/pkg/handler/composer.go

@@ -0,0 +1,87 @@
+package handler
+
+// StoreComposer represents a composable data store. It consists of the core
+// data store and optional extensions. Please consult the package's overview
+// for a more detailed introduction in how to use this structure.
+type StoreComposer struct {
+	Core DataStore
+
+	UsesTerminater     bool
+	Terminater         TerminaterDataStore
+	UsesLocker         bool
+	Locker             Locker
+	UsesConcater       bool
+	Concater           ConcaterDataStore
+	UsesLengthDeferrer bool
+	LengthDeferrer     LengthDeferrerDataStore
+}
+
+// NewStoreComposer creates a new and empty store composer.
+func NewStoreComposer() *StoreComposer {
+	return &StoreComposer{}
+}
+
+// Capabilities returns a string representing the provided extensions in a
+// human-readable format meant for debugging.
+func (store *StoreComposer) Capabilities() string {
+	str := "Core: "
+
+	if store.Core != nil {
+		str += "✓"
+	} else {
+		str += "✗"
+	}
+
+	str += ` Terminater: `
+	if store.UsesTerminater {
+		str += "✓"
+	} else {
+		str += "✗"
+	}
+	str += ` Locker: `
+	if store.UsesLocker {
+		str += "✓"
+	} else {
+		str += "✗"
+	}
+	str += ` Concater: `
+	if store.UsesConcater {
+		str += "✓"
+	} else {
+		str += "✗"
+	}
+	str += ` LengthDeferrer: `
+	if store.UsesLengthDeferrer {
+		str += "✓"
+	} else {
+		str += "✗"
+	}
+
+	return str
+}
+
+// UseCore will set the used core data store. If the argument is nil, the
+// property will be unset.
+func (store *StoreComposer) UseCore(core DataStore) {
+	store.Core = core
+}
+
+func (store *StoreComposer) UseTerminater(ext TerminaterDataStore) {
+	store.UsesTerminater = ext != nil
+	store.Terminater = ext
+}
+
+func (store *StoreComposer) UseLocker(ext Locker) {
+	store.UsesLocker = ext != nil
+	store.Locker = ext
+}
+
+func (store *StoreComposer) UseConcater(ext ConcaterDataStore) {
+	store.UsesConcater = ext != nil
+	store.Concater = ext
+}
+
+func (store *StoreComposer) UseLengthDeferrer(ext LengthDeferrerDataStore) {
+	store.UsesLengthDeferrer = ext != nil
+	store.LengthDeferrer = ext
+}

vendor/github.com/busyfree/tusd/pkg/handler/composer.mgo

@@ -0,0 +1,74 @@
+package handler
+
+#define USE_FUNC(TYPE) \
+func (store *StoreComposer) Use ## TYPE(ext TYPE ## DataStore) { \
+  store.Uses ## TYPE = ext != nil; \
+  store.TYPE = ext; \
+}
+
+#define USE_FIELD(TYPE) Uses ## TYPE bool; \
+  TYPE TYPE ## DataStore
+
+#define USE_FROM(TYPE) if mod, ok := store.(TYPE ## DataStore); ok { \
+  composer.Use ## TYPE (mod) \
+}
+
+#define USE_CAP(TYPE) str += ` TYPE: `; \
+if store.Uses ## TYPE { \
+  str += "✓" \
+} else { \
+  str += "✗" \
+}
+
+// StoreComposer represents a composable data store. It consists of the core
+// data store and optional extensions. Please consult the package's overview
+// for a more detailed introduction in how to use this structure.
+type StoreComposer struct {
+  Core DataStore
+
+  USE_FIELD(Terminater)
+  USE_FIELD(Finisher)
+  USE_FIELD(Locker)
+  USE_FIELD(GetReader)
+  USE_FIELD(Concater)
+  USE_FIELD(LengthDeferrer)
+}
+
+// NewStoreComposer creates a new and empty store composer.
+func NewStoreComposer() *StoreComposer {
+  return &StoreComposer{}
+}
+
+// Capabilities returns a string representing the provided extensions in a
+// human-readable format meant for debugging.
+func (store *StoreComposer) Capabilities() string {
+  str := "Core: "
+
+  if store.Core != nil {
+    str += "✓"
+  } else {
+    str += "✗"
+  }
+
+  USE_CAP(Terminater)
+  USE_CAP(Finisher)
+  USE_CAP(Locker)
+  USE_CAP(GetReader)
+  USE_CAP(Concater)
+  USE_CAP(LengthDeferrer)
+
+  return str
+}
+
+// UseCore will set the used core data store. If the argument is nil, the
+// property will be unset.
+func (store *StoreComposer) UseCore(core DataStore) {
+  store.Core = core
+}
+
+USE_FUNC(Terminater)
+USE_FUNC(Finisher)
+USE_FUNC(Locker)
+USE_FUNC(GetReader)
+USE_FUNC(Concater)
+USE_FUNC(LengthDeferrer)

vendor/github.com/busyfree/tusd/pkg/handler/config.go

@@ -0,0 +1,86 @@
+package handler
+
+import (
+	"errors"
+	"log"
+	"net/url"
+	"os"
+)
+
+// Config provides a way to configure the Handler depending on your needs.
+type Config struct {
+	// StoreComposer points to the store composer from which the core data store
+	// and optional dependencies should be taken. May only be nil if DataStore is
+	// set.
+	// TODO: Remove pointer?
+	StoreComposer *StoreComposer
+	// MaxSize defines how many bytes may be stored in one single upload. If its
+	// value is is 0 or smaller no limit will be enforced.
+	MaxSize int64
+	// BasePath defines the URL path used for handling uploads, e.g. "/files/".
+	// If no trailing slash is presented it will be added. You may specify an
+	// absolute URL containing a scheme, e.g. "http://tus.io"
+	BasePath string
+	isAbs    bool
+	// NotifyCompleteUploads indicates whether sending notifications about
+	// completed uploads using the CompleteUploads channel should be enabled.
+	NotifyCompleteUploads bool
+	// NotifyTerminatedUploads indicates whether sending notifications about
+	// terminated uploads using the TerminatedUploads channel should be enabled.
+	NotifyTerminatedUploads bool
+	// NotifyUploadProgress indicates whether sending notifications about
+	// the upload progress using the UploadProgress channel should be enabled.
+	NotifyUploadProgress bool
+	// NotifyCreatedUploads indicates whether sending notifications about
+	// the upload having been created using the CreatedUploads channel should be enabled.
+	NotifyCreatedUploads bool
+	// Logger is the logger to use internally, mostly for printing requests.
+	Logger *log.Logger
+	// Respect the X-Forwarded-Host, X-Forwarded-Proto and Forwarded headers
+	// potentially set by proxies when generating an absolute URL in the
+	// response to POST requests.
+	RespectForwardedHeaders bool
+	// PreUploadCreateCallback will be invoked before a new upload is created, if the
+	// property is supplied. If the callback returns nil, the upload will be created.
+	// Otherwise the HTTP request will be aborted. This can be used to implement
+	// validation of upload metadata etc.
+	PreUploadCreateCallback func(hook HookEvent) error
+	// PreFinishResponseCallback will be invoked after an upload is completed but before
+	// a response is returned to the client. Error responses from the callback will be passed
+	// back to the client. This can be used to implement post-processing validation.
+	PreFinishResponseCallback func(hook HookEvent) error
+}
+
+func (config *Config) validate() error {
+	if config.Logger == nil {
+		config.Logger = log.New(os.Stdout, "[tusd] ", log.Ldate|log.Ltime)
+	}
+
+	base := config.BasePath
+	uri, err := url.Parse(base)
+	if err != nil {
+		return err
+	}
+
+	// Ensure base path ends with slash to remove logic from absFileURL
+	if base != "" && string(base[len(base)-1]) != "/" {
+		base += "/"
+	}
+
+	// Ensure base path begins with slash if not absolute (starts with scheme)
+	if !uri.IsAbs() && len(base) > 0 && string(base[0]) != "/" {
+		base = "/" + base
+	}
+	config.BasePath = base
+	config.isAbs = uri.IsAbs()
+
+	if config.StoreComposer == nil {
+		return errors.New("tusd: StoreComposer must no be nil")
+	}
+
+	if config.StoreComposer.Core == nil {
+		return errors.New("tusd: StoreComposer in Config needs to contain a non-nil core")
+	}
+
+	return nil
+}

vendor/github.com/busyfree/tusd/pkg/handler/datastore.go

@@ -0,0 +1,156 @@
+package handler
+
+import (
+	"context"
+	"io"
+)
+
+type MetaData map[string]string
+
+type FileInfo struct {
+	ID string
+	// Total file size in bytes specified in the NewUpload call
+	Size int64
+	// Indicates whether the total file size is deferred until later
+	SizeIsDeferred bool
+	// Offset in bytes (zero-based)
+	Offset   int64
+	MetaData MetaData
+	// Indicates that this is a partial upload which will later be used to form
+	// a final upload by concatenation. Partial uploads should not be processed
+	// when they are finished since they are only incomplete chunks of files.
+	IsPartial bool
+	// Indicates that this is a final upload
+	IsFinal bool
+	// If the upload is a final one (see IsFinal) this will be a non-empty
+	// ordered slice containing the ids of the uploads of which the final upload
+	// will consist after concatenation.
+	PartialUploads []string
+	// Storage contains information about where the data storage saves the upload,
+	// for example a file path. The available values vary depending on what data
+	// store is used. This map may also be nil.
+	Storage map[string]string
+
+	// stopUpload is the cancel function for the upload's context.Context. When
+	// invoked it will interrupt the writes to DataStore#WriteChunk.
+	stopUpload context.CancelFunc
+}
+
+// StopUpload interrupts an running upload from the server-side. This means that
+// the current request body is closed, so that the data store does not get any
+// more data. Furthermore, a response is sent to notify the client of the
+// interrupting and the upload is terminated (if supported by the data store),
+// so the upload cannot be resumed anymore.
+func (f FileInfo) StopUpload() {
+	if f.stopUpload != nil {
+		f.stopUpload()
+	}
+}
+
+type Upload interface {
+	// Write the chunk read from src into the file specified by the id at the
+	// given offset. The handler will take care of validating the offset and
+	// limiting the size of the src to not overflow the file's size. It may
+	// return an os.ErrNotExist which will be interpreted as a 404 Not Found.
+	// It will also lock resources while they are written to ensure only one
+	// write happens per time.
+	// The function call must return the number of bytes written.
+	WriteChunk(ctx context.Context, offset int64, src io.Reader) (int64, error)
+	// Read the fileinformation used to validate the offset and respond to HEAD
+	// requests. It may return an os.ErrNotExist which will be interpreted as a
+	// 404 Not Found.
+	GetInfo(ctx context.Context) (FileInfo, error)
+	// GetReader returns a reader which allows iterating of the content of an
+	// upload specified by its ID. It should attempt to provide a reader even if
+	// the upload has not been finished yet but it's not required.
+	// If the returned reader also implements the io.Closer interface, the
+	// Close() method will be invoked once everything has been read.
+	// If the given upload could not be found, the error tusd.ErrNotFound should
+	// be returned.
+	GetReader(ctx context.Context) (io.Reader, error)
+	// FinisherDataStore is the interface which can be implemented by DataStores
+	// which need to do additional operations once an entire upload has been
+	// completed. These tasks may include but are not limited to freeing unused
+	// resources or notifying other services. For example, S3Store uses this
+	// interface for removing a temporary object.
+	// FinishUpload executes additional operations for the finished upload which
+	// is specified by its ID.
+	FinishUpload(ctx context.Context) error
+}
+
+type DataStore interface {
+	// Create a new upload using the size as the file's length. The method must
+	// return an unique id which is used to identify the upload. If no backend
+	// (e.g. Riak) specifes the id you may want to use the uid package to
+	// generate one. The properties Size and MetaData will be filled.
+	NewUpload(ctx context.Context, info FileInfo) (upload Upload, err error)
+
+	GetUpload(ctx context.Context, id string) (upload Upload, err error)
+}
+
+type TerminatableUpload interface {
+	// Terminate an upload so any further requests to the resource, both reading
+	// and writing, must return os.ErrNotExist or similar.
+	Terminate(ctx context.Context) error
+}
+
+// TerminaterDataStore is the interface which must be implemented by DataStores
+// if they want to receive DELETE requests using the Handler. If this interface
+// is not implemented, no request handler for this method is attached.
+type TerminaterDataStore interface {
+	AsTerminatableUpload(upload Upload) TerminatableUpload
+}
+
+// ConcaterDataStore is the interface required to be implemented if the
+// Concatenation extension should be enabled. Only in this case, the handler
+// will parse and respect the Upload-Concat header.
+type ConcaterDataStore interface {
+	AsConcatableUpload(upload Upload) ConcatableUpload
+}
+
+type ConcatableUpload interface {
+	// ConcatUploads concatenates the content from the provided partial uploads
+	// and writes the result in the destination upload.
+	// The caller (usually the handler) must and will ensure that this
+	// destination upload has been created before with enough space to hold all
+	// partial uploads. The order, in which the partial uploads are supplied,
+	// must be respected during concatenation.
+	ConcatUploads(ctx context.Context, partialUploads []Upload) error
+}
+
+// LengthDeferrerDataStore is the interface that must be implemented if the
+// creation-defer-length extension should be enabled. The extension enables a
+// client to upload files when their total size is not yet known. Instead, the
+// client must send the total size as soon as it becomes known.
+type LengthDeferrerDataStore interface {
+	AsLengthDeclarableUpload(upload Upload) LengthDeclarableUpload
+}
+
+type LengthDeclarableUpload interface {
+	DeclareLength(ctx context.Context, length int64) error
+}
+
+// Locker is the interface required for custom lock persisting mechanisms.
+// Common ways to store this information is in memory, on disk or using an
+// external service, such as Redis.
+// When multiple processes are attempting to access an upload, whether it be
+// by reading or writing, a synchronization mechanism is required to prevent
+// data corruption, especially to ensure correct offset values and the proper
+// order of chunks inside a single upload.
+type Locker interface {
+	// NewLock creates a new unlocked lock object for the given upload ID.
+	NewLock(id string) (Lock, error)
+}
+
+// Lock is the interface for a lock as returned from a Locker.
+type Lock interface {
+	// Lock attempts to obtain an exclusive lock for the upload specified
+	// by its id.
+	// If this operation fails because the resource is already locked, the
+	// tusd.ErrFileLocked must be returned. If no error is returned, the attempt
+	// is consider to be successful and the upload to be locked until UnlockUpload
+	// is invoked for the same upload.
+	Lock() error
+	// Unlock releases an existing lock for the given upload.
+	Unlock() error
+}

vendor/github.com/busyfree/tusd/pkg/handler/doc.go

@@ -0,0 +1,69 @@
+/*
+Package handler provides ways to accept tus 1.0 calls using HTTP.
+
+tus is a protocol based on HTTP for resumable file uploads. Resumable means that
+an upload can be interrupted at any moment and can be resumed without
+re-uploading the previous data again. An interruption may happen willingly, if
+the user wants to pause, or by accident in case of an network issue or server
+outage (http://tus.io).
+
+The basics of tusd
+
+tusd was designed in way which allows an flexible and customizable usage. We
+wanted to avoid binding this package to a specific storage system – particularly
+a proprietary third-party software. Therefore tusd is an abstract layer whose
+only job is to accept incoming HTTP requests, validate them according to the
+specification and finally passes them to the data store.
+
+The data store is another important component in tusd's architecture whose
+purpose is to do the actual file handling. It has to write the incoming upload
+to a persistent storage system and retrieve information about an upload's
+current state. Therefore it is the only part of the system which communicates
+directly with the underlying storage system, whether it be the local disk, a
+remote FTP server or cloud providers such as AWS S3.
+
+Using a store composer
+
+The only hard requirements for a data store can be found in the DataStore
+interface. It contains methods for creating uploads (NewUpload), writing to
+them (WriteChunk) and retrieving their status (GetInfo). However, there
+are many more features which are not mandatory but may still be used.
+These are contained in their own interfaces which all share the *DataStore
+suffix. For example, GetReaderDataStore which enables downloading uploads or
+TerminaterDataStore which allows uploads to be terminated.
+
+The store composer offers a way to combine the basic data store - the core -
+implementation and these additional extensions:
+
+  composer := tusd.NewStoreComposer()
+  composer.UseCore(dataStore) // Implements DataStore
+  composer.UseTerminater(terminater) // Implements TerminaterDataStore
+  composer.UseLocker(locker) // Implements LockerDataStore
+
+The corresponding methods for adding an extension to the composer are prefixed
+with Use* followed by the name of the corresponding interface. However, most
+data store provide multiple extensions and adding all of them manually can be
+tedious and error-prone. Therefore, all data store distributed with tusd provide
+an UseIn() method which does this job automatically. For example, this is the
+S3 store in action (see S3Store.UseIn):
+
+  store := s3store.New(…)
+  locker := memorylocker.New()
+  composer := tusd.NewStoreComposer()
+  store.UseIn(composer)
+  locker.UseIn(composer)
+
+Finally, once you are done with composing your data store, you can pass it
+inside the Config struct in order to create create a new tusd HTTP handler:
+
+  config := tusd.Config{
+    StoreComposer: composer,
+    BasePath: "/files/",
+  }
+  handler, err := tusd.NewHandler(config)
+
+This handler can then be mounted to a specific path, e.g. /files:
+
+  http.Handle("/files/", http.StripPrefix("/files/", handler))
+*/
+package handler

vendor/github.com/busyfree/tusd/pkg/handler/handler.go

@@ -0,0 +1,51 @@
+package handler
+
+import (
+	"net/http"
+
+	"github.com/bmizerany/pat"
+)
+
+// Handler is a ready to use handler with routing (using pat)
+type Handler struct {
+	*UnroutedHandler
+	http.Handler
+}
+
+// NewHandler creates a routed tus protocol handler. This is the simplest
+// way to use tusd but may not be as configurable as you require. If you are
+// integrating this into an existing app you may like to use tusd.NewUnroutedHandler
+// instead. Using tusd.NewUnroutedHandler allows the tus handlers to be combined into
+// your existing router (aka mux) directly. It also allows the GET and DELETE
+// endpoints to be customized. These are not part of the protocol so can be
+// changed depending on your needs.
+func NewHandler(config Config) (*Handler, error) {
+	if err := config.validate(); err != nil {
+		return nil, err
+	}
+
+	handler, err := NewUnroutedHandler(config)
+	if err != nil {
+		return nil, err
+	}
+
+	routedHandler := &Handler{
+		UnroutedHandler: handler,
+	}
+
+	mux := pat.New()
+
+	routedHandler.Handler = handler.Middleware(mux)
+
+	mux.Post("", http.HandlerFunc(handler.PostFile))
+	mux.Head(":id", http.HandlerFunc(handler.HeadFile))
+	mux.Add("PATCH", ":id", http.HandlerFunc(handler.PatchFile))
+	mux.Get(":id", http.HandlerFunc(handler.GetFile))
+
+	// Only attach the DELETE handler if the Terminate() method is provided
+	if config.StoreComposer.UsesTerminater {
+		mux.Del(":id", http.HandlerFunc(handler.DelFile))
+	}
+
+	return routedHandler, nil
+}

vendor/github.com/busyfree/tusd/pkg/handler/log.go

@@ -0,0 +1,27 @@
+package handler
+
+import (
+	"log"
+)
+
+func (h *UnroutedHandler) log(eventName string, details ...string) {
+	LogEvent(h.logger, eventName, details...)
+}
+
+func LogEvent(logger *log.Logger, eventName string, details ...string) {
+	result := make([]byte, 0, 100)
+
+	result = append(result, `event="`...)
+	result = append(result, eventName...)
+	result = append(result, `" `...)
+
+	for i := 0; i < len(details); i += 2 {
+		result = append(result, details[i]...)
+		result = append(result, `="`...)
+		result = append(result, details[i+1]...)
+		result = append(result, `" `...)
+	}
+
+	result = append(result, "\n"...)
+	logger.Output(2, string(result))
+}

vendor/github.com/busyfree/tusd/pkg/handler/metrics.go

@@ -0,0 +1,137 @@
+package handler
+
+import (
+	"errors"
+	"sync"
+	"sync/atomic"
+)
+
+// Metrics provides numbers about the usage of the tusd handler. Since these may
+// be accessed from multiple goroutines, it is necessary to read and modify them
+// atomically using the functions exposed in the sync/atomic package, such as
+// atomic.LoadUint64. In addition the maps must not be modified to prevent data
+// races.
+type Metrics struct {
+	// RequestTotal counts the number of incoming requests per method
+	RequestsTotal map[string]*uint64
+	// ErrorsTotal counts the number of returned errors by their message
+	ErrorsTotal       *ErrorsTotalMap
+	BytesReceived     *uint64
+	UploadsFinished   *uint64
+	UploadsCreated    *uint64
+	UploadsTerminated *uint64
+}
+
+// incRequestsTotal increases the counter for this request method atomically by
+// one. The method must be one of GET, HEAD, POST, PATCH, DELETE.
+func (m Metrics) incRequestsTotal(method string) {
+	if ptr, ok := m.RequestsTotal[method]; ok {
+		atomic.AddUint64(ptr, 1)
+	}
+}
+
+// incErrorsTotal increases the counter for this error atomically by one.
+func (m Metrics) incErrorsTotal(err HTTPError) {
+	ptr := m.ErrorsTotal.retrievePointerFor(err)
+	atomic.AddUint64(ptr, 1)
+}
+
+// incBytesReceived increases the number of received bytes atomically be the
+// specified number.
+func (m Metrics) incBytesReceived(delta uint64) {
+	atomic.AddUint64(m.BytesReceived, delta)
+}
+
+// incUploadsFinished increases the counter for finished uploads atomically by one.
+func (m Metrics) incUploadsFinished() {
+	atomic.AddUint64(m.UploadsFinished, 1)
+}
+
+// incUploadsCreated increases the counter for completed uploads atomically by one.
+func (m Metrics) incUploadsCreated() {
+	atomic.AddUint64(m.UploadsCreated, 1)
+}
+
+// incUploadsTerminated increases the counter for completed uploads atomically by one.
+func (m Metrics) incUploadsTerminated() {
+	atomic.AddUint64(m.UploadsTerminated, 1)
+}
+
+func newMetrics() Metrics {
+	return Metrics{
+		RequestsTotal: map[string]*uint64{
+			"GET":     new(uint64),
+			"HEAD":    new(uint64),
+			"POST":    new(uint64),
+			"PATCH":   new(uint64),
+			"DELETE":  new(uint64),
+			"OPTIONS": new(uint64),
+		},
+		ErrorsTotal:       newErrorsTotalMap(),
+		BytesReceived:     new(uint64),
+		UploadsFinished:   new(uint64),
+		UploadsCreated:    new(uint64),
+		UploadsTerminated: new(uint64),
+	}
+}
+
+// ErrorsTotalMap stores the counters for the different HTTP errors.
+type ErrorsTotalMap struct {
+	lock    sync.RWMutex
+	counter map[simpleHTTPError]*uint64
+}
+
+type simpleHTTPError struct {
+	Message    string
+	StatusCode int
+}
+
+func simplifyHTTPError(err HTTPError) simpleHTTPError {
+	return simpleHTTPError{
+		Message:    err.Error(),
+		StatusCode: err.StatusCode(),
+	}
+}
+
+func newErrorsTotalMap() *ErrorsTotalMap {
+	m := make(map[simpleHTTPError]*uint64, 20)
+	return &ErrorsTotalMap{
+		counter: m,
+	}
+}
+
+// retrievePointerFor returns (after creating it if necessary) the pointer to
+// the counter for the error.
+func (e *ErrorsTotalMap) retrievePointerFor(err HTTPError) *uint64 {
+	serr := simplifyHTTPError(err)
+	e.lock.RLock()
+	ptr, ok := e.counter[serr]
+	e.lock.RUnlock()
+	if ok {
+		return ptr
+	}
+
+	// For pointer creation, a write-lock is required
+	e.lock.Lock()
+	// We ensure that the pointer wasn't created in the meantime
+	if ptr, ok = e.counter[serr]; !ok {
+		ptr = new(uint64)
+		e.counter[serr] = ptr
+	}
+	e.lock.Unlock()
+
+	return ptr
+}
+
+// Load retrieves the map of the counter pointers atomically
+func (e *ErrorsTotalMap) Load() map[HTTPError]*uint64 {
+	m := make(map[HTTPError]*uint64, len(e.counter))
+	e.lock.RLock()
+	for err, ptr := range e.counter {
+		httpErr := NewHTTPError(errors.New(err.Message), err.StatusCode)
+		m[httpErr] = ptr
+	}
+	e.lock.RUnlock()
+
+	return m
+}

vendor/github.com/cihub/seelog/LICENSE.txt

@@ -0,0 +1,24 @@
+Copyright (c) 2012, Cloud Instruments Co., Ltd. <info@cin.io>
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+    * Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+    * Neither the name of the Cloud Instruments Co., Ltd. nor the
+      names of its contributors may be used to endorse or promote products
+      derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
+DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

vendor/github.com/cihub/seelog/archive/archive.go

@@ -0,0 +1,198 @@
+package archive
+
+import (
+	"archive/tar"
+	"archive/zip"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"os"
+	"time"
+
+	"github.com/cihub/seelog/archive/gzip"
+)
+
+// Reader is the interface for reading files from an archive.
+type Reader interface {
+	NextFile() (name string, err error)
+	io.Reader
+}
+
+// ReadCloser is the interface that groups Reader with the Close method.
+type ReadCloser interface {
+	Reader
+	io.Closer
+}
+
+// Writer is the interface for writing files to an archived format.
+type Writer interface {
+	NextFile(name string, fi os.FileInfo) error
+	io.Writer
+}
+
+// WriteCloser is the interface that groups Writer with the Close method.
+type WriteCloser interface {
+	Writer
+	io.Closer
+}
+
+type nopCloser struct{ Reader }
+
+func (nopCloser) Close() error { return nil }
+
+// NopCloser returns a ReadCloser with a no-op Close method wrapping the
+// provided Reader r.
+func NopCloser(r Reader) ReadCloser {
+	return nopCloser{r}
+}
+
+// Copy copies from src to dest until either EOF is reached on src or an error
+// occurs.
+//
+// When the archive format of src matches that of dst, Copy streams the files
+// directly into dst. Otherwise, copy buffers the contents to disk to compute
+// headers before writing to dst.
+func Copy(dst Writer, src Reader) error {
+	switch src := src.(type) {
+	case tarReader:
+		if dst, ok := dst.(tarWriter); ok {
+			return copyTar(dst, src)
+		}
+	case zipReader:
+		if dst, ok := dst.(zipWriter); ok {
+			return copyZip(dst, src)
+		}
+	// Switch on concrete type because gzip has no special methods
+	case *gzip.Reader:
+		if dst, ok := dst.(*gzip.Writer); ok {
+			_, err := io.Copy(dst, src)
+			return err
+		}
+	}
+
+	return copyBuffer(dst, src)
+}
+
+func copyBuffer(dst Writer, src Reader) (err error) {
+	const defaultFileMode = 0666
+
+	buf, err := ioutil.TempFile("", "archive_copy_buffer")
+	if err != nil {
+		return err
+	}
+	defer os.Remove(buf.Name()) // Do not care about failure removing temp
+	defer buf.Close()           // Do not care about failure closing temp
+	for {
+		// Handle the next file
+		name, err := src.NextFile()
+		switch err {
+		case io.EOF: // Done copying
+			return nil
+		default: // Failed to write: bail out
+			return err
+		case nil: // Proceed below
+		}
+
+		// Buffer the file
+		if _, err := io.Copy(buf, src); err != nil {
+			return fmt.Errorf("buffer to disk: %v", err)
+		}
+
+		// Seek to the start of the file for full file copy
+		if _, err := buf.Seek(0, os.SEEK_SET); err != nil {
+			return err
+		}
+
+		// Set desired file permissions
+		if err := os.Chmod(buf.Name(), defaultFileMode); err != nil {
+			return err
+		}
+		fi, err := buf.Stat()
+		if err != nil {
+			return err
+		}
+
+		// Write the buffered file
+		if err := dst.NextFile(name, fi); err != nil {
+			return err
+		}
+		if _, err := io.Copy(dst, buf); err != nil {
+			return fmt.Errorf("copy to dst: %v", err)
+		}
+		if err := buf.Truncate(0); err != nil {
+			return err
+		}
+		if _, err := buf.Seek(0, os.SEEK_SET); err != nil {
+			return err
+		}
+	}
+}
+
+type tarReader interface {
+	Next() (*tar.Header, error)
+	io.Reader
+}
+
+type tarWriter interface {
+	WriteHeader(hdr *tar.Header) error
+	io.Writer
+}
+
+type zipReader interface {
+	Files() []*zip.File
+}
+
+type zipWriter interface {
+	CreateHeader(fh *zip.FileHeader) (io.Writer, error)
+}
+
+func copyTar(w tarWriter, r tarReader) error {
+	for {
+		hdr, err := r.Next()
+		switch err {
+		case io.EOF:
+			return nil
+		default: // Handle error
+			return err
+		case nil: // Proceed below
+		}
+
+		info := hdr.FileInfo()
+		// Skip directories
+		if info.IsDir() {
+			continue
+		}
+		if err := w.WriteHeader(hdr); err != nil {
+			return err
+		}
+		if _, err := io.Copy(w, r); err != nil {
+			return err
+		}
+	}
+}
+
+func copyZip(zw zipWriter, r zipReader) error {
+	for _, f := range r.Files() {
+		if err := copyZipFile(zw, f); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func copyZipFile(zw zipWriter, f *zip.File) error {
+	rc, err := f.Open()
+	if err != nil {
+		return err
+	}
+	defer rc.Close() // Read-only
+
+	hdr := f.FileHeader
+	hdr.SetModTime(time.Now())
+	w, err := zw.CreateHeader(&hdr)
+	if err != nil {
+		return err
+	}
+	_, err = io.Copy(w, rc)
+	return err
+}

vendor/github.com/cihub/seelog/archive/gzip/gzip.go

@@ -0,0 +1,64 @@
+// Package gzip implements reading and writing of gzip format compressed files.
+// See the compress/gzip package for more details.
+package gzip
+
+import (
+	"compress/gzip"
+	"fmt"
+	"io"
+	"os"
+)
+
+// Reader is an io.Reader that can be read to retrieve uncompressed data from a
+// gzip-format compressed file.
+type Reader struct {
+	gzip.Reader
+	name  string
+	isEOF bool
+}
+
+// NewReader creates a new Reader reading the given reader.
+func NewReader(r io.Reader, name string) (*Reader, error) {
+	gr, err := gzip.NewReader(r)
+	if err != nil {
+		return nil, err
+	}
+	return &Reader{
+		Reader: *gr,
+		name:   name,
+	}, nil
+}
+
+// NextFile returns the file name. Calls subsequent to the first call will
+// return EOF.
+func (r *Reader) NextFile() (name string, err error) {
+	if r.isEOF {
+		return "", io.EOF
+	}
+
+	r.isEOF = true
+	return r.name, nil
+}
+
+// Writer is an io.WriteCloser. Writes to a Writer are compressed and written to w.
+type Writer struct {
+	gzip.Writer
+	name        string
+	noMoreFiles bool
+}
+
+// NextFile never returns a next file, and should not be called more than once.
+func (w *Writer) NextFile(name string, _ os.FileInfo) error {
+	if w.noMoreFiles {
+		return fmt.Errorf("gzip: only accepts one file: already received %q and now %q", w.name, name)
+	}
+	w.noMoreFiles = true
+	w.name = name
+	return nil
+}
+
+// NewWriter returns a new Writer. Writes to the returned writer are compressed
+// and written to w.
+func NewWriter(w io.Writer) *Writer {
+	return &Writer{Writer: *gzip.NewWriter(w)}
+}

vendor/github.com/cihub/seelog/archive/tar/tar.go

@@ -0,0 +1,72 @@
+package tar
+
+import (
+	"archive/tar"
+	"io"
+	"os"
+)
+
+// Reader provides sequential access to the contents of a tar archive.
+type Reader struct {
+	tar.Reader
+}
+
+// NewReader creates a new Reader reading from r.
+func NewReader(r io.Reader) *Reader {
+	return &Reader{Reader: *tar.NewReader(r)}
+}
+
+// NextFile advances to the next file in the tar archive.
+func (r *Reader) NextFile() (name string, err error) {
+	hdr, err := r.Next()
+	if err != nil {
+		return "", err
+	}
+	return hdr.Name, nil
+}
+
+// Writer provides sequential writing of a tar archive in POSIX.1 format.
+type Writer struct {
+	tar.Writer
+	closers []io.Closer
+}
+
+// NewWriter creates a new Writer writing to w.
+func NewWriter(w io.Writer) *Writer {
+	return &Writer{Writer: *tar.NewWriter(w)}
+}
+
+// NewWriteMultiCloser creates a new Writer writing to w that also closes all
+// closers in order on close.
+func NewWriteMultiCloser(w io.WriteCloser, closers ...io.Closer) *Writer {
+	return &Writer{
+		Writer:  *tar.NewWriter(w),
+		closers: closers,
+	}
+}
+
+// NextFile computes and writes a header and prepares to accept the file's
+// contents.
+func (w *Writer) NextFile(name string, fi os.FileInfo) error {
+	if name == "" {
+		name = fi.Name()
+	}
+	hdr, err := tar.FileInfoHeader(fi, name)
+	if err != nil {
+		return err
+	}
+	hdr.Name = name
+	return w.WriteHeader(hdr)
+}
+
+// Close closes the tar archive and all other closers, flushing any unwritten
+// data to the underlying writer.
+func (w *Writer) Close() error {
+	err := w.Writer.Close()
+	for _, c := range w.closers {
+		if cerr := c.Close(); cerr != nil && err == nil {
+			err = cerr
+		}
+	}
+	return err
+}

vendor/github.com/cihub/seelog/archive/zip/zip.go

@@ -0,0 +1,89 @@
+package zip
+
+import (
+	"archive/zip"
+	"io"
+	"os"
+)
+
+// Reader provides sequential access to the contents of a zip archive.
+type Reader struct {
+	zip.Reader
+	unread []*zip.File
+	rc     io.ReadCloser
+}
+
+// NewReader returns a new Reader reading from r, which is assumed to have the
+// given size in bytes.
+func NewReader(r io.ReaderAt, size int64) (*Reader, error) {
+	zr, err := zip.NewReader(r, size)
+	if err != nil {
+		return nil, err
+	}
+	return &Reader{Reader: *zr}, nil
+}
+
+// NextFile advances to the next file in the zip archive.
+func (r *Reader) NextFile() (name string, err error) {
+	// Initialize unread
+	if r.unread == nil {
+		r.unread = r.Files()[:]
+	}
+
+	// Close previous file
+	if r.rc != nil {
+		r.rc.Close() // Read-only
+	}
+
+	if len(r.unread) == 0 {
+		return "", io.EOF
+	}
+
+	// Open and return next unread
+	f := r.unread[0]
+	name, r.unread = f.Name, r.unread[1:]
+	r.rc, err = f.Open()
+	if err != nil {
+		return "", err
+	}
+	return name, nil
+}
+
+func (r *Reader) Read(p []byte) (n int, err error) {
+	return r.rc.Read(p)
+}
+
+// Files returns the full list of files in the zip archive.
+func (r *Reader) Files() []*zip.File {
+	return r.File
+}
+
+// Writer provides sequential writing of a zip archive.1 format.
+type Writer struct {
+	zip.Writer
+	w io.Writer
+}
+
+// NewWriter returns a new Writer writing to w.
+func NewWriter(w io.Writer) *Writer {
+	return &Writer{Writer: *zip.NewWriter(w)}
+}
+
+// NextFile computes and writes a header and prepares to accept the file's
+// contents.
+func (w *Writer) NextFile(name string, fi os.FileInfo) error {
+	if name == "" {
+		name = fi.Name()
+	}
+	hdr, err := zip.FileInfoHeader(fi)
+	if err != nil {
+		return err
+	}
+	hdr.Name = name
+	w.w, err = w.CreateHeader(hdr)
+	return err
+}
+
+func (w *Writer) Write(p []byte) (n int, err error) {
+	return w.w.Write(p)
+}

vendor/github.com/deckarep/golang-set/.gitignore

@@ -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

vendor/github.com/deckarep/golang-set/.travis.yml

@@ -0,0 +1,11 @@
+language: go
+
+go:
+    - 1.8
+    - 1.9
+    - tip
+
+script:
+    - go test -race ./...
+    - go test -bench=.
+

vendor/github.com/deckarep/golang-set/LICENSE

@@ -0,0 +1,22 @@
+Open Source Initiative OSI - The MIT License (MIT):Licensing
+
+The MIT License (MIT)
+Copyright (c) 2013 Ralph Caraveo (deckarep@gmail.com)
+
+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.

vendor/github.com/deckarep/golang-set/README.md

@@ -0,0 +1,95 @@
+[![Build Status](https://travis-ci.org/deckarep/golang-set.svg?branch=master)](https://travis-ci.org/deckarep/golang-set)
+[![Go Report Card](https://goreportcard.com/badge/github.com/deckarep/golang-set)](https://goreportcard.com/report/github.com/deckarep/golang-set)
+[![GoDoc](https://godoc.org/github.com/deckarep/golang-set?status.svg)](http://godoc.org/github.com/deckarep/golang-set)
+
+## golang-set
+
+
+The missing set collection for the Go language.  Until Go has sets built-in...use this.
+
+Coming from Python one of the things I miss is the superbly wonderful set collection.  This is my attempt to mimic the primary features of the set from Python.
+You can of course argue that there is no need for a set in Go, otherwise the creators would have added one to the standard library.  To those I say simply ignore this repository
+and carry-on and to the rest that find this useful please contribute in helping me make it better by:
+
+* Helping to make more idiomatic improvements to the code.
+* Helping to increase the performance of it. ~~(So far, no attempt has been made, but since it uses a map internally, I expect it to be mostly performant.)~~
+* Helping to make the unit-tests more robust and kick-ass.
+* Helping to fill in the [documentation.](http://godoc.org/github.com/deckarep/golang-set)
+* Simply offering feedback and suggestions.  (Positive, constructive feedback is appreciated.)
+
+I have to give some credit for helping seed the idea with this post on [stackoverflow.](http://programmers.stackexchange.com/questions/177428/sets-data-structure-in-golang)
+
+*Update* - as of 3/9/2014, you can use a compile-time generic version of this package in the [gen](http://clipperhouse.github.io/gen/) framework.  This framework allows you to use the golang-set in a completely generic and type-safe way by allowing you to generate a supporting .go file based on your custom types.
+
+## Features (as of 9/22/2014)
+
+* a CartesianProduct() method has been added with unit-tests: [Read more about the cartesian product](http://en.wikipedia.org/wiki/Cartesian_product)
+
+## Features (as of 9/15/2014)
+
+* a PowerSet() method has been added with unit-tests: [Read more about the Power set](http://en.wikipedia.org/wiki/Power_set)
+
+## Features (as of 4/22/2014)
+
+* One common interface to both implementations
+* Two set implementations to choose from
+  * a thread-safe implementation designed for concurrent use
+  * a non-thread-safe implementation designed for performance
+* 75 benchmarks for both implementations
+* 35 unit tests for both implementations
+* 14 concurrent tests for the thread-safe implementation
+
+
+
+Please see the unit test file for additional usage examples.  The Python set documentation will also do a better job than I can of explaining how a set typically [works.](http://docs.python.org/2/library/sets.html)    Please keep in mind
+however that the Python set is a built-in type and supports additional features and syntax that make it awesome.
+
+## Examples but not exhaustive:
+
+```go
+requiredClasses := mapset.NewSet()
+requiredClasses.Add("Cooking")
+requiredClasses.Add("English")
+requiredClasses.Add("Math")
+requiredClasses.Add("Biology")
+
+scienceSlice := []interface{}{"Biology", "Chemistry"}
+scienceClasses := mapset.NewSetFromSlice(scienceSlice)
+
+electiveClasses := mapset.NewSet()
+electiveClasses.Add("Welding")
+electiveClasses.Add("Music")
+electiveClasses.Add("Automotive")
+
+bonusClasses := mapset.NewSet()
+bonusClasses.Add("Go Programming")
+bonusClasses.Add("Python Programming")
+
+//Show me all the available classes I can take
+allClasses := requiredClasses.Union(scienceClasses).Union(electiveClasses).Union(bonusClasses)
+fmt.Println(allClasses) //Set{Cooking, English, Math, Chemistry, Welding, Biology, Music, Automotive, Go Programming, Python Programming}
+
+
+//Is cooking considered a science class?
+fmt.Println(scienceClasses.Contains("Cooking")) //false
+
+//Show me all classes that are not science classes, since I hate science.
+fmt.Println(allClasses.Difference(scienceClasses)) //Set{Music, Automotive, Go Programming, Python Programming, Cooking, English, Math, Welding}
+
+//Which science classes are also required classes?
+fmt.Println(scienceClasses.Intersect(requiredClasses)) //Set{Biology}
+
+//How many bonus classes do you offer?
+fmt.Println(bonusClasses.Cardinality()) //2
+
+//Do you have the following classes? Welding, Automotive and English?
+fmt.Println(allClasses.IsSuperset(mapset.NewSetFromSlice([]interface{}{"Welding", "Automotive", "English"}))) //true
+```
+
+Thanks!
+
+-Ralph
+
+[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/deckarep/golang-set/trend.png)](https://bitdeli.com/free "Bitdeli Badge")
+
+[![Analytics](https://ga-beacon.appspot.com/UA-42584447-2/deckarep/golang-set)](https://github.com/igrigorik/ga-beacon)

vendor/github.com/deckarep/golang-set/iterator.go

@@ -0,0 +1,58 @@
+/*
+Open Source Initiative OSI - The MIT License (MIT):Licensing
+
+The MIT License (MIT)
+Copyright (c) 2013 Ralph Caraveo (deckarep@gmail.com)
+
+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 mapset
+
+// Iterator defines an iterator over a Set, its C channel can be used to range over the Set's
+// elements.
+type Iterator struct {
+	C    <-chan interface{}
+	stop chan struct{}
+}
+
+// Stop stops the Iterator, no further elements will be received on C, C will be closed.
+func (i *Iterator) Stop() {
+	// Allows for Stop() to be called multiple times
+	// (close() panics when called on already closed channel)
+	defer func() {
+		recover()
+	}()
+
+	close(i.stop)
+
+	// Exhaust any remaining elements.
+	for range i.C {
+	}
+}
+
+// newIterator returns a new Iterator instance together with its item and stop channels.
+func newIterator() (*Iterator, chan<- interface{}, <-chan struct{}) {
+	itemChan := make(chan interface{})
+	stopChan := make(chan struct{})
+	return &Iterator{
+		C:    itemChan,
+		stop: stopChan,
+	}, itemChan, stopChan
+}

vendor/github.com/deckarep/golang-set/set.go

@@ -0,0 +1,217 @@
+/*
+Open Source Initiative OSI - The MIT License (MIT):Licensing
+
+The MIT License (MIT)
+Copyright (c) 2013 Ralph Caraveo (deckarep@gmail.com)
+
+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 mapset implements a simple and generic set collection.
+// Items stored within it are unordered and unique. It supports
+// typical set operations: membership testing, intersection, union,
+// difference, symmetric difference and cloning.
+//
+// Package mapset provides two implementations of the Set
+// interface. The default implementation is safe for concurrent
+// access, but a non-thread-safe implementation is also provided for
+// programs that can benefit from the slight speed improvement and
+// that can enforce mutual exclusion through other means.
+package mapset
+
+// Set is the primary interface provided by the mapset package.  It
+// represents an unordered set of data and a large number of
+// operations that can be applied to that set.
+type Set interface {
+	// Adds an element to the set. Returns whether
+	// the item was added.
+	Add(i interface{}) bool
+
+	// Returns the number of elements in the set.
+	Cardinality() int
+
+	// Removes all elements from the set, leaving
+	// the empty set.
+	Clear()
+
+	// Returns a clone of the set using the same
+	// implementation, duplicating all keys.
+	Clone() Set
+
+	// Returns whether the given items
+	// are all in the set.
+	Contains(i ...interface{}) bool
+
+	// Returns the difference between this set
+	// and other. The returned set will contain
+	// all elements of this set that are not also
+	// elements of other.
+	//
+	// Note that the argument to Difference
+	// must be of the same type as the receiver
+	// of the method. Otherwise, Difference will
+	// panic.
+	Difference(other Set) Set
+
+	// Determines if two sets are equal to each
+	// other. If they have the same cardinality
+	// and contain the same elements, they are
+	// considered equal. The order in which
+	// the elements were added is irrelevant.
+	//
+	// Note that the argument to Equal must be
+	// of the same type as the receiver of the
+	// method. Otherwise, Equal will panic.
+	Equal(other Set) bool
+
+	// Returns a new set containing only the elements
+	// that exist only in both sets.
+	//
+	// Note that the argument to Intersect
+	// must be of the same type as the receiver
+	// of the method. Otherwise, Intersect will
+	// panic.
+	Intersect(other Set) Set
+
+	// Determines if every element in this set is in
+	// the other set but the two sets are not equal.
+	//
+	// Note that the argument to IsProperSubset
+	// must be of the same type as the receiver
+	// of the method. Otherwise, IsProperSubset
+	// will panic.
+	IsProperSubset(other Set) bool
+
+	// Determines if every element in the other set
+	// is in this set but the two sets are not
+	// equal.
+	//
+	// Note that the argument to IsSuperset
+	// must be of the same type as the receiver
+	// of the method. Otherwise, IsSuperset will
+	// panic.
+	IsProperSuperset(other Set) bool
+
+	// Determines if every element in this set is in
+	// the other set.
+	//
+	// Note that the argument to IsSubset
+	// must be of the same type as the receiver
+	// of the method. Otherwise, IsSubset will
+	// panic.
+	IsSubset(other Set) bool
+
+	// Determines if every element in the other set
+	// is in this set.
+	//
+	// Note that the argument to IsSuperset
+	// must be of the same type as the receiver
+	// of the method. Otherwise, IsSuperset will
+	// panic.
+	IsSuperset(other Set) bool
+
+	// Iterates over elements and executes the passed func against each element.
+	// If passed func returns true, stop iteration at the time.
+	Each(func(interface{}) bool)
+
+	// Returns a channel of elements that you can
+	// range over.
+	Iter() <-chan interface{}
+
+	// Returns an Iterator object that you can
+	// use to range over the set.
+	Iterator() *Iterator
+
+	// Remove a single element from the set.
+	Remove(i interface{})
+
+	// Provides a convenient string representation
+	// of the current state of the set.
+	String() string
+
+	// Returns a new set with all elements which are
+	// in either this set or the other set but not in both.
+	//
+	// Note that the argument to SymmetricDifference
+	// must be of the same type as the receiver
+	// of the method. Otherwise, SymmetricDifference
+	// will panic.
+	SymmetricDifference(other Set) Set
+
+	// Returns a new set with all elements in both sets.
+	//
+	// Note that the argument to Union must be of the
+
+	// same type as the receiver of the method.
+	// Otherwise, IsSuperset will panic.
+	Union(other Set) Set
+
+	// Pop removes and returns an arbitrary item from the set.
+	Pop() interface{}
+
+	// Returns all subsets of a given set (Power Set).
+	PowerSet() Set
+
+	// Returns the Cartesian Product of two sets.
+	CartesianProduct(other Set) Set
+
+	// Returns the members of the set as a slice.
+	ToSlice() []interface{}
+}
+
+// NewSet creates and returns a reference to an empty set.  Operations
+// on the resulting set are thread-safe.
+func NewSet(s ...interface{}) Set {
+	set := newThreadSafeSet()
+	for _, item := range s {
+		set.Add(item)
+	}
+	return &set
+}
+
+// NewSetWith creates and returns a new set with the given elements.
+// Operations on the resulting set are thread-safe.
+func NewSetWith(elts ...interface{}) Set {
+	return NewSetFromSlice(elts)
+}
+
+// NewSetFromSlice creates and returns a reference to a set from an
+// existing slice.  Operations on the resulting set are thread-safe.
+func NewSetFromSlice(s []interface{}) Set {
+	a := NewSet(s...)
+	return a
+}
+
+// NewThreadUnsafeSet creates and returns a reference to an empty set.
+// Operations on the resulting set are not thread-safe.
+func NewThreadUnsafeSet() Set {
+	set := newThreadUnsafeSet()
+	return &set
+}
+
+// NewThreadUnsafeSetFromSlice creates and returns a reference to a
+// set from an existing slice.  Operations on the resulting set are
+// not thread-safe.
+func NewThreadUnsafeSetFromSlice(s []interface{}) Set {
+	a := NewThreadUnsafeSet()
+	for _, item := range s {
+		a.Add(item)
+	}
+	return a
+}

vendor/github.com/deckarep/golang-set/threadsafe.go

@@ -0,0 +1,283 @@
+/*
+Open Source Initiative OSI - The MIT License (MIT):Licensing
+
+The MIT License (MIT)
+Copyright (c) 2013 Ralph Caraveo (deckarep@gmail.com)
+
+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 mapset
+
+import "sync"
+
+type threadSafeSet struct {
+	s threadUnsafeSet
+	sync.RWMutex
+}
+
+func newThreadSafeSet() threadSafeSet {
+	return threadSafeSet{s: newThreadUnsafeSet()}
+}
+
+func (set *threadSafeSet) Add(i interface{}) bool {
+	set.Lock()
+	ret := set.s.Add(i)
+	set.Unlock()
+	return ret
+}
+
+func (set *threadSafeSet) Contains(i ...interface{}) bool {
+	set.RLock()
+	ret := set.s.Contains(i...)
+	set.RUnlock()
+	return ret
+}
+
+func (set *threadSafeSet) IsSubset(other Set) bool {
+	o := other.(*threadSafeSet)
+
+	set.RLock()
+	o.RLock()
+
+	ret := set.s.IsSubset(&o.s)
+	set.RUnlock()
+	o.RUnlock()
+	return ret
+}
+
+func (set *threadSafeSet) IsProperSubset(other Set) bool {
+	o := other.(*threadSafeSet)
+
+	set.RLock()
+	defer set.RUnlock()
+	o.RLock()
+	defer o.RUnlock()
+
+	return set.s.IsProperSubset(&o.s)
+}
+
+func (set *threadSafeSet) IsSuperset(other Set) bool {
+	return other.IsSubset(set)
+}
+
+func (set *threadSafeSet) IsProperSuperset(other Set) bool {
+	return other.IsProperSubset(set)
+}
+
+func (set *threadSafeSet) Union(other Set) Set {
+	o := other.(*threadSafeSet)
+
+	set.RLock()
+	o.RLock()
+
+	unsafeUnion := set.s.Union(&o.s).(*threadUnsafeSet)
+	ret := &threadSafeSet{s: *unsafeUnion}
+	set.RUnlock()
+	o.RUnlock()
+	return ret
+}
+
+func (set *threadSafeSet) Intersect(other Set) Set {
+	o := other.(*threadSafeSet)
+
+	set.RLock()
+	o.RLock()
+
+	unsafeIntersection := set.s.Intersect(&o.s).(*threadUnsafeSet)
+	ret := &threadSafeSet{s: *unsafeIntersection}
+	set.RUnlock()
+	o.RUnlock()
+	return ret
+}
+
+func (set *threadSafeSet) Difference(other Set) Set {
+	o := other.(*threadSafeSet)
+
+	set.RLock()
+	o.RLock()
+
+	unsafeDifference := set.s.Difference(&o.s).(*threadUnsafeSet)
+	ret := &threadSafeSet{s: *unsafeDifference}
+	set.RUnlock()
+	o.RUnlock()
+	return ret
+}
+
+func (set *threadSafeSet) SymmetricDifference(other Set) Set {
+	o := other.(*threadSafeSet)
+
+	set.RLock()
+	o.RLock()
+
+	unsafeDifference := set.s.SymmetricDifference(&o.s).(*threadUnsafeSet)
+	ret := &threadSafeSet{s: *unsafeDifference}
+	set.RUnlock()
+	o.RUnlock()
+	return ret
+}
+
+func (set *threadSafeSet) Clear() {
+	set.Lock()
+	set.s = newThreadUnsafeSet()
+	set.Unlock()
+}
+
+func (set *threadSafeSet) Remove(i interface{}) {
+	set.Lock()
+	delete(set.s, i)
+	set.Unlock()
+}
+
+func (set *threadSafeSet) Cardinality() int {
+	set.RLock()
+	defer set.RUnlock()
+	return len(set.s)
+}
+
+func (set *threadSafeSet) Each(cb func(interface{}) bool) {
+	set.RLock()
+	for elem := range set.s {
+		if cb(elem) {
+			break
+		}
+	}
+	set.RUnlock()
+}
+
+func (set *threadSafeSet) Iter() <-chan interface{} {
+	ch := make(chan interface{})
+	go func() {
+		set.RLock()
+
+		for elem := range set.s {
+			ch <- elem
+		}
+		close(ch)
+		set.RUnlock()
+	}()
+
+	return ch
+}
+
+func (set *threadSafeSet) Iterator() *Iterator {
+	iterator, ch, stopCh := newIterator()
+
+	go func() {
+		set.RLock()
+	L:
+		for elem := range set.s {
+			select {
+			case <-stopCh:
+				break L
+			case ch <- elem:
+			}
+		}
+		close(ch)
+		set.RUnlock()
+	}()
+
+	return iterator
+}
+
+func (set *threadSafeSet) Equal(other Set) bool {
+	o := other.(*threadSafeSet)
+
+	set.RLock()
+	o.RLock()
+
+	ret := set.s.Equal(&o.s)
+	set.RUnlock()
+	o.RUnlock()
+	return ret
+}
+
+func (set *threadSafeSet) Clone() Set {
+	set.RLock()
+
+	unsafeClone := set.s.Clone().(*threadUnsafeSet)
+	ret := &threadSafeSet{s: *unsafeClone}
+	set.RUnlock()
+	return ret
+}
+
+func (set *threadSafeSet) String() string {
+	set.RLock()
+	ret := set.s.String()
+	set.RUnlock()
+	return ret
+}
+
+func (set *threadSafeSet) PowerSet() Set {
+	set.RLock()
+	unsafePowerSet := set.s.PowerSet().(*threadUnsafeSet)
+	set.RUnlock()
+
+	ret := &threadSafeSet{s: newThreadUnsafeSet()}
+	for subset := range unsafePowerSet.Iter() {
+		unsafeSubset := subset.(*threadUnsafeSet)
+		ret.Add(&threadSafeSet{s: *unsafeSubset})
+	}
+	return ret
+}
+
+func (set *threadSafeSet) Pop() interface{} {
+	set.Lock()
+	defer set.Unlock()
+	return set.s.Pop()
+}
+
+func (set *threadSafeSet) CartesianProduct(other Set) Set {
+	o := other.(*threadSafeSet)
+
+	set.RLock()
+	o.RLock()
+
+	unsafeCartProduct := set.s.CartesianProduct(&o.s).(*threadUnsafeSet)
+	ret := &threadSafeSet{s: *unsafeCartProduct}
+	set.RUnlock()
+	o.RUnlock()
+	return ret
+}
+
+func (set *threadSafeSet) ToSlice() []interface{} {
+	keys := make([]interface{}, 0, set.Cardinality())
+	set.RLock()
+	for elem := range set.s {
+		keys = append(keys, elem)
+	}
+	set.RUnlock()
+	return keys
+}
+
+func (set *threadSafeSet) MarshalJSON() ([]byte, error) {
+	set.RLock()
+	b, err := set.s.MarshalJSON()
+	set.RUnlock()
+
+	return b, err
+}
+
+func (set *threadSafeSet) UnmarshalJSON(p []byte) error {
+	set.RLock()
+	err := set.s.UnmarshalJSON(p)
+	set.RUnlock()
+
+	return err
+}

vendor/github.com/deckarep/golang-set/threadunsafe.go

@@ -0,0 +1,337 @@
+/*
+Open Source Initiative OSI - The MIT License (MIT):Licensing
+
+The MIT License (MIT)
+Copyright (c) 2013 Ralph Caraveo (deckarep@gmail.com)
+
+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 mapset
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"reflect"
+	"strings"
+)
+
+type threadUnsafeSet map[interface{}]struct{}
+
+// An OrderedPair represents a 2-tuple of values.
+type OrderedPair struct {
+	First  interface{}
+	Second interface{}
+}
+
+func newThreadUnsafeSet() threadUnsafeSet {
+	return make(threadUnsafeSet)
+}
+
+// Equal says whether two 2-tuples contain the same values in the same order.
+func (pair *OrderedPair) Equal(other OrderedPair) bool {
+	if pair.First == other.First &&
+		pair.Second == other.Second {
+		return true
+	}
+
+	return false
+}
+
+func (set *threadUnsafeSet) Add(i interface{}) bool {
+	_, found := (*set)[i]
+	if found {
+		return false //False if it existed already
+	}
+
+	(*set)[i] = struct{}{}
+	return true
+}
+
+func (set *threadUnsafeSet) Contains(i ...interface{}) bool {
+	for _, val := range i {
+		if _, ok := (*set)[val]; !ok {
+			return false
+		}
+	}
+	return true
+}
+
+func (set *threadUnsafeSet) IsSubset(other Set) bool {
+	_ = other.(*threadUnsafeSet)
+	for elem := range *set {
+		if !other.Contains(elem) {
+			return false
+		}
+	}
+	return true
+}
+
+func (set *threadUnsafeSet) IsProperSubset(other Set) bool {
+	return set.IsSubset(other) && !set.Equal(other)
+}
+
+func (set *threadUnsafeSet) IsSuperset(other Set) bool {
+	return other.IsSubset(set)
+}
+
+func (set *threadUnsafeSet) IsProperSuperset(other Set) bool {
+	return set.IsSuperset(other) && !set.Equal(other)
+}
+
+func (set *threadUnsafeSet) Union(other Set) Set {
+	o := other.(*threadUnsafeSet)
+
+	unionedSet := newThreadUnsafeSet()
+
+	for elem := range *set {
+		unionedSet.Add(elem)
+	}
+	for elem := range *o {
+		unionedSet.Add(elem)
+	}
+	return &unionedSet
+}
+
+func (set *threadUnsafeSet) Intersect(other Set) Set {
+	o := other.(*threadUnsafeSet)
+
+	intersection := newThreadUnsafeSet()
+	// loop over smaller set
+	if set.Cardinality() < other.Cardinality() {
+		for elem := range *set {
+			if other.Contains(elem) {
+				intersection.Add(elem)
+			}
+		}
+	} else {
+		for elem := range *o {
+			if set.Contains(elem) {
+				intersection.Add(elem)
+			}
+		}
+	}
+	return &intersection
+}
+
+func (set *threadUnsafeSet) Difference(other Set) Set {
+	_ = other.(*threadUnsafeSet)
+
+	difference := newThreadUnsafeSet()
+	for elem := range *set {
+		if !other.Contains(elem) {
+			difference.Add(elem)
+		}
+	}
+	return &difference
+}
+
+func (set *threadUnsafeSet) SymmetricDifference(other Set) Set {
+	_ = other.(*threadUnsafeSet)
+
+	aDiff := set.Difference(other)
+	bDiff := other.Difference(set)
+	return aDiff.Union(bDiff)
+}
+
+func (set *threadUnsafeSet) Clear() {
+	*set = newThreadUnsafeSet()
+}
+
+func (set *threadUnsafeSet) Remove(i interface{}) {
+	delete(*set, i)
+}
+
+func (set *threadUnsafeSet) Cardinality() int {
+	return len(*set)
+}
+
+func (set *threadUnsafeSet) Each(cb func(interface{}) bool) {
+	for elem := range *set {
+		if cb(elem) {
+			break
+		}
+	}
+}
+
+func (set *threadUnsafeSet) Iter() <-chan interface{} {
+	ch := make(chan interface{})
+	go func() {
+		for elem := range *set {
+			ch <- elem
+		}
+		close(ch)
+	}()
+
+	return ch
+}
+
+func (set *threadUnsafeSet) Iterator() *Iterator {
+	iterator, ch, stopCh := newIterator()
+
+	go func() {
+	L:
+		for elem := range *set {
+			select {
+			case <-stopCh:
+				break L
+			case ch <- elem:
+			}
+		}
+		close(ch)
+	}()
+
+	return iterator
+}
+
+func (set *threadUnsafeSet) Equal(other Set) bool {
+	_ = other.(*threadUnsafeSet)
+
+	if set.Cardinality() != other.Cardinality() {
+		return false
+	}
+	for elem := range *set {
+		if !other.Contains(elem) {
+			return false
+		}
+	}
+	return true
+}
+
+func (set *threadUnsafeSet) Clone() Set {
+	clonedSet := newThreadUnsafeSet()
+	for elem := range *set {
+		clonedSet.Add(elem)
+	}
+	return &clonedSet
+}
+
+func (set *threadUnsafeSet) String() string {
+	items := make([]string, 0, len(*set))
+
+	for elem := range *set {
+		items = append(items, fmt.Sprintf("%v", elem))
+	}
+	return fmt.Sprintf("Set{%s}", strings.Join(items, ", "))
+}
+
+// String outputs a 2-tuple in the form "(A, B)".
+func (pair OrderedPair) String() string {
+	return fmt.Sprintf("(%v, %v)", pair.First, pair.Second)
+}
+
+func (set *threadUnsafeSet) Pop() interface{} {
+	for item := range *set {
+		delete(*set, item)
+		return item
+	}
+	return nil
+}
+
+func (set *threadUnsafeSet) PowerSet() Set {
+	powSet := NewThreadUnsafeSet()
+	nullset := newThreadUnsafeSet()
+	powSet.Add(&nullset)
+
+	for es := range *set {
+		u := newThreadUnsafeSet()
+		j := powSet.Iter()
+		for er := range j {
+			p := newThreadUnsafeSet()
+			if reflect.TypeOf(er).Name() == "" {
+				k := er.(*threadUnsafeSet)
+				for ek := range *(k) {
+					p.Add(ek)
+				}
+			} else {
+				p.Add(er)
+			}
+			p.Add(es)
+			u.Add(&p)
+		}
+
+		powSet = powSet.Union(&u)
+	}
+
+	return powSet
+}
+
+func (set *threadUnsafeSet) CartesianProduct(other Set) Set {
+	o := other.(*threadUnsafeSet)
+	cartProduct := NewThreadUnsafeSet()
+
+	for i := range *set {
+		for j := range *o {
+			elem := OrderedPair{First: i, Second: j}
+			cartProduct.Add(elem)
+		}
+	}
+
+	return cartProduct
+}
+
+func (set *threadUnsafeSet) ToSlice() []interface{} {
+	keys := make([]interface{}, 0, set.Cardinality())
+	for elem := range *set {
+		keys = append(keys, elem)
+	}
+
+	return keys
+}
+
+// MarshalJSON creates a JSON array from the set, it marshals all elements
+func (set *threadUnsafeSet) MarshalJSON() ([]byte, error) {
+	items := make([]string, 0, set.Cardinality())
+
+	for elem := range *set {
+		b, err := json.Marshal(elem)
+		if err != nil {
+			return nil, err
+		}
+
+		items = append(items, string(b))
+	}
+
+	return []byte(fmt.Sprintf("[%s]", strings.Join(items, ","))), nil
+}
+
+// UnmarshalJSON recreates a set from a JSON array, it only decodes
+// primitive types. Numbers are decoded as json.Number.
+func (set *threadUnsafeSet) UnmarshalJSON(b []byte) error {
+	var i []interface{}
+
+	d := json.NewDecoder(bytes.NewReader(b))
+	d.UseNumber()
+	err := d.Decode(&i)
+	if err != nil {
+		return err
+	}
+
+	for _, v := range i {
+		switch t := v.(type) {
+		case []interface{}, map[string]interface{}:
+			continue
+		default:
+			set.Add(t)
+		}
+	}
+
+	return nil
+}

vendor/github.com/eventials/go-tus/.gitignore

@@ -0,0 +1,28 @@
+# 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
+
+.DS_Store
+
+.idea/

vendor/github.com/eventials/go-tus/.travis.yml

@@ -0,0 +1,11 @@
+language: go
+go:
+  - 1.13
+  - tip
+script: go test -v ./...
+notifications:
+  email:
+    recipients:
+      - devs@eventials.com
+    on_success: never
+    on_failure: always

vendor/github.com/eventials/go-tus/Dockerfile

@@ -0,0 +1,9 @@
+FROM golang:1.13
+
+RUN mkdir -p /go/src/github.com/eventials/go-tus
+
+WORKDIR /go/src/github.com/eventials/go-tus
+
+RUN go get github.com/stretchr/testify
+RUN go get github.com/tus/tusd
+RUN go get github.com/syndtr/goleveldb/leveldb

vendor/github.com/eventials/go-tus/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Eventials
+
+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.

vendor/github.com/eventials/go-tus/README.md

@@ -0,0 +1,62 @@
+# go-tus [![Build Status](https://travis-ci.org/eventials/go-tus.svg?branch=master)](https://travis-ci.org/eventials/go-tus) [![Go Report Card](https://goreportcard.com/badge/github.com/eventials/go-tus)](https://goreportcard.com/report/github.com/eventials/go-tus) [![GoDoc](https://godoc.org/github.com/eventials/go-tus?status.svg)](http://godoc.org/github.com/eventials/go-tus)
+
+A pure Go client for the [tus resumable upload protocol](http://tus.io/)
+
+## Example
+
+```go
+package main
+
+import (
+    "os"
+    "github.com/eventials/go-tus"
+)
+
+func main() {
+    f, err := os.Open("my-file.txt")
+
+    if err != nil {
+        panic(err)
+    }
+
+    defer f.Close()
+
+    // create the tus client.
+    client, _ := tus.NewClient("https://tus.example.org/files", nil)
+
+    // create an upload from a file.
+    upload, _ := tus.NewUploadFromFile(f)
+
+    // create the uploader.
+    uploader, _ := client.CreateUpload(upload)
+
+    // start the uploading process.
+    uploader.Upload()
+}
+```
+
+## Features
+
+> This is not a full protocol client implementation.
+
+Checksum, Termination and Concatenation extensions are not implemented yet.
+
+This client allows to resume an upload if a Store is used.
+
+## Built in Store
+
+Store is used to map an upload's fingerprint with the corresponding upload URL.
+
+| Name | Backend | Dependencies |
+|:----:|:-------:|:------------:|
+| MemoryStore  | In-Memory | None |
+| LeveldbStore | LevelDB   | [goleveldb](https://github.com/syndtr/goleveldb) |
+
+## Future Work
+
+- [ ] SQLite store
+- [ ] Redis store
+- [ ] Memcached store
+- [ ] Checksum extension
+- [ ] Termination extension
+- [ ] Concatenation extension

vendor/github.com/eventials/go-tus/client.go

@@ -0,0 +1,254 @@
+package tus
+
+import (
+	"io"
+	"io/ioutil"
+	"net/http"
+	netUrl "net/url"
+	"strconv"
+)
+
+const (
+	ProtocolVersion = "1.0.0"
+)
+
+// Client represents the tus client.
+// You can use it in goroutines to create parallels uploads.
+type Client struct {
+	Config  *Config
+	Url     string
+	Version string
+	Header  http.Header
+
+	client *http.Client
+}
+
+// NewClient creates a new tus client.
+func NewClient(url string, config *Config) (*Client, error) {
+	if config == nil {
+		config = DefaultConfig()
+	} else {
+		if err := config.Validate(); err != nil {
+			return nil, err
+		}
+	}
+
+	if config.Header == nil {
+		config.Header = make(http.Header)
+	}
+
+	if config.HttpClient == nil {
+		config.HttpClient = &http.Client{}
+	}
+
+	return &Client{
+		Config:  config,
+		Url:     url,
+		Version: ProtocolVersion,
+		Header:  config.Header,
+
+		client: config.HttpClient,
+	}, nil
+}
+
+func (c *Client) Do(req *http.Request) (*http.Response, error) {
+	for k, v := range c.Header {
+		req.Header[k] = v
+	}
+
+	req.Header.Set("Tus-Resumable", ProtocolVersion)
+
+	return c.client.Do(req)
+}
+
+// CreateUpload creates a new upload in the server.
+func (c *Client) CreateUpload(u *Upload) (*Uploader, error) {
+	if u == nil {
+		return nil, ErrNilUpload
+	}
+
+	if c.Config.Resume && len(u.Fingerprint) == 0 {
+		return nil, ErrFingerprintNotSet
+	}
+
+	req, err := http.NewRequest("POST", c.Url, nil)
+
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Set("Content-Length", "0")
+	req.Header.Set("Upload-Length", strconv.FormatInt(u.size, 10))
+	req.Header.Set("Upload-Metadata", u.EncodedMetadata())
+
+	res, err := c.Do(req)
+
+	if err != nil {
+		return nil, err
+	}
+	defer res.Body.Close()
+
+	switch res.StatusCode {
+	case 201:
+		url := res.Header.Get("Location")
+
+		baseUrl, err := netUrl.Parse(c.Url)
+		if err != nil {
+			return nil, ErrUrlNotRecognized
+		}
+
+		newUrl, err := netUrl.Parse(url)
+		if err != nil {
+			return nil, ErrUrlNotRecognized
+		}
+		if newUrl.Scheme == "" {
+			newUrl.Scheme = baseUrl.Scheme
+			url = newUrl.String()
+		}
+
+		if c.Config.Resume {
+			c.Config.Store.Set(u.Fingerprint, url)
+		}
+
+		return NewUploader(c, url, u, 0), nil
+	case 412:
+		return nil, ErrVersionMismatch
+	case 413:
+		return nil, ErrLargeUpload
+	default:
+		return nil, newClientError(res)
+	}
+}
+
+// ResumeUpload resumes the upload if already created, otherwise it will return an error.
+func (c *Client) ResumeUpload(u *Upload) (*Uploader, error) {
+	if u == nil {
+		return nil, ErrNilUpload
+	}
+
+	if !c.Config.Resume {
+		return nil, ErrResumeNotEnabled
+	} else if len(u.Fingerprint) == 0 {
+		return nil, ErrFingerprintNotSet
+	}
+
+	url, found := c.Config.Store.Get(u.Fingerprint)
+
+	if !found {
+		return nil, ErrUploadNotFound
+	}
+
+	offset, err := c.getUploadOffset(url)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return NewUploader(c, url, u, offset), nil
+}
+
+// CreateOrResumeUpload resumes the upload if already created or creates a new upload in the server.
+func (c *Client) CreateOrResumeUpload(u *Upload) (*Uploader, error) {
+	if u == nil {
+		return nil, ErrNilUpload
+	}
+
+	uploader, err := c.ResumeUpload(u)
+
+	if err == nil {
+		return uploader, err
+	} else if (err == ErrResumeNotEnabled) || (err == ErrUploadNotFound) {
+		return c.CreateUpload(u)
+	}
+
+	return nil, err
+}
+
+func (c *Client) uploadChunck(url string, body io.Reader, size int64, offset int64) (int64, error) {
+	var method string
+
+	if !c.Config.OverridePatchMethod {
+		method = "PATCH"
+	} else {
+		method = "POST"
+	}
+
+	req, err := http.NewRequest(method, url, body)
+
+	if err != nil {
+		return -1, err
+	}
+
+	req.Header.Set("Content-Type", "application/offset+octet-stream")
+	req.Header.Set("Content-Length", strconv.FormatInt(size, 10))
+	req.Header.Set("Upload-Offset", strconv.FormatInt(offset, 10))
+
+	if c.Config.OverridePatchMethod {
+		req.Header.Set("X-HTTP-Method-Override", "PATCH")
+	}
+
+	res, err := c.Do(req)
+
+	if err != nil {
+		return -1, err
+	}
+	defer res.Body.Close()
+
+	switch res.StatusCode {
+	case 204:
+		if newOffset, err := strconv.ParseInt(res.Header.Get("Upload-Offset"), 10, 64); err == nil {
+			return newOffset, nil
+		} else {
+			return -1, err
+		}
+	case 409:
+		return -1, ErrOffsetMismatch
+	case 412:
+		return -1, ErrVersionMismatch
+	case 413:
+		return -1, ErrLargeUpload
+	default:
+		return -1, newClientError(res)
+	}
+}
+
+func (c *Client) getUploadOffset(url string) (int64, error) {
+	req, err := http.NewRequest("HEAD", url, nil)
+
+	if err != nil {
+		return -1, err
+	}
+
+	res, err := c.Do(req)
+
+	if err != nil {
+		return -1, err
+	}
+	defer res.Body.Close()
+
+	switch res.StatusCode {
+	case 200:
+		i, err := strconv.ParseInt(res.Header.Get("Upload-Offset"), 10, 64)
+
+		if err == nil {
+			return i, nil
+		} else {
+			return -1, err
+		}
+	case 403, 404, 410:
+		// file doesn't exists.
+		return -1, ErrUploadNotFound
+	case 412:
+		return -1, ErrVersionMismatch
+	default:
+		return -1, newClientError(res)
+	}
+}
+
+func newClientError(res *http.Response) ClientError {
+	body, _ := ioutil.ReadAll(res.Body)
+	return ClientError{
+		Code: res.StatusCode,
+		Body: body,
+	}
+}

vendor/github.com/eventials/go-tus/config.go

@@ -0,0 +1,47 @@
+package tus
+
+import (
+	"net/http"
+)
+
+// Config provides a way to configure the Client depending on your needs.
+type Config struct {
+	// ChunkSize divide the file into chunks.
+	ChunkSize int64
+	// Resume enables resumable upload.
+	Resume bool
+	// OverridePatchMethod allow to by pass proxies sendind a POST request instead of PATCH.
+	OverridePatchMethod bool
+	// Store map an upload's fingerprint with the corresponding upload URL.
+	// If Resume is true the Store is required.
+	Store Store
+	// Set custom header values used in all requests.
+	Header http.Header
+	// HTTP Client
+	HttpClient *http.Client
+}
+
+// DefaultConfig return the default Client configuration.
+func DefaultConfig() *Config {
+	return &Config{
+		ChunkSize:           2 * 1024 * 1024,
+		Resume:              false,
+		OverridePatchMethod: false,
+		Store:               nil,
+		Header:              make(http.Header),
+		HttpClient:          nil,
+	}
+}
+
+// Validate validates the custom configuration.
+func (c *Config) Validate() error {
+	if c.ChunkSize < 1 {
+		return ErrChuckSize
+	}
+
+	if c.Resume && c.Store == nil {
+		return ErrNilStore
+	}
+
+	return nil
+}

vendor/github.com/eventials/go-tus/doc.go

@@ -0,0 +1,8 @@
+// Package tus provides a client to tus protocol version 1.0.0.
+//
+// tus is a protocol based on HTTP for resumable file uploads. Resumable means that
+// an upload can be interrupted at any moment and can be resumed without
+// re-uploading the previous data again. An interruption may happen willingly, if
+// the user wants to pause, or by accident in case of an network issue or server
+// outage (http://tus.io).
+package tus

vendor/github.com/eventials/go-tus/docker-compose.yml

@@ -0,0 +1,8 @@
+version: '2'
+services:
+  app:
+    build: .
+    working_dir: /go/src/github.com/eventials/go-tus
+    command: go run main.go
+    volumes:
+     - .:/go/src/github.com/eventials/go-tus

vendor/github.com/eventials/go-tus/errors.go

@@ -0,0 +1,29 @@
+package tus
+
+import (
+	"errors"
+	"fmt"
+)
+
+var (
+	ErrChuckSize         = errors.New("chunk size must be greater than zero.")
+	ErrNilLogger         = errors.New("logger can't be nil.")
+	ErrNilStore          = errors.New("store can't be nil if Resume is enable.")
+	ErrNilUpload         = errors.New("upload can't be nil.")
+	ErrLargeUpload       = errors.New("upload body is to large.")
+	ErrVersionMismatch   = errors.New("protocol version mismatch.")
+	ErrOffsetMismatch    = errors.New("upload offset mismatch.")
+	ErrUploadNotFound    = errors.New("upload not found.")
+	ErrResumeNotEnabled  = errors.New("resuming not enabled.")
+	ErrFingerprintNotSet = errors.New("fingerprint not set.")
+	ErrUrlNotRecognized  = errors.New("url not recognized")
+)
+
+type ClientError struct {
+	Code int
+	Body []byte
+}
+
+func (c ClientError) Error() string {
+	return fmt.Sprintf("unexpected status code: %d", c.Code)
+}

vendor/github.com/eventials/go-tus/go.mod

@@ -0,0 +1,9 @@
+module github.com/eventials/go-tus
+
+go 1.13
+
+require (
+	github.com/stretchr/testify v1.5.1
+	github.com/syndtr/goleveldb v1.0.0
+	github.com/tus/tusd v1.1.0
+)

vendor/github.com/eventials/go-tus/go.sum

@@ -0,0 +1,184 @@
+cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.34.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+cloud.google.com/go v0.38.0/go.mod h1:990N+gfupTy94rShfmMCWGDn0LpTmnzTp2qbd1dvSRU=
+cloud.google.com/go v0.40.0/go.mod h1:Tk58MuI9rbLMKlAjeO/bDnteAx7tX2gJIXw4T5Jwlro=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
+github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+github.com/aws/aws-sdk-go v1.20.1/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
+github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
+github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
+github.com/bmizerany/pat v0.0.0-20170815010413-6226ea591a40 h1:y4B3+GPxKlrigF1ha5FFErxK+sr6sWxQovRMzwMhejo=
+github.com/bmizerany/pat v0.0.0-20170815010413-6226ea591a40/go.mod h1:8rLXio+WjiTceGBHIoTvn60HIbs7Hm7bcHjyrSqYB9c=
+github.com/census-instrumentation/opencensus-proto v0.2.1/go.mod h1:f6KPmirojxKA12rnyqOA5BBL4O983OfeGPqjHWSTneU=
+github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/envoyproxy/go-control-plane v0.9.0/go.mod h1:YTl/9mNaCwkRvm6d1a2C3ymFceY/DCBVvsKhRF0iEA4=
+github.com/envoyproxy/protoc-gen-validate v0.1.0/go.mod h1:iSmxcyjqTsJpI2R4NaDN7+kN2VEUnK/pcBlmesArF7c=
+github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
+github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
+github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
+github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
+github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
+github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.2.0/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/mock v1.3.1 h1:qGJ6qTW+x6xX/my+8YUVl4WNpX9B7+/l2tRsHGZ7f2s=
+github.com/golang/mock v1.3.1/go.mod h1:sBzyDLLjw3U8JLTeZvSv8jJB+tU5PVekmnlKIyFUx0Y=
+github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.2 h1:6nsPYzhq5kReh6QImI3k5qWzO4PEbvbIW2cwSfR/6xs=
+github.com/golang/protobuf v1.3.2/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db h1:woRePGFeVFfLKN/pOkfl+p/TAqKOfFu+7KPlMVpok/w=
+github.com/golang/snappy v0.0.0-20180518054509-2e65f85255db/go.mod h1:/XxbfmMg8lxefKM7IXC3fBNl/7bRcc72aCRzEWrmP2Q=
+github.com/google/btree v0.0.0-20180813153112-4030bb1f1f0c/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
+github.com/google/go-cmp v0.3.0/go.mod h1:8QqcDgzrUqlUb/G2PQTWiueGozuR1884gddMywk6iLU=
+github.com/google/martian v2.1.0+incompatible/go.mod h1:9I4somxYTbIHy5NJKHRl3wXiIaQGbYVAs8BPL6v8lEs=
+github.com/google/pprof v0.0.0-20181206194817-3ea8567a2e57/go.mod h1:zfwlbNMJ+OItoe0UupaVj+oy1omPYYDuagoSzA8v9mc=
+github.com/googleapis/gax-go/v2 v2.0.4/go.mod h1:0Wqv26UfaUD9n4G6kQubkQ+KchISgw+vpHVxEJEs9eg=
+github.com/grpc-ecosystem/go-grpc-middleware v1.1.0/go.mod h1:f5nM7jw/oeRSadq3xCzHAvxcr8HZnzsqU6ILg/0NiiE=
+github.com/h2non/parth v0.0.0-20190131123155-b4df798d6542/go.mod h1:Ow0tF8D4Kplbc8s8sSb3V2oUCygFHVp8gC3Dn6U4MNI=
+github.com/hashicorp/golang-lru v0.5.0/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/hashicorp/golang-lru v0.5.1/go.mod h1:/m3WP610KZHVQ1SGc6re/UDhFvYD7pJ4Ao+sR/qLZy8=
+github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
+github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
+github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
+github.com/jstemmer/go-junit-report v0.0.0-20190106144839-af01ea7f8024/go.mod h1:6v2b51hI/fHJwM22ozAgKL4VKDeJcHhJFhtBdhmNjmU=
+github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
+github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
+github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
+github.com/nbio/st v0.0.0-20140626010706-e9e8d9816f32/go.mod h1:9wM+0iRr9ahx58uYLpLIr5fm8diHn0JbqRycJi6w0Ms=
+github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/ginkgo v1.7.0 h1:WSHQ+IS43OoUrWtD1/bbclrwK8TTH5hzp+umCiuxHgs=
+github.com/onsi/ginkgo v1.7.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/gomega v1.4.3 h1:RE1xgDvH7imwFD45h+u2SgIfERHlS2yNG4DObb5BSKU=
+github.com/onsi/gomega v1.4.3/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/opentracing/opentracing-go v1.1.0/go.mod h1:UkNAQd3GIcIGf0SeVgPpRdFStlNbqXla1AfSYxPUl2o=
+github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
+github.com/prometheus/client_golang v1.0.0/go.mod h1:db9x61etRT2tGnBNRi70OPL5FsnadC4Ky3P0J6CfImo=
+github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
+github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/client_model v0.0.0-20190812154241-14fe0d1b01d4/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/common v0.4.1/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
+github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/prometheus/procfs v0.0.2/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
+github.com/sethgrid/pester v0.0.0-20190127155807-68a33a018ad0/go.mod h1:Ad7IjTpvzZO8Fl0vh9AzQ+j/jYZfyp2diGwI8m5q+ns=
+github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
+github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4=
+github.com/stretchr/testify v1.5.1 h1:nOGnQDM7FYENwehXlg/kFVnos3rEvtKTjRvOWSzb6H4=
+github.com/stretchr/testify v1.5.1/go.mod h1:5W2xD1RspED5o8YsWQXVCued0rvSQ+mT+I5cxcmMvtA=
+github.com/syndtr/goleveldb v1.0.0 h1:fBdIW9lB4Iz0n9khmH8w27SJ3QEJ7+IgjPEwGSZiFdE=
+github.com/syndtr/goleveldb v1.0.0/go.mod h1:ZVVdQEZoIme9iO1Ch2Jdy24qqXrMMOU6lpPAyBWyWuQ=
+github.com/tus/tusd v1.1.0 h1:y2oBFGeOyqlGgyqD0CloH8FuBrjDk0Tq1IQWvAZnyG8=
+github.com/tus/tusd v1.1.0/go.mod h1:3DWPOdeCnjBwKtv98y5dSws3itPqfce5TVa0s59LRiA=
+github.com/vimeo/go-util v1.2.0/go.mod h1:s13SMDTSO7AjH1nbgp707mfN5JFIWUFDU5MDDuRRtKs=
+go.opencensus.io v0.21.0/go.mod h1:mSImk1erAIZhrmZN+AvHh14ztQfjbGwt4TtuofqLduU=
+go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
+go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
+go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
+golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/exp v0.0.0-20190121172915-509febef88a4/go.mod h1:CJ0aWSM057203Lf6IL+f9T1iT9GByDxfZKAQTCR3kQA=
+golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190227174305-5b3e6a55c961/go.mod h1:wehouNa3lNwaWXcvxsM5YxQ5yQlVC4a0KAMCusXpPoU=
+golang.org/x/lint v0.0.0-20190301231843-5614ed5bae6f/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/lint v0.0.0-20190409202823-959b441ac422/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/net v0.0.0-20180724234803-3673e40ba225/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd h1:nTDtHvHSdCn1m6ITfMRqtOd/9+7a3s8RBNOZ3eYZzJA=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190108225652-1e06a53dbb7e/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190213061140-3a22650c66bd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c h1:uOCk1iQW6Vc18bnC13MfzScl+wdKBmM9Y9kU7Z83/lw=
+golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/oauth2 v0.0.0-20190226205417-e64efc72b421/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/oauth2 v0.0.0-20190604053449-0f29369cfe45/go.mod h1:gOpvHmFTYa4IltrdGE7lF6nIHvwfUNPOp7c8zoXwtLw=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f h1:wMNYb4v58l5UBM7MYRLPG6ZhfOqbKu7X5eyFl8ZhKvA=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190227155943-e225da77a7e6/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e h1:o3PsSEY8E4eXWkXrIP9YJALUkVZqzHJT5DOasTyn8Vs=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b h1:ag/x1USPSsqHud38I9BAC88qdNLDHHtQ4mlgQIZPPNA=
+golang.org/x/sys v0.0.0-20190507160741-ecd444e8653b/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.1-0.20180807135948-17ff2d5776d2/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
+golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/time v0.0.0-20181108054448-85acf8d2951c/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190226205152-f727befe758c/go.mod h1:9Yl7xja0Znq3iFh3HoIrodX9oNMXvdceNzlUR8zjMvY=
+golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190312170243-e65039ee4138/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+golang.org/x/tools v0.0.0-20190425150028-36563e24a262/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190506145303-2d16b83fe98c/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+golang.org/x/tools v0.0.0-20190524140312-2c0ae7006135/go.mod h1:RgjU9mgBXZiqYHBnxXauZ1Gv1EHHAz9KjViQ78xBX0Q=
+google.golang.org/api v0.4.0/go.mod h1:8k5glujaEP+g9n7WNsDg8QP6cUVNI86fCNMcbazEtwE=
+google.golang.org/api v0.6.0/go.mod h1:btoxGiFvQNVUZQ8W08zLtrVS08CNpINPEfxXxgJL1Q4=
+google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+google.golang.org/appengine v1.4.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/appengine v1.5.0/go.mod h1:xpcJRLb0r/rnEns0DIKYYv+WjYCduHsrkT7/EB5XEv4=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/genproto v0.0.0-20190307195333-5fe7a883aa19/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190418145605-e7d98fc518a7/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190502173448-54afdca5d873/go.mod h1:VzzqZJRnGkLBvHegQrXjBqPurQTc5/KpmUdxsrq26oE=
+google.golang.org/genproto v0.0.0-20190530194941-fb225487d101/go.mod h1:z3L6/3dTEVtUr6QSP8miRzeRqwQOioJ9I66odjN4I7s=
+google.golang.org/genproto v0.0.0-20190819201941-24fa4b261c55/go.mod h1:DMBHOl98Agz4BDEuKkezgsaosCRResVns1a3J2ZsMNc=
+google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
+google.golang.org/grpc v1.20.1/go.mod h1:10oTOabMzJvdu6/UiuZezV6QK5dSlG84ov/aaiqXj38=
+google.golang.org/grpc v1.23.0/go.mod h1:Y5yQAOtifL1yxbo5wqy6BxZv8vAUGQwXBOALyacEbxg=
+google.golang.org/grpc v1.25.1/go.mod h1:c3i+UQWmh7LiEpx4sFZnkU36qjEYZ0imhYfXVyQciAY=
+gopkg.in/Acconut/lockfile.v1 v1.1.0/go.mod h1:6UCz3wJ8tSFUsPR6uP/j8uegEtDuEEqFxlpi0JI4Umw=
+gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=
+gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/h2non/gock.v1 v1.0.14/go.mod h1:sX4zAkdYX1TRGJ2JY156cFspQn4yRWn6p9EMdODlynE=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190418001031-e561f6794a2a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+honnef.co/go/tools v0.0.0-20190523083050-ea95bdfd59fc/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
+rsc.io/binaryregexp v0.2.0/go.mod h1:qTv7/COck+e2FymRvadv62gMdZztPaShugOCi3I+8D8=

vendor/github.com/eventials/go-tus/store.go

@@ -0,0 +1,8 @@
+package tus
+
+type Store interface {
+	Get(fingerprint string) (string, bool)
+	Set(fingerprint, url string)
+	Delete(fingerprint string)
+	Close()
+}

vendor/github.com/eventials/go-tus/upload.go

@@ -0,0 +1,107 @@
+package tus
+
+import (
+	"bytes"
+	"encoding/base64"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+)
+
+type Metadata map[string]string
+
+type Upload struct {
+	stream io.ReadSeeker
+	size   int64
+	offset int64
+
+	Fingerprint string
+	Metadata    Metadata
+}
+
+// Updates the Upload information based on offset.
+func (u *Upload) updateProgress(offset int64) {
+	u.offset = offset
+}
+
+// Returns whether this upload is finished or not.
+func (u *Upload) Finished() bool {
+	return u.offset >= u.size
+}
+
+// Returns the progress in a percentage.
+func (u *Upload) Progress() int64 {
+	return (u.offset * 100) / u.size
+}
+
+// Returns the current upload offset.
+func (u *Upload) Offset() int64 {
+	return u.offset
+}
+
+// Returns the size of the upload body.
+func (u *Upload) Size() int64 {
+	return u.size
+}
+
+// EncodedMetadata encodes the upload metadata.
+func (u *Upload) EncodedMetadata() string {
+	var encoded []string
+
+	for k, v := range u.Metadata {
+		encoded = append(encoded, fmt.Sprintf("%s %s", k, b64encode(v)))
+	}
+
+	return strings.Join(encoded, ",")
+}
+
+// NewUploadFromFile creates a new Upload from an os.File.
+func NewUploadFromFile(f *os.File) (*Upload, error) {
+	fi, err := f.Stat()
+
+	if err != nil {
+		return nil, err
+	}
+
+	metadata := map[string]string{
+		"filename": fi.Name(),
+	}
+
+	fingerprint := fmt.Sprintf("%s-%d-%s", fi.Name(), fi.Size(), fi.ModTime())
+
+	return NewUpload(f, fi.Size(), metadata, fingerprint), nil
+}
+
+// NewUploadFromBytes creates a new upload from a byte array.
+func NewUploadFromBytes(b []byte) *Upload {
+	buffer := bytes.NewReader(b)
+	return NewUpload(buffer, buffer.Size(), nil, "")
+}
+
+// NewUpload creates a new upload from an io.Reader.
+func NewUpload(reader io.Reader, size int64, metadata Metadata, fingerprint string) *Upload {
+	stream, ok := reader.(io.ReadSeeker)
+
+	if !ok {
+		buf := new(bytes.Buffer)
+		buf.ReadFrom(reader)
+		stream = bytes.NewReader(buf.Bytes())
+	}
+
+	if metadata == nil {
+		metadata = make(Metadata)
+	}
+
+	return &Upload{
+		stream: stream,
+		size:   size,
+
+		Fingerprint: fingerprint,
+		Metadata:    metadata,
+	}
+}
+
+func b64encode(s string) string {
+	return base64.StdEncoding.EncodeToString([]byte(s))
+}

vendor/github.com/eventials/go-tus/uploader.go

@@ -0,0 +1,115 @@
+package tus
+
+import (
+	"bytes"
+)
+
+type Uploader struct {
+	client     *Client
+	url        string
+	upload     *Upload
+	offset     int64
+	aborted    bool
+	uploadSubs []chan Upload
+	notifyChan chan bool
+}
+
+// Subscribes to progress updates.
+func (u *Uploader) NotifyUploadProgress(c chan Upload) {
+	u.uploadSubs = append(u.uploadSubs, c)
+}
+
+// Abort aborts the upload process.
+// It doens't abort the current chunck, only the remaining.
+func (u *Uploader) Abort() {
+	u.aborted = true
+}
+
+// IsAborted returns true if the upload was aborted.
+func (u *Uploader) IsAborted() bool {
+	return u.aborted
+}
+
+// Url returns the upload url.
+func (u *Uploader) Url() string {
+	return u.url
+}
+
+// Offset returns the current offset uploaded.
+func (u *Uploader) Offset() int64 {
+	return u.offset
+}
+
+// Upload uploads the entire body to the server.
+func (u *Uploader) Upload() error {
+	for u.offset < u.upload.size && !u.aborted {
+		err := u.UploadChunck()
+
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+// UploadChunck uploads a single chunck.
+func (u *Uploader) UploadChunck() error {
+	data := make([]byte, u.client.Config.ChunkSize)
+
+	_, err := u.upload.stream.Seek(u.offset, 0)
+
+	if err != nil {
+		return err
+	}
+
+	size, err := u.upload.stream.Read(data)
+
+	if err != nil {
+		return err
+	}
+
+	body := bytes.NewBuffer(data[:size])
+
+	newOffset, err := u.client.uploadChunck(u.url, body, int64(size), u.offset)
+
+	if err != nil {
+		return err
+	}
+
+	u.offset = newOffset
+
+	u.upload.updateProgress(u.offset)
+
+	u.notifyChan <- true
+
+	return nil
+}
+
+// Waits for a signal to broadcast to all subscribers
+func (u *Uploader) broadcastProgress() {
+	for _ = range u.notifyChan {
+		for _, c := range u.uploadSubs {
+			c <- *u.upload
+		}
+	}
+}
+
+// NewUploader creates a new Uploader.
+func NewUploader(client *Client, url string, upload *Upload, offset int64) *Uploader {
+	notifyChan := make(chan bool)
+
+	uploader := &Uploader{
+		client,
+		url,
+		upload,
+		offset,
+		false,
+		nil,
+		notifyChan,
+	}
+
+	go uploader.broadcastProgress()
+
+	return uploader
+}

vendor/github.com/go-ole/go-ole/.travis.yml

@@ -0,0 +1,8 @@
+language: go
+sudo: false
+
+go:
+  - 1.9.x
+  - 1.10.x
+  - 1.11.x
+  - tip

vendor/github.com/go-ole/go-ole/ChangeLog.md

@@ -0,0 +1,49 @@
+# Version 1.x.x
+
+* **Add more test cases and reference new test COM server project.** (Placeholder for future additions)
+
+# Version 1.2.0-alphaX
+
+**Minimum supported version is now Go 1.4. Go 1.1 support is deprecated, but should still build.**
+
+ * Added CI configuration for Travis-CI and AppVeyor.
+ * Added test InterfaceID and ClassID for the COM Test Server project.
+ * Added more inline documentation (#83).
+ * Added IEnumVARIANT implementation (#88).
+ * Added IEnumVARIANT test cases (#99, #100, #101).
+ * Added support for retrieving `time.Time` from VARIANT (#92).
+ * Added test case for IUnknown (#64).
+ * Added test case for IDispatch (#64).
+ * Added test cases for scalar variants (#64, #76).
+
+# Version 1.1.1
+
+ * Fixes for Linux build.
+ * Fixes for Windows build.
+
+# Version 1.1.0
+
+The change to provide building on all platforms is a new feature. The increase in minor version reflects that and allows those who wish to stay on 1.0.x to continue to do so. Support for 1.0.x will be limited to bug fixes.
+
+ * Move GUID out of variables.go into its own file to make new documentation available.
+ * Move OleError out of ole.go into its own file to make new documentation available.
+ * Add documentation to utility functions.
+ * Add documentation to variant receiver functions.
+ * Add documentation to ole structures.
+ * Make variant available to other systems outside of Windows.
+ * Make OLE structures available to other systems outside of Windows.
+
+## New Features
+
+ * Library should now be built on all platforms supported by Go. Library will NOOP on any platform that is not Windows.
+ * More functions are now documented and available on godoc.org.
+
+# Version 1.0.1
+
+ 1. Fix package references from repository location change.
+
+# Version 1.0.0
+
+This version is stable enough for use. The COM API is still incomplete, but provides enough functionality for accessing COM servers using IDispatch interface.
+
+There is no changelog for this version. Check commits for history.

vendor/github.com/go-ole/go-ole/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright © 2013-2017 Yasuhiro Matsumoto, <mattn.jp@gmail.com>
+
+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.

vendor/github.com/go-ole/go-ole/README.md

@@ -0,0 +1,46 @@
+# Go OLE
+
+[![Build status](https://ci.appveyor.com/api/projects/status/qr0u2sf7q43us9fj?svg=true)](https://ci.appveyor.com/project/jacobsantos/go-ole-jgs28)
+[![Build Status](https://travis-ci.org/go-ole/go-ole.svg?branch=master)](https://travis-ci.org/go-ole/go-ole)
+[![GoDoc](https://godoc.org/github.com/go-ole/go-ole?status.svg)](https://godoc.org/github.com/go-ole/go-ole)
+
+Go bindings for Windows COM using shared libraries instead of cgo.
+
+By Yasuhiro Matsumoto.
+
+## Install
+
+To experiment with go-ole, you can just compile and run the example program:
+
+```
+go get github.com/go-ole/go-ole
+cd /path/to/go-ole/
+go test
+
+cd /path/to/go-ole/example/excel
+go run excel.go
+```
+
+## Continuous Integration
+
+Continuous integration configuration has been added for both Travis-CI and AppVeyor. You will have to add these to your own account for your fork in order for it to run.
+
+**Travis-CI**
+
+Travis-CI was added to check builds on Linux to ensure that `go get` works when cross building. Currently, Travis-CI is not used to test cross-building, but this may be changed in the future. It is also not currently possible to test the library on Linux, since COM API is specific to Windows and it is not currently possible to run a COM server on Linux or even connect to a remote COM server.
+
+**AppVeyor**
+
+AppVeyor is used to build on Windows using the (in-development) test COM server. It is currently only used to test the build and ensure that the code works on Windows. It will be used to register a COM server and then run the test cases based on the test COM server.
+
+The tests currently do run and do pass and this should be maintained with commits.
+
+## Versioning
+
+Go OLE uses [semantic versioning](http://semver.org) for version numbers, which is similar to the version contract of the Go language. Which means that the major version will always maintain backwards compatibility with minor versions. Minor versions will only add new additions and changes. Fixes will always be in patch. 
+
+This contract should allow you to upgrade to new minor and patch versions without breakage or modifications to your existing code. Leave a ticket, if there is breakage, so that it could be fixed.
+
+## LICENSE
+
+Under the MIT License: http://mattn.mit-license.org/2013

vendor/github.com/go-ole/go-ole/appveyor.yml

@@ -0,0 +1,54 @@
+# Notes:
+#   - Minimal appveyor.yml file is an empty file. All sections are optional.
+#   - Indent each level of configuration with 2 spaces. Do not use tabs!
+#   - All section names are case-sensitive.
+#   - Section names should be unique on each level.
+
+version: "1.3.0.{build}-alpha-{branch}"
+
+os: Windows Server 2012 R2
+
+branches:
+  only:
+    - master
+    - v1.2
+    - v1.1
+    - v1.0
+
+skip_tags: true
+
+clone_folder: c:\gopath\src\github.com\go-ole\go-ole
+
+environment:
+  GOPATH: c:\gopath
+  matrix:
+  - GOARCH: amd64
+    GOVERSION: 1.5
+    GOROOT: c:\go
+    DOWNLOADPLATFORM: "x64"
+
+install:
+  - choco install mingw
+  - SET PATH=c:\tools\mingw64\bin;%PATH%
+  # - Download COM Server
+  - ps: Start-FileDownload "https://github.com/go-ole/test-com-server/releases/download/v1.0.2/test-com-server-${env:DOWNLOADPLATFORM}.zip"
+  - 7z e test-com-server-%DOWNLOADPLATFORM%.zip -oc:\gopath\src\github.com\go-ole\go-ole > NUL
+  - c:\gopath\src\github.com\go-ole\go-ole\build\register-assembly.bat
+  # - set
+  - go version
+  - go env
+  - go get -u golang.org/x/tools/cmd/cover
+  - go get -u golang.org/x/tools/cmd/godoc
+  - go get -u golang.org/x/tools/cmd/stringer
+
+build_script:
+  - cd c:\gopath\src\github.com\go-ole\go-ole
+  - go get -v -t ./...
+  - go build
+  - go test -v -cover ./...
+
+# disable automatic tests
+test: off
+
+# disable deployment
+deploy: off

vendor/github.com/go-ole/go-ole/com.go

@@ -0,0 +1,344 @@
+// +build windows
+
+package ole
+
+import (
+	"syscall"
+	"unicode/utf16"
+	"unsafe"
+)
+
+var (
+	procCoInitialize            = modole32.NewProc("CoInitialize")
+	procCoInitializeEx          = modole32.NewProc("CoInitializeEx")
+	procCoUninitialize          = modole32.NewProc("CoUninitialize")
+	procCoCreateInstance        = modole32.NewProc("CoCreateInstance")
+	procCoTaskMemFree           = modole32.NewProc("CoTaskMemFree")
+	procCLSIDFromProgID         = modole32.NewProc("CLSIDFromProgID")
+	procCLSIDFromString         = modole32.NewProc("CLSIDFromString")
+	procStringFromCLSID         = modole32.NewProc("StringFromCLSID")
+	procStringFromIID           = modole32.NewProc("StringFromIID")
+	procIIDFromString           = modole32.NewProc("IIDFromString")
+	procCoGetObject             = modole32.NewProc("CoGetObject")
+	procGetUserDefaultLCID      = modkernel32.NewProc("GetUserDefaultLCID")
+	procCopyMemory              = modkernel32.NewProc("RtlMoveMemory")
+	procVariantInit             = modoleaut32.NewProc("VariantInit")
+	procVariantClear            = modoleaut32.NewProc("VariantClear")
+	procVariantTimeToSystemTime = modoleaut32.NewProc("VariantTimeToSystemTime")
+	procSysAllocString          = modoleaut32.NewProc("SysAllocString")
+	procSysAllocStringLen       = modoleaut32.NewProc("SysAllocStringLen")
+	procSysFreeString           = modoleaut32.NewProc("SysFreeString")
+	procSysStringLen            = modoleaut32.NewProc("SysStringLen")
+	procCreateDispTypeInfo      = modoleaut32.NewProc("CreateDispTypeInfo")
+	procCreateStdDispatch       = modoleaut32.NewProc("CreateStdDispatch")
+	procGetActiveObject         = modoleaut32.NewProc("GetActiveObject")
+
+	procGetMessageW      = moduser32.NewProc("GetMessageW")
+	procDispatchMessageW = moduser32.NewProc("DispatchMessageW")
+)
+
+// coInitialize initializes COM library on current thread.
+//
+// MSDN documentation suggests that this function should not be called. Call
+// CoInitializeEx() instead. The reason has to do with threading and this
+// function is only for single-threaded apartments.
+//
+// That said, most users of the library have gotten away with just this
+// function. If you are experiencing threading issues, then use
+// CoInitializeEx().
+func coInitialize() (err error) {
+	// http://msdn.microsoft.com/en-us/library/windows/desktop/ms678543(v=vs.85).aspx
+	// Suggests that no value should be passed to CoInitialized.
+	// Could just be Call() since the parameter is optional. <-- Needs testing to be sure.
+	hr, _, _ := procCoInitialize.Call(uintptr(0))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+// coInitializeEx initializes COM library with concurrency model.
+func coInitializeEx(coinit uint32) (err error) {
+	// http://msdn.microsoft.com/en-us/library/windows/desktop/ms695279(v=vs.85).aspx
+	// Suggests that the first parameter is not only optional but should always be NULL.
+	hr, _, _ := procCoInitializeEx.Call(uintptr(0), uintptr(coinit))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+// CoInitialize initializes COM library on current thread.
+//
+// MSDN documentation suggests that this function should not be called. Call
+// CoInitializeEx() instead. The reason has to do with threading and this
+// function is only for single-threaded apartments.
+//
+// That said, most users of the library have gotten away with just this
+// function. If you are experiencing threading issues, then use
+// CoInitializeEx().
+func CoInitialize(p uintptr) (err error) {
+	// p is ignored and won't be used.
+	// Avoid any variable not used errors.
+	p = uintptr(0)
+	return coInitialize()
+}
+
+// CoInitializeEx initializes COM library with concurrency model.
+func CoInitializeEx(p uintptr, coinit uint32) (err error) {
+	// Avoid any variable not used errors.
+	p = uintptr(0)
+	return coInitializeEx(coinit)
+}
+
+// CoUninitialize uninitializes COM Library.
+func CoUninitialize() {
+	procCoUninitialize.Call()
+}
+
+// CoTaskMemFree frees memory pointer.
+func CoTaskMemFree(memptr uintptr) {
+	procCoTaskMemFree.Call(memptr)
+}
+
+// CLSIDFromProgID retrieves Class Identifier with the given Program Identifier.
+//
+// The Programmatic Identifier must be registered, because it will be looked up
+// in the Windows Registry. The registry entry has the following keys: CLSID,
+// Insertable, Protocol and Shell
+// (https://msdn.microsoft.com/en-us/library/dd542719(v=vs.85).aspx).
+//
+// programID identifies the class id with less precision and is not guaranteed
+// to be unique. These are usually found in the registry under
+// HKEY_LOCAL_MACHINE\SOFTWARE\Classes, usually with the format of
+// "Program.Component.Version" with version being optional.
+//
+// CLSIDFromProgID in Windows API.
+func CLSIDFromProgID(progId string) (clsid *GUID, err error) {
+	var guid GUID
+	lpszProgID := uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(progId)))
+	hr, _, _ := procCLSIDFromProgID.Call(lpszProgID, uintptr(unsafe.Pointer(&guid)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	clsid = &guid
+	return
+}
+
+// CLSIDFromString retrieves Class ID from string representation.
+//
+// This is technically the string version of the GUID and will convert the
+// string to object.
+//
+// CLSIDFromString in Windows API.
+func CLSIDFromString(str string) (clsid *GUID, err error) {
+	var guid GUID
+	lpsz := uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(str)))
+	hr, _, _ := procCLSIDFromString.Call(lpsz, uintptr(unsafe.Pointer(&guid)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	clsid = &guid
+	return
+}
+
+// StringFromCLSID returns GUID formated string from GUID object.
+func StringFromCLSID(clsid *GUID) (str string, err error) {
+	var p *uint16
+	hr, _, _ := procStringFromCLSID.Call(uintptr(unsafe.Pointer(clsid)), uintptr(unsafe.Pointer(&p)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	str = LpOleStrToString(p)
+	return
+}
+
+// IIDFromString returns GUID from program ID.
+func IIDFromString(progId string) (clsid *GUID, err error) {
+	var guid GUID
+	lpsz := uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(progId)))
+	hr, _, _ := procIIDFromString.Call(lpsz, uintptr(unsafe.Pointer(&guid)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	clsid = &guid
+	return
+}
+
+// StringFromIID returns GUID formatted string from GUID object.
+func StringFromIID(iid *GUID) (str string, err error) {
+	var p *uint16
+	hr, _, _ := procStringFromIID.Call(uintptr(unsafe.Pointer(iid)), uintptr(unsafe.Pointer(&p)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	str = LpOleStrToString(p)
+	return
+}
+
+// CreateInstance of single uninitialized object with GUID.
+func CreateInstance(clsid *GUID, iid *GUID) (unk *IUnknown, err error) {
+	if iid == nil {
+		iid = IID_IUnknown
+	}
+	hr, _, _ := procCoCreateInstance.Call(
+		uintptr(unsafe.Pointer(clsid)),
+		0,
+		CLSCTX_SERVER,
+		uintptr(unsafe.Pointer(iid)),
+		uintptr(unsafe.Pointer(&unk)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+// GetActiveObject retrieves pointer to active object.
+func GetActiveObject(clsid *GUID, iid *GUID) (unk *IUnknown, err error) {
+	if iid == nil {
+		iid = IID_IUnknown
+	}
+	hr, _, _ := procGetActiveObject.Call(
+		uintptr(unsafe.Pointer(clsid)),
+		uintptr(unsafe.Pointer(iid)),
+		uintptr(unsafe.Pointer(&unk)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+type BindOpts struct {
+	CbStruct          uint32
+	GrfFlags          uint32
+	GrfMode           uint32
+	TickCountDeadline uint32
+}
+
+// GetObject retrieves pointer to active object.
+func GetObject(programID string, bindOpts *BindOpts, iid *GUID) (unk *IUnknown, err error) {
+	if bindOpts != nil {
+		bindOpts.CbStruct = uint32(unsafe.Sizeof(BindOpts{}))
+	}
+	if iid == nil {
+		iid = IID_IUnknown
+	}
+	hr, _, _ := procCoGetObject.Call(
+		uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(programID))),
+		uintptr(unsafe.Pointer(bindOpts)),
+		uintptr(unsafe.Pointer(iid)),
+		uintptr(unsafe.Pointer(&unk)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+// VariantInit initializes variant.
+func VariantInit(v *VARIANT) (err error) {
+	hr, _, _ := procVariantInit.Call(uintptr(unsafe.Pointer(v)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+// VariantClear clears value in Variant settings to VT_EMPTY.
+func VariantClear(v *VARIANT) (err error) {
+	hr, _, _ := procVariantClear.Call(uintptr(unsafe.Pointer(v)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+// SysAllocString allocates memory for string and copies string into memory.
+func SysAllocString(v string) (ss *int16) {
+	pss, _, _ := procSysAllocString.Call(uintptr(unsafe.Pointer(syscall.StringToUTF16Ptr(v))))
+	ss = (*int16)(unsafe.Pointer(pss))
+	return
+}
+
+// SysAllocStringLen copies up to length of given string returning pointer.
+func SysAllocStringLen(v string) (ss *int16) {
+	utf16 := utf16.Encode([]rune(v + "\x00"))
+	ptr := &utf16[0]
+
+	pss, _, _ := procSysAllocStringLen.Call(uintptr(unsafe.Pointer(ptr)), uintptr(len(utf16)-1))
+	ss = (*int16)(unsafe.Pointer(pss))
+	return
+}
+
+// SysFreeString frees string system memory. This must be called with SysAllocString.
+func SysFreeString(v *int16) (err error) {
+	hr, _, _ := procSysFreeString.Call(uintptr(unsafe.Pointer(v)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+// SysStringLen is the length of the system allocated string.
+func SysStringLen(v *int16) uint32 {
+	l, _, _ := procSysStringLen.Call(uintptr(unsafe.Pointer(v)))
+	return uint32(l)
+}
+
+// CreateStdDispatch provides default IDispatch implementation for IUnknown.
+//
+// This handles default IDispatch implementation for objects. It haves a few
+// limitations with only supporting one language. It will also only return
+// default exception codes.
+func CreateStdDispatch(unk *IUnknown, v uintptr, ptinfo *IUnknown) (disp *IDispatch, err error) {
+	hr, _, _ := procCreateStdDispatch.Call(
+		uintptr(unsafe.Pointer(unk)),
+		v,
+		uintptr(unsafe.Pointer(ptinfo)),
+		uintptr(unsafe.Pointer(&disp)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+// CreateDispTypeInfo provides default ITypeInfo implementation for IDispatch.
+//
+// This will not handle the full implementation of the interface.
+func CreateDispTypeInfo(idata *INTERFACEDATA) (pptinfo *IUnknown, err error) {
+	hr, _, _ := procCreateDispTypeInfo.Call(
+		uintptr(unsafe.Pointer(idata)),
+		uintptr(GetUserDefaultLCID()),
+		uintptr(unsafe.Pointer(&pptinfo)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+// copyMemory moves location of a block of memory.
+func copyMemory(dest unsafe.Pointer, src unsafe.Pointer, length uint32) {
+	procCopyMemory.Call(uintptr(dest), uintptr(src), uintptr(length))
+}
+
+// GetUserDefaultLCID retrieves current user default locale.
+func GetUserDefaultLCID() (lcid uint32) {
+	ret, _, _ := procGetUserDefaultLCID.Call()
+	lcid = uint32(ret)
+	return
+}
+
+// GetMessage in message queue from runtime.
+//
+// This function appears to block. PeekMessage does not block.
+func GetMessage(msg *Msg, hwnd uint32, MsgFilterMin uint32, MsgFilterMax uint32) (ret int32, err error) {
+	r0, _, err := procGetMessageW.Call(uintptr(unsafe.Pointer(msg)), uintptr(hwnd), uintptr(MsgFilterMin), uintptr(MsgFilterMax))
+	ret = int32(r0)
+	return
+}
+
+// DispatchMessage to window procedure.
+func DispatchMessage(msg *Msg) (ret int32) {
+	r0, _, _ := procDispatchMessageW.Call(uintptr(unsafe.Pointer(msg)))
+	ret = int32(r0)
+	return
+}

vendor/github.com/go-ole/go-ole/com_func.go

@@ -0,0 +1,174 @@
+// +build !windows
+
+package ole
+
+import (
+	"time"
+	"unsafe"
+)
+
+// coInitialize initializes COM library on current thread.
+//
+// MSDN documentation suggests that this function should not be called. Call
+// CoInitializeEx() instead. The reason has to do with threading and this
+// function is only for single-threaded apartments.
+//
+// That said, most users of the library have gotten away with just this
+// function. If you are experiencing threading issues, then use
+// CoInitializeEx().
+func coInitialize() error {
+	return NewError(E_NOTIMPL)
+}
+
+// coInitializeEx initializes COM library with concurrency model.
+func coInitializeEx(coinit uint32) error {
+	return NewError(E_NOTIMPL)
+}
+
+// CoInitialize initializes COM library on current thread.
+//
+// MSDN documentation suggests that this function should not be called. Call
+// CoInitializeEx() instead. The reason has to do with threading and this
+// function is only for single-threaded apartments.
+//
+// That said, most users of the library have gotten away with just this
+// function. If you are experiencing threading issues, then use
+// CoInitializeEx().
+func CoInitialize(p uintptr) error {
+	return NewError(E_NOTIMPL)
+}
+
+// CoInitializeEx initializes COM library with concurrency model.
+func CoInitializeEx(p uintptr, coinit uint32) error {
+	return NewError(E_NOTIMPL)
+}
+
+// CoUninitialize uninitializes COM Library.
+func CoUninitialize() {}
+
+// CoTaskMemFree frees memory pointer.
+func CoTaskMemFree(memptr uintptr) {}
+
+// CLSIDFromProgID retrieves Class Identifier with the given Program Identifier.
+//
+// The Programmatic Identifier must be registered, because it will be looked up
+// in the Windows Registry. The registry entry has the following keys: CLSID,
+// Insertable, Protocol and Shell
+// (https://msdn.microsoft.com/en-us/library/dd542719(v=vs.85).aspx).
+//
+// programID identifies the class id with less precision and is not guaranteed
+// to be unique. These are usually found in the registry under
+// HKEY_LOCAL_MACHINE\SOFTWARE\Classes, usually with the format of
+// "Program.Component.Version" with version being optional.
+//
+// CLSIDFromProgID in Windows API.
+func CLSIDFromProgID(progId string) (*GUID, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// CLSIDFromString retrieves Class ID from string representation.
+//
+// This is technically the string version of the GUID and will convert the
+// string to object.
+//
+// CLSIDFromString in Windows API.
+func CLSIDFromString(str string) (*GUID, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// StringFromCLSID returns GUID formated string from GUID object.
+func StringFromCLSID(clsid *GUID) (string, error) {
+	return "", NewError(E_NOTIMPL)
+}
+
+// IIDFromString returns GUID from program ID.
+func IIDFromString(progId string) (*GUID, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// StringFromIID returns GUID formatted string from GUID object.
+func StringFromIID(iid *GUID) (string, error) {
+	return "", NewError(E_NOTIMPL)
+}
+
+// CreateInstance of single uninitialized object with GUID.
+func CreateInstance(clsid *GUID, iid *GUID) (*IUnknown, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// GetActiveObject retrieves pointer to active object.
+func GetActiveObject(clsid *GUID, iid *GUID) (*IUnknown, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// VariantInit initializes variant.
+func VariantInit(v *VARIANT) error {
+	return NewError(E_NOTIMPL)
+}
+
+// VariantClear clears value in Variant settings to VT_EMPTY.
+func VariantClear(v *VARIANT) error {
+	return NewError(E_NOTIMPL)
+}
+
+// SysAllocString allocates memory for string and copies string into memory.
+func SysAllocString(v string) *int16 {
+	u := int16(0)
+	return &u
+}
+
+// SysAllocStringLen copies up to length of given string returning pointer.
+func SysAllocStringLen(v string) *int16 {
+	u := int16(0)
+	return &u
+}
+
+// SysFreeString frees string system memory. This must be called with SysAllocString.
+func SysFreeString(v *int16) error {
+	return NewError(E_NOTIMPL)
+}
+
+// SysStringLen is the length of the system allocated string.
+func SysStringLen(v *int16) uint32 {
+	return uint32(0)
+}
+
+// CreateStdDispatch provides default IDispatch implementation for IUnknown.
+//
+// This handles default IDispatch implementation for objects. It haves a few
+// limitations with only supporting one language. It will also only return
+// default exception codes.
+func CreateStdDispatch(unk *IUnknown, v uintptr, ptinfo *IUnknown) (*IDispatch, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// CreateDispTypeInfo provides default ITypeInfo implementation for IDispatch.
+//
+// This will not handle the full implementation of the interface.
+func CreateDispTypeInfo(idata *INTERFACEDATA) (*IUnknown, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// copyMemory moves location of a block of memory.
+func copyMemory(dest unsafe.Pointer, src unsafe.Pointer, length uint32) {}
+
+// GetUserDefaultLCID retrieves current user default locale.
+func GetUserDefaultLCID() uint32 {
+	return uint32(0)
+}
+
+// GetMessage in message queue from runtime.
+//
+// This function appears to block. PeekMessage does not block.
+func GetMessage(msg *Msg, hwnd uint32, MsgFilterMin uint32, MsgFilterMax uint32) (int32, error) {
+	return int32(0), NewError(E_NOTIMPL)
+}
+
+// DispatchMessage to window procedure.
+func DispatchMessage(msg *Msg) int32 {
+	return int32(0)
+}
+
+func GetVariantDate(value uint64) (time.Time, error) {
+	return time.Now(), NewError(E_NOTIMPL)
+}

vendor/github.com/go-ole/go-ole/connect.go

@@ -0,0 +1,192 @@
+package ole
+
+// Connection contains IUnknown for fluent interface interaction.
+//
+// Deprecated. Use oleutil package instead.
+type Connection struct {
+	Object *IUnknown // Access COM
+}
+
+// Initialize COM.
+func (*Connection) Initialize() (err error) {
+	return coInitialize()
+}
+
+// Uninitialize COM.
+func (*Connection) Uninitialize() {
+	CoUninitialize()
+}
+
+// Create IUnknown object based first on ProgId and then from String.
+func (c *Connection) Create(progId string) (err error) {
+	var clsid *GUID
+	clsid, err = CLSIDFromProgID(progId)
+	if err != nil {
+		clsid, err = CLSIDFromString(progId)
+		if err != nil {
+			return
+		}
+	}
+
+	unknown, err := CreateInstance(clsid, IID_IUnknown)
+	if err != nil {
+		return
+	}
+	c.Object = unknown
+
+	return
+}
+
+// Release IUnknown object.
+func (c *Connection) Release() {
+	c.Object.Release()
+}
+
+// Load COM object from list of programIDs or strings.
+func (c *Connection) Load(names ...string) (errors []error) {
+	var tempErrors []error = make([]error, len(names))
+	var numErrors int = 0
+	for _, name := range names {
+		err := c.Create(name)
+		if err != nil {
+			tempErrors = append(tempErrors, err)
+			numErrors += 1
+			continue
+		}
+		break
+	}
+
+	copy(errors, tempErrors[0:numErrors])
+	return
+}
+
+// Dispatch returns Dispatch object.
+func (c *Connection) Dispatch() (object *Dispatch, err error) {
+	dispatch, err := c.Object.QueryInterface(IID_IDispatch)
+	if err != nil {
+		return
+	}
+	object = &Dispatch{dispatch}
+	return
+}
+
+// Dispatch stores IDispatch object.
+type Dispatch struct {
+	Object *IDispatch // Dispatch object.
+}
+
+// Call method on IDispatch with parameters.
+func (d *Dispatch) Call(method string, params ...interface{}) (result *VARIANT, err error) {
+	id, err := d.GetId(method)
+	if err != nil {
+		return
+	}
+
+	result, err = d.Invoke(id, DISPATCH_METHOD, params)
+	return
+}
+
+// MustCall method on IDispatch with parameters.
+func (d *Dispatch) MustCall(method string, params ...interface{}) (result *VARIANT) {
+	id, err := d.GetId(method)
+	if err != nil {
+		panic(err)
+	}
+
+	result, err = d.Invoke(id, DISPATCH_METHOD, params)
+	if err != nil {
+		panic(err)
+	}
+
+	return
+}
+
+// Get property on IDispatch with parameters.
+func (d *Dispatch) Get(name string, params ...interface{}) (result *VARIANT, err error) {
+	id, err := d.GetId(name)
+	if err != nil {
+		return
+	}
+	result, err = d.Invoke(id, DISPATCH_PROPERTYGET, params)
+	return
+}
+
+// MustGet property on IDispatch with parameters.
+func (d *Dispatch) MustGet(name string, params ...interface{}) (result *VARIANT) {
+	id, err := d.GetId(name)
+	if err != nil {
+		panic(err)
+	}
+
+	result, err = d.Invoke(id, DISPATCH_PROPERTYGET, params)
+	if err != nil {
+		panic(err)
+	}
+	return
+}
+
+// Set property on IDispatch with parameters.
+func (d *Dispatch) Set(name string, params ...interface{}) (result *VARIANT, err error) {
+	id, err := d.GetId(name)
+	if err != nil {
+		return
+	}
+	result, err = d.Invoke(id, DISPATCH_PROPERTYPUT, params)
+	return
+}
+
+// MustSet property on IDispatch with parameters.
+func (d *Dispatch) MustSet(name string, params ...interface{}) (result *VARIANT) {
+	id, err := d.GetId(name)
+	if err != nil {
+		panic(err)
+	}
+
+	result, err = d.Invoke(id, DISPATCH_PROPERTYPUT, params)
+	if err != nil {
+		panic(err)
+	}
+	return
+}
+
+// GetId retrieves ID of name on IDispatch.
+func (d *Dispatch) GetId(name string) (id int32, err error) {
+	var dispid []int32
+	dispid, err = d.Object.GetIDsOfName([]string{name})
+	if err != nil {
+		return
+	}
+	id = dispid[0]
+	return
+}
+
+// GetIds retrieves all IDs of names on IDispatch.
+func (d *Dispatch) GetIds(names ...string) (dispid []int32, err error) {
+	dispid, err = d.Object.GetIDsOfName(names)
+	return
+}
+
+// Invoke IDispatch on DisplayID of dispatch type with parameters.
+//
+// There have been problems where if send cascading params..., it would error
+// out because the parameters would be empty.
+func (d *Dispatch) Invoke(id int32, dispatch int16, params []interface{}) (result *VARIANT, err error) {
+	if len(params) < 1 {
+		result, err = d.Object.Invoke(id, dispatch)
+	} else {
+		result, err = d.Object.Invoke(id, dispatch, params...)
+	}
+	return
+}
+
+// Release IDispatch object.
+func (d *Dispatch) Release() {
+	d.Object.Release()
+}
+
+// Connect initializes COM and attempts to load IUnknown based on given names.
+func Connect(names ...string) (connection *Connection) {
+	connection.Initialize()
+	connection.Load(names...)
+	return
+}

vendor/github.com/go-ole/go-ole/constants.go

@@ -0,0 +1,153 @@
+package ole
+
+const (
+	CLSCTX_INPROC_SERVER   = 1
+	CLSCTX_INPROC_HANDLER  = 2
+	CLSCTX_LOCAL_SERVER    = 4
+	CLSCTX_INPROC_SERVER16 = 8
+	CLSCTX_REMOTE_SERVER   = 16
+	CLSCTX_ALL             = CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER | CLSCTX_LOCAL_SERVER
+	CLSCTX_INPROC          = CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER
+	CLSCTX_SERVER          = CLSCTX_INPROC_SERVER | CLSCTX_LOCAL_SERVER | CLSCTX_REMOTE_SERVER
+)
+
+const (
+	COINIT_APARTMENTTHREADED = 0x2
+	COINIT_MULTITHREADED     = 0x0
+	COINIT_DISABLE_OLE1DDE   = 0x4
+	COINIT_SPEED_OVER_MEMORY = 0x8
+)
+
+const (
+	DISPATCH_METHOD         = 1
+	DISPATCH_PROPERTYGET    = 2
+	DISPATCH_PROPERTYPUT    = 4
+	DISPATCH_PROPERTYPUTREF = 8
+)
+
+const (
+	S_OK           = 0x00000000
+	E_UNEXPECTED   = 0x8000FFFF
+	E_NOTIMPL      = 0x80004001
+	E_OUTOFMEMORY  = 0x8007000E
+	E_INVALIDARG   = 0x80070057
+	E_NOINTERFACE  = 0x80004002
+	E_POINTER      = 0x80004003
+	E_HANDLE       = 0x80070006
+	E_ABORT        = 0x80004004
+	E_FAIL         = 0x80004005
+	E_ACCESSDENIED = 0x80070005
+	E_PENDING      = 0x8000000A
+
+	CO_E_CLASSSTRING = 0x800401F3
+)
+
+const (
+	CC_FASTCALL = iota
+	CC_CDECL
+	CC_MSCPASCAL
+	CC_PASCAL = CC_MSCPASCAL
+	CC_MACPASCAL
+	CC_STDCALL
+	CC_FPFASTCALL
+	CC_SYSCALL
+	CC_MPWCDECL
+	CC_MPWPASCAL
+	CC_MAX = CC_MPWPASCAL
+)
+
+type VT uint16
+
+const (
+	VT_EMPTY           VT = 0x0
+	VT_NULL            VT = 0x1
+	VT_I2              VT = 0x2
+	VT_I4              VT = 0x3
+	VT_R4              VT = 0x4
+	VT_R8              VT = 0x5
+	VT_CY              VT = 0x6
+	VT_DATE            VT = 0x7
+	VT_BSTR            VT = 0x8
+	VT_DISPATCH        VT = 0x9
+	VT_ERROR           VT = 0xa
+	VT_BOOL            VT = 0xb
+	VT_VARIANT         VT = 0xc
+	VT_UNKNOWN         VT = 0xd
+	VT_DECIMAL         VT = 0xe
+	VT_I1              VT = 0x10
+	VT_UI1             VT = 0x11
+	VT_UI2             VT = 0x12
+	VT_UI4             VT = 0x13
+	VT_I8              VT = 0x14
+	VT_UI8             VT = 0x15
+	VT_INT             VT = 0x16
+	VT_UINT            VT = 0x17
+	VT_VOID            VT = 0x18
+	VT_HRESULT         VT = 0x19
+	VT_PTR             VT = 0x1a
+	VT_SAFEARRAY       VT = 0x1b
+	VT_CARRAY          VT = 0x1c
+	VT_USERDEFINED     VT = 0x1d
+	VT_LPSTR           VT = 0x1e
+	VT_LPWSTR          VT = 0x1f
+	VT_RECORD          VT = 0x24
+	VT_INT_PTR         VT = 0x25
+	VT_UINT_PTR        VT = 0x26
+	VT_FILETIME        VT = 0x40
+	VT_BLOB            VT = 0x41
+	VT_STREAM          VT = 0x42
+	VT_STORAGE         VT = 0x43
+	VT_STREAMED_OBJECT VT = 0x44
+	VT_STORED_OBJECT   VT = 0x45
+	VT_BLOB_OBJECT     VT = 0x46
+	VT_CF              VT = 0x47
+	VT_CLSID           VT = 0x48
+	VT_BSTR_BLOB       VT = 0xfff
+	VT_VECTOR          VT = 0x1000
+	VT_ARRAY           VT = 0x2000
+	VT_BYREF           VT = 0x4000
+	VT_RESERVED        VT = 0x8000
+	VT_ILLEGAL         VT = 0xffff
+	VT_ILLEGALMASKED   VT = 0xfff
+	VT_TYPEMASK        VT = 0xfff
+)
+
+const (
+	DISPID_UNKNOWN     = -1
+	DISPID_VALUE       = 0
+	DISPID_PROPERTYPUT = -3
+	DISPID_NEWENUM     = -4
+	DISPID_EVALUATE    = -5
+	DISPID_CONSTRUCTOR = -6
+	DISPID_DESTRUCTOR  = -7
+	DISPID_COLLECT     = -8
+)
+
+const (
+	TKIND_ENUM      = 1
+	TKIND_RECORD    = 2
+	TKIND_MODULE    = 3
+	TKIND_INTERFACE = 4
+	TKIND_DISPATCH  = 5
+	TKIND_COCLASS   = 6
+	TKIND_ALIAS     = 7
+	TKIND_UNION     = 8
+	TKIND_MAX       = 9
+)
+
+// Safe Array Feature Flags
+
+const (
+	FADF_AUTO        = 0x0001
+	FADF_STATIC      = 0x0002
+	FADF_EMBEDDED    = 0x0004
+	FADF_FIXEDSIZE   = 0x0010
+	FADF_RECORD      = 0x0020
+	FADF_HAVEIID     = 0x0040
+	FADF_HAVEVARTYPE = 0x0080
+	FADF_BSTR        = 0x0100
+	FADF_UNKNOWN     = 0x0200
+	FADF_DISPATCH    = 0x0400
+	FADF_VARIANT     = 0x0800
+	FADF_RESERVED    = 0xF008
+)

vendor/github.com/go-ole/go-ole/error.go

@@ -0,0 +1,51 @@
+package ole
+
+// OleError stores COM errors.
+type OleError struct {
+	hr          uintptr
+	description string
+	subError    error
+}
+
+// NewError creates new error with HResult.
+func NewError(hr uintptr) *OleError {
+	return &OleError{hr: hr}
+}
+
+// NewErrorWithDescription creates new COM error with HResult and description.
+func NewErrorWithDescription(hr uintptr, description string) *OleError {
+	return &OleError{hr: hr, description: description}
+}
+
+// NewErrorWithSubError creates new COM error with parent error.
+func NewErrorWithSubError(hr uintptr, description string, err error) *OleError {
+	return &OleError{hr: hr, description: description, subError: err}
+}
+
+// Code is the HResult.
+func (v *OleError) Code() uintptr {
+	return uintptr(v.hr)
+}
+
+// String description, either manually set or format message with error code.
+func (v *OleError) String() string {
+	if v.description != "" {
+		return errstr(int(v.hr)) + " (" + v.description + ")"
+	}
+	return errstr(int(v.hr))
+}
+
+// Error implements error interface.
+func (v *OleError) Error() string {
+	return v.String()
+}
+
+// Description retrieves error summary, if there is one.
+func (v *OleError) Description() string {
+	return v.description
+}
+
+// SubError returns parent error, if there is one.
+func (v *OleError) SubError() error {
+	return v.subError
+}

vendor/github.com/go-ole/go-ole/error_func.go

@@ -0,0 +1,8 @@
+// +build !windows
+
+package ole
+
+// errstr converts error code to string.
+func errstr(errno int) string {
+	return ""
+}

vendor/github.com/go-ole/go-ole/error_windows.go

@@ -0,0 +1,24 @@
+// +build windows
+
+package ole
+
+import (
+	"fmt"
+	"syscall"
+	"unicode/utf16"
+)
+
+// errstr converts error code to string.
+func errstr(errno int) string {
+	// ask windows for the remaining errors
+	var flags uint32 = syscall.FORMAT_MESSAGE_FROM_SYSTEM | syscall.FORMAT_MESSAGE_ARGUMENT_ARRAY | syscall.FORMAT_MESSAGE_IGNORE_INSERTS
+	b := make([]uint16, 300)
+	n, err := syscall.FormatMessage(flags, 0, uint32(errno), 0, b, nil)
+	if err != nil {
+		return fmt.Sprintf("error %d (FormatMessage failed with: %v)", errno, err)
+	}
+	// trim terminating \r and \n
+	for ; n > 0 && (b[n-1] == '\n' || b[n-1] == '\r'); n-- {
+	}
+	return string(utf16.Decode(b[:n]))
+}

vendor/github.com/go-ole/go-ole/go.mod

@@ -0,0 +1,5 @@
+module github.com/go-ole/go-ole
+
+go 1.12
+
+require golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3

vendor/github.com/go-ole/go-ole/go.sum

@@ -0,0 +1,2 @@
+golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3 h1:7TYNF4UdlohbFwpNH04CoPMp1cHUZgO1Ebq5r2hIjfo=
+golang.org/x/sys v0.0.0-20190916202348-b4ddaad3f8a3/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=

vendor/github.com/go-ole/go-ole/guid.go

@@ -0,0 +1,284 @@
+package ole
+
+var (
+	// IID_NULL is null Interface ID, used when no other Interface ID is known.
+	IID_NULL = NewGUID("{00000000-0000-0000-0000-000000000000}")
+
+	// IID_IUnknown is for IUnknown interfaces.
+	IID_IUnknown = NewGUID("{00000000-0000-0000-C000-000000000046}")
+
+	// IID_IDispatch is for IDispatch interfaces.
+	IID_IDispatch = NewGUID("{00020400-0000-0000-C000-000000000046}")
+
+	// IID_IEnumVariant is for IEnumVariant interfaces
+	IID_IEnumVariant = NewGUID("{00020404-0000-0000-C000-000000000046}")
+
+	// IID_IConnectionPointContainer is for IConnectionPointContainer interfaces.
+	IID_IConnectionPointContainer = NewGUID("{B196B284-BAB4-101A-B69C-00AA00341D07}")
+
+	// IID_IConnectionPoint is for IConnectionPoint interfaces.
+	IID_IConnectionPoint = NewGUID("{B196B286-BAB4-101A-B69C-00AA00341D07}")
+
+	// IID_IInspectable is for IInspectable interfaces.
+	IID_IInspectable = NewGUID("{AF86E2E0-B12D-4C6A-9C5A-D7AA65101E90}")
+
+	// IID_IProvideClassInfo is for IProvideClassInfo interfaces.
+	IID_IProvideClassInfo = NewGUID("{B196B283-BAB4-101A-B69C-00AA00341D07}")
+)
+
+// These are for testing and not part of any library.
+var (
+	// IID_ICOMTestString is for ICOMTestString interfaces.
+	//
+	// {E0133EB4-C36F-469A-9D3D-C66B84BE19ED}
+	IID_ICOMTestString = NewGUID("{E0133EB4-C36F-469A-9D3D-C66B84BE19ED}")
+
+	// IID_ICOMTestInt8 is for ICOMTestInt8 interfaces.
+	//
+	// {BEB06610-EB84-4155-AF58-E2BFF53680B4}
+	IID_ICOMTestInt8 = NewGUID("{BEB06610-EB84-4155-AF58-E2BFF53680B4}")
+
+	// IID_ICOMTestInt16 is for ICOMTestInt16 interfaces.
+	//
+	// {DAA3F9FA-761E-4976-A860-8364CE55F6FC}
+	IID_ICOMTestInt16 = NewGUID("{DAA3F9FA-761E-4976-A860-8364CE55F6FC}")
+
+	// IID_ICOMTestInt32 is for ICOMTestInt32 interfaces.
+	//
+	// {E3DEDEE7-38A2-4540-91D1-2EEF1D8891B0}
+	IID_ICOMTestInt32 = NewGUID("{E3DEDEE7-38A2-4540-91D1-2EEF1D8891B0}")
+
+	// IID_ICOMTestInt64 is for ICOMTestInt64 interfaces.
+	//
+	// {8D437CBC-B3ED-485C-BC32-C336432A1623}
+	IID_ICOMTestInt64 = NewGUID("{8D437CBC-B3ED-485C-BC32-C336432A1623}")
+
+	// IID_ICOMTestFloat is for ICOMTestFloat interfaces.
+	//
+	// {BF1ED004-EA02-456A-AA55-2AC8AC6B054C}
+	IID_ICOMTestFloat = NewGUID("{BF1ED004-EA02-456A-AA55-2AC8AC6B054C}")
+
+	// IID_ICOMTestDouble is for ICOMTestDouble interfaces.
+	//
+	// {BF908A81-8687-4E93-999F-D86FAB284BA0}
+	IID_ICOMTestDouble = NewGUID("{BF908A81-8687-4E93-999F-D86FAB284BA0}")
+
+	// IID_ICOMTestBoolean is for ICOMTestBoolean interfaces.
+	//
+	// {D530E7A6-4EE8-40D1-8931-3D63B8605010}
+	IID_ICOMTestBoolean = NewGUID("{D530E7A6-4EE8-40D1-8931-3D63B8605010}")
+
+	// IID_ICOMEchoTestObject is for ICOMEchoTestObject interfaces.
+	//
+	// {6485B1EF-D780-4834-A4FE-1EBB51746CA3}
+	IID_ICOMEchoTestObject = NewGUID("{6485B1EF-D780-4834-A4FE-1EBB51746CA3}")
+
+	// IID_ICOMTestTypes is for ICOMTestTypes interfaces.
+	//
+	// {CCA8D7AE-91C0-4277-A8B3-FF4EDF28D3C0}
+	IID_ICOMTestTypes = NewGUID("{CCA8D7AE-91C0-4277-A8B3-FF4EDF28D3C0}")
+
+	// CLSID_COMEchoTestObject is for COMEchoTestObject class.
+	//
+	// {3C24506A-AE9E-4D50-9157-EF317281F1B0}
+	CLSID_COMEchoTestObject = NewGUID("{3C24506A-AE9E-4D50-9157-EF317281F1B0}")
+
+	// CLSID_COMTestScalarClass is for COMTestScalarClass class.
+	//
+	// {865B85C5-0334-4AC6-9EF6-AACEC8FC5E86}
+	CLSID_COMTestScalarClass = NewGUID("{865B85C5-0334-4AC6-9EF6-AACEC8FC5E86}")
+)
+
+const hextable = "0123456789ABCDEF"
+const emptyGUID = "{00000000-0000-0000-0000-000000000000}"
+
+// GUID is Windows API specific GUID type.
+//
+// This exists to match Windows GUID type for direct passing for COM.
+// Format is in xxxxxxxx-xxxx-xxxx-xxxxxxxxxxxxxxxx.
+type GUID struct {
+	Data1 uint32
+	Data2 uint16
+	Data3 uint16
+	Data4 [8]byte
+}
+
+// NewGUID converts the given string into a globally unique identifier that is
+// compliant with the Windows API.
+//
+// The supplied string may be in any of these formats:
+//
+//  XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
+//  XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX
+//  {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}
+//
+// The conversion of the supplied string is not case-sensitive.
+func NewGUID(guid string) *GUID {
+	d := []byte(guid)
+	var d1, d2, d3, d4a, d4b []byte
+
+	switch len(d) {
+	case 38:
+		if d[0] != '{' || d[37] != '}' {
+			return nil
+		}
+		d = d[1:37]
+		fallthrough
+	case 36:
+		if d[8] != '-' || d[13] != '-' || d[18] != '-' || d[23] != '-' {
+			return nil
+		}
+		d1 = d[0:8]
+		d2 = d[9:13]
+		d3 = d[14:18]
+		d4a = d[19:23]
+		d4b = d[24:36]
+	case 32:
+		d1 = d[0:8]
+		d2 = d[8:12]
+		d3 = d[12:16]
+		d4a = d[16:20]
+		d4b = d[20:32]
+	default:
+		return nil
+	}
+
+	var g GUID
+	var ok1, ok2, ok3, ok4 bool
+	g.Data1, ok1 = decodeHexUint32(d1)
+	g.Data2, ok2 = decodeHexUint16(d2)
+	g.Data3, ok3 = decodeHexUint16(d3)
+	g.Data4, ok4 = decodeHexByte64(d4a, d4b)
+	if ok1 && ok2 && ok3 && ok4 {
+		return &g
+	}
+	return nil
+}
+
+func decodeHexUint32(src []byte) (value uint32, ok bool) {
+	var b1, b2, b3, b4 byte
+	var ok1, ok2, ok3, ok4 bool
+	b1, ok1 = decodeHexByte(src[0], src[1])
+	b2, ok2 = decodeHexByte(src[2], src[3])
+	b3, ok3 = decodeHexByte(src[4], src[5])
+	b4, ok4 = decodeHexByte(src[6], src[7])
+	value = (uint32(b1) << 24) | (uint32(b2) << 16) | (uint32(b3) << 8) | uint32(b4)
+	ok = ok1 && ok2 && ok3 && ok4
+	return
+}
+
+func decodeHexUint16(src []byte) (value uint16, ok bool) {
+	var b1, b2 byte
+	var ok1, ok2 bool
+	b1, ok1 = decodeHexByte(src[0], src[1])
+	b2, ok2 = decodeHexByte(src[2], src[3])
+	value = (uint16(b1) << 8) | uint16(b2)
+	ok = ok1 && ok2
+	return
+}
+
+func decodeHexByte64(s1 []byte, s2 []byte) (value [8]byte, ok bool) {
+	var ok1, ok2, ok3, ok4, ok5, ok6, ok7, ok8 bool
+	value[0], ok1 = decodeHexByte(s1[0], s1[1])
+	value[1], ok2 = decodeHexByte(s1[2], s1[3])
+	value[2], ok3 = decodeHexByte(s2[0], s2[1])
+	value[3], ok4 = decodeHexByte(s2[2], s2[3])
+	value[4], ok5 = decodeHexByte(s2[4], s2[5])
+	value[5], ok6 = decodeHexByte(s2[6], s2[7])
+	value[6], ok7 = decodeHexByte(s2[8], s2[9])
+	value[7], ok8 = decodeHexByte(s2[10], s2[11])
+	ok = ok1 && ok2 && ok3 && ok4 && ok5 && ok6 && ok7 && ok8
+	return
+}
+
+func decodeHexByte(c1, c2 byte) (value byte, ok bool) {
+	var n1, n2 byte
+	var ok1, ok2 bool
+	n1, ok1 = decodeHexChar(c1)
+	n2, ok2 = decodeHexChar(c2)
+	value = (n1 << 4) | n2
+	ok = ok1 && ok2
+	return
+}
+
+func decodeHexChar(c byte) (byte, bool) {
+	switch {
+	case '0' <= c && c <= '9':
+		return c - '0', true
+	case 'a' <= c && c <= 'f':
+		return c - 'a' + 10, true
+	case 'A' <= c && c <= 'F':
+		return c - 'A' + 10, true
+	}
+
+	return 0, false
+}
+
+// String converts the GUID to string form. It will adhere to this pattern:
+//
+//  {XXXXXXXX-XXXX-XXXX-XXXX-XXXXXXXXXXXX}
+//
+// If the GUID is nil, the string representation of an empty GUID is returned:
+//
+//  {00000000-0000-0000-0000-000000000000}
+func (guid *GUID) String() string {
+	if guid == nil {
+		return emptyGUID
+	}
+
+	var c [38]byte
+	c[0] = '{'
+	putUint32Hex(c[1:9], guid.Data1)
+	c[9] = '-'
+	putUint16Hex(c[10:14], guid.Data2)
+	c[14] = '-'
+	putUint16Hex(c[15:19], guid.Data3)
+	c[19] = '-'
+	putByteHex(c[20:24], guid.Data4[0:2])
+	c[24] = '-'
+	putByteHex(c[25:37], guid.Data4[2:8])
+	c[37] = '}'
+	return string(c[:])
+}
+
+func putUint32Hex(b []byte, v uint32) {
+	b[0] = hextable[byte(v>>24)>>4]
+	b[1] = hextable[byte(v>>24)&0x0f]
+	b[2] = hextable[byte(v>>16)>>4]
+	b[3] = hextable[byte(v>>16)&0x0f]
+	b[4] = hextable[byte(v>>8)>>4]
+	b[5] = hextable[byte(v>>8)&0x0f]
+	b[6] = hextable[byte(v)>>4]
+	b[7] = hextable[byte(v)&0x0f]
+}
+
+func putUint16Hex(b []byte, v uint16) {
+	b[0] = hextable[byte(v>>8)>>4]
+	b[1] = hextable[byte(v>>8)&0x0f]
+	b[2] = hextable[byte(v)>>4]
+	b[3] = hextable[byte(v)&0x0f]
+}
+
+func putByteHex(dst, src []byte) {
+	for i := 0; i < len(src); i++ {
+		dst[i*2] = hextable[src[i]>>4]
+		dst[i*2+1] = hextable[src[i]&0x0f]
+	}
+}
+
+// IsEqualGUID compares two GUID.
+//
+// Not constant time comparison.
+func IsEqualGUID(guid1 *GUID, guid2 *GUID) bool {
+	return guid1.Data1 == guid2.Data1 &&
+		guid1.Data2 == guid2.Data2 &&
+		guid1.Data3 == guid2.Data3 &&
+		guid1.Data4[0] == guid2.Data4[0] &&
+		guid1.Data4[1] == guid2.Data4[1] &&
+		guid1.Data4[2] == guid2.Data4[2] &&
+		guid1.Data4[3] == guid2.Data4[3] &&
+		guid1.Data4[4] == guid2.Data4[4] &&
+		guid1.Data4[5] == guid2.Data4[5] &&
+		guid1.Data4[6] == guid2.Data4[6] &&
+		guid1.Data4[7] == guid2.Data4[7]
+}

vendor/github.com/go-ole/go-ole/iconnectionpoint.go

@@ -0,0 +1,20 @@
+package ole
+
+import "unsafe"
+
+type IConnectionPoint struct {
+	IUnknown
+}
+
+type IConnectionPointVtbl struct {
+	IUnknownVtbl
+	GetConnectionInterface      uintptr
+	GetConnectionPointContainer uintptr
+	Advise                      uintptr
+	Unadvise                    uintptr
+	EnumConnections             uintptr
+}
+
+func (v *IConnectionPoint) VTable() *IConnectionPointVtbl {
+	return (*IConnectionPointVtbl)(unsafe.Pointer(v.RawVTable))
+}

vendor/github.com/go-ole/go-ole/iconnectionpoint_func.go

@@ -0,0 +1,21 @@
+// +build !windows
+
+package ole
+
+import "unsafe"
+
+func (v *IConnectionPoint) GetConnectionInterface(piid **GUID) int32 {
+	return int32(0)
+}
+
+func (v *IConnectionPoint) Advise(unknown *IUnknown) (uint32, error) {
+	return uint32(0), NewError(E_NOTIMPL)
+}
+
+func (v *IConnectionPoint) Unadvise(cookie uint32) error {
+	return NewError(E_NOTIMPL)
+}
+
+func (v *IConnectionPoint) EnumConnections(p *unsafe.Pointer) (err error) {
+	return NewError(E_NOTIMPL)
+}

vendor/github.com/go-ole/go-ole/iconnectionpoint_windows.go

@@ -0,0 +1,43 @@
+// +build windows
+
+package ole
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+func (v *IConnectionPoint) GetConnectionInterface(piid **GUID) int32 {
+	// XXX: This doesn't look like it does what it's supposed to
+	return release((*IUnknown)(unsafe.Pointer(v)))
+}
+
+func (v *IConnectionPoint) Advise(unknown *IUnknown) (cookie uint32, err error) {
+	hr, _, _ := syscall.Syscall(
+		v.VTable().Advise,
+		3,
+		uintptr(unsafe.Pointer(v)),
+		uintptr(unsafe.Pointer(unknown)),
+		uintptr(unsafe.Pointer(&cookie)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func (v *IConnectionPoint) Unadvise(cookie uint32) (err error) {
+	hr, _, _ := syscall.Syscall(
+		v.VTable().Unadvise,
+		2,
+		uintptr(unsafe.Pointer(v)),
+		uintptr(cookie),
+		0)
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func (v *IConnectionPoint) EnumConnections(p *unsafe.Pointer) error {
+	return NewError(E_NOTIMPL)
+}

vendor/github.com/go-ole/go-ole/iconnectionpointcontainer.go

@@ -0,0 +1,17 @@
+package ole
+
+import "unsafe"
+
+type IConnectionPointContainer struct {
+	IUnknown
+}
+
+type IConnectionPointContainerVtbl struct {
+	IUnknownVtbl
+	EnumConnectionPoints uintptr
+	FindConnectionPoint  uintptr
+}
+
+func (v *IConnectionPointContainer) VTable() *IConnectionPointContainerVtbl {
+	return (*IConnectionPointContainerVtbl)(unsafe.Pointer(v.RawVTable))
+}

vendor/github.com/go-ole/go-ole/iconnectionpointcontainer_func.go

@@ -0,0 +1,11 @@
+// +build !windows
+
+package ole
+
+func (v *IConnectionPointContainer) EnumConnectionPoints(points interface{}) error {
+	return NewError(E_NOTIMPL)
+}
+
+func (v *IConnectionPointContainer) FindConnectionPoint(iid *GUID, point **IConnectionPoint) error {
+	return NewError(E_NOTIMPL)
+}

vendor/github.com/go-ole/go-ole/iconnectionpointcontainer_windows.go

@@ -0,0 +1,25 @@
+// +build windows
+
+package ole
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+func (v *IConnectionPointContainer) EnumConnectionPoints(points interface{}) error {
+	return NewError(E_NOTIMPL)
+}
+
+func (v *IConnectionPointContainer) FindConnectionPoint(iid *GUID, point **IConnectionPoint) (err error) {
+	hr, _, _ := syscall.Syscall(
+		v.VTable().FindConnectionPoint,
+		3,
+		uintptr(unsafe.Pointer(v)),
+		uintptr(unsafe.Pointer(iid)),
+		uintptr(unsafe.Pointer(point)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}

vendor/github.com/go-ole/go-ole/idispatch.go

@@ -0,0 +1,94 @@
+package ole
+
+import "unsafe"
+
+type IDispatch struct {
+	IUnknown
+}
+
+type IDispatchVtbl struct {
+	IUnknownVtbl
+	GetTypeInfoCount uintptr
+	GetTypeInfo      uintptr
+	GetIDsOfNames    uintptr
+	Invoke           uintptr
+}
+
+func (v *IDispatch) VTable() *IDispatchVtbl {
+	return (*IDispatchVtbl)(unsafe.Pointer(v.RawVTable))
+}
+
+func (v *IDispatch) GetIDsOfName(names []string) (dispid []int32, err error) {
+	dispid, err = getIDsOfName(v, names)
+	return
+}
+
+func (v *IDispatch) Invoke(dispid int32, dispatch int16, params ...interface{}) (result *VARIANT, err error) {
+	result, err = invoke(v, dispid, dispatch, params...)
+	return
+}
+
+func (v *IDispatch) GetTypeInfoCount() (c uint32, err error) {
+	c, err = getTypeInfoCount(v)
+	return
+}
+
+func (v *IDispatch) GetTypeInfo() (tinfo *ITypeInfo, err error) {
+	tinfo, err = getTypeInfo(v)
+	return
+}
+
+// GetSingleIDOfName is a helper that returns single display ID for IDispatch name.
+//
+// This replaces the common pattern of attempting to get a single name from the list of available
+// IDs. It gives the first ID, if it is available.
+func (v *IDispatch) GetSingleIDOfName(name string) (displayID int32, err error) {
+	var displayIDs []int32
+	displayIDs, err = v.GetIDsOfName([]string{name})
+	if err != nil {
+		return
+	}
+	displayID = displayIDs[0]
+	return
+}
+
+// InvokeWithOptionalArgs accepts arguments as an array, works like Invoke.
+//
+// Accepts name and will attempt to retrieve Display ID to pass to Invoke.
+//
+// Passing params as an array is a workaround that could be fixed in later versions of Go that
+// prevent passing empty params. During testing it was discovered that this is an acceptable way of
+// getting around not being able to pass params normally.
+func (v *IDispatch) InvokeWithOptionalArgs(name string, dispatch int16, params []interface{}) (result *VARIANT, err error) {
+	displayID, err := v.GetSingleIDOfName(name)
+	if err != nil {
+		return
+	}
+
+	if len(params) < 1 {
+		result, err = v.Invoke(displayID, dispatch)
+	} else {
+		result, err = v.Invoke(displayID, dispatch, params...)
+	}
+
+	return
+}
+
+// CallMethod invokes named function with arguments on object.
+func (v *IDispatch) CallMethod(name string, params ...interface{}) (*VARIANT, error) {
+	return v.InvokeWithOptionalArgs(name, DISPATCH_METHOD, params)
+}
+
+// GetProperty retrieves the property with the name with the ability to pass arguments.
+//
+// Most of the time you will not need to pass arguments as most objects do not allow for this
+// feature. Or at least, should not allow for this feature. Some servers don't follow best practices
+// and this is provided for those edge cases.
+func (v *IDispatch) GetProperty(name string, params ...interface{}) (*VARIANT, error) {
+	return v.InvokeWithOptionalArgs(name, DISPATCH_PROPERTYGET, params)
+}
+
+// PutProperty attempts to mutate a property in the object.
+func (v *IDispatch) PutProperty(name string, params ...interface{}) (*VARIANT, error) {
+	return v.InvokeWithOptionalArgs(name, DISPATCH_PROPERTYPUT, params)
+}

vendor/github.com/go-ole/go-ole/idispatch_func.go

@@ -0,0 +1,19 @@
+// +build !windows
+
+package ole
+
+func getIDsOfName(disp *IDispatch, names []string) ([]int32, error) {
+	return []int32{}, NewError(E_NOTIMPL)
+}
+
+func getTypeInfoCount(disp *IDispatch) (uint32, error) {
+	return uint32(0), NewError(E_NOTIMPL)
+}
+
+func getTypeInfo(disp *IDispatch) (*ITypeInfo, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+func invoke(disp *IDispatch, dispid int32, dispatch int16, params ...interface{}) (*VARIANT, error) {
+	return nil, NewError(E_NOTIMPL)
+}

vendor/github.com/go-ole/go-ole/idispatch_windows.go

@@ -0,0 +1,200 @@
+// +build windows
+
+package ole
+
+import (
+	"math/big"
+	"syscall"
+	"time"
+	"unsafe"
+)
+
+func getIDsOfName(disp *IDispatch, names []string) (dispid []int32, err error) {
+	wnames := make([]*uint16, len(names))
+	for i := 0; i < len(names); i++ {
+		wnames[i] = syscall.StringToUTF16Ptr(names[i])
+	}
+	dispid = make([]int32, len(names))
+	namelen := uint32(len(names))
+	hr, _, _ := syscall.Syscall6(
+		disp.VTable().GetIDsOfNames,
+		6,
+		uintptr(unsafe.Pointer(disp)),
+		uintptr(unsafe.Pointer(IID_NULL)),
+		uintptr(unsafe.Pointer(&wnames[0])),
+		uintptr(namelen),
+		uintptr(GetUserDefaultLCID()),
+		uintptr(unsafe.Pointer(&dispid[0])))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func getTypeInfoCount(disp *IDispatch) (c uint32, err error) {
+	hr, _, _ := syscall.Syscall(
+		disp.VTable().GetTypeInfoCount,
+		2,
+		uintptr(unsafe.Pointer(disp)),
+		uintptr(unsafe.Pointer(&c)),
+		0)
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func getTypeInfo(disp *IDispatch) (tinfo *ITypeInfo, err error) {
+	hr, _, _ := syscall.Syscall(
+		disp.VTable().GetTypeInfo,
+		3,
+		uintptr(unsafe.Pointer(disp)),
+		uintptr(GetUserDefaultLCID()),
+		uintptr(unsafe.Pointer(&tinfo)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func invoke(disp *IDispatch, dispid int32, dispatch int16, params ...interface{}) (result *VARIANT, err error) {
+	var dispparams DISPPARAMS
+
+	if dispatch&DISPATCH_PROPERTYPUT != 0 {
+		dispnames := [1]int32{DISPID_PROPERTYPUT}
+		dispparams.rgdispidNamedArgs = uintptr(unsafe.Pointer(&dispnames[0]))
+		dispparams.cNamedArgs = 1
+	} else if dispatch&DISPATCH_PROPERTYPUTREF != 0 {
+		dispnames := [1]int32{DISPID_PROPERTYPUT}
+		dispparams.rgdispidNamedArgs = uintptr(unsafe.Pointer(&dispnames[0]))
+		dispparams.cNamedArgs = 1
+	}
+	var vargs []VARIANT
+	if len(params) > 0 {
+		vargs = make([]VARIANT, len(params))
+		for i, v := range params {
+			//n := len(params)-i-1
+			n := len(params) - i - 1
+			VariantInit(&vargs[n])
+			switch vv := v.(type) {
+			case bool:
+				if vv {
+					vargs[n] = NewVariant(VT_BOOL, 0xffff)
+				} else {
+					vargs[n] = NewVariant(VT_BOOL, 0)
+				}
+			case *bool:
+				vargs[n] = NewVariant(VT_BOOL|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*bool)))))
+			case uint8:
+				vargs[n] = NewVariant(VT_I1, int64(v.(uint8)))
+			case *uint8:
+				vargs[n] = NewVariant(VT_I1|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint8)))))
+			case int8:
+				vargs[n] = NewVariant(VT_I1, int64(v.(int8)))
+			case *int8:
+				vargs[n] = NewVariant(VT_I1|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint8)))))
+			case int16:
+				vargs[n] = NewVariant(VT_I2, int64(v.(int16)))
+			case *int16:
+				vargs[n] = NewVariant(VT_I2|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*int16)))))
+			case uint16:
+				vargs[n] = NewVariant(VT_UI2, int64(v.(uint16)))
+			case *uint16:
+				vargs[n] = NewVariant(VT_UI2|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint16)))))
+			case int32:
+				vargs[n] = NewVariant(VT_I4, int64(v.(int32)))
+			case *int32:
+				vargs[n] = NewVariant(VT_I4|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*int32)))))
+			case uint32:
+				vargs[n] = NewVariant(VT_UI4, int64(v.(uint32)))
+			case *uint32:
+				vargs[n] = NewVariant(VT_UI4|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint32)))))
+			case int64:
+				vargs[n] = NewVariant(VT_I8, int64(v.(int64)))
+			case *int64:
+				vargs[n] = NewVariant(VT_I8|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*int64)))))
+			case uint64:
+				vargs[n] = NewVariant(VT_UI8, int64(uintptr(v.(uint64))))
+			case *uint64:
+				vargs[n] = NewVariant(VT_UI8|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint64)))))
+			case int:
+				vargs[n] = NewVariant(VT_I4, int64(v.(int)))
+			case *int:
+				vargs[n] = NewVariant(VT_I4|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*int)))))
+			case uint:
+				vargs[n] = NewVariant(VT_UI4, int64(v.(uint)))
+			case *uint:
+				vargs[n] = NewVariant(VT_UI4|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*uint)))))
+			case float32:
+				vargs[n] = NewVariant(VT_R4, *(*int64)(unsafe.Pointer(&vv)))
+			case *float32:
+				vargs[n] = NewVariant(VT_R4|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*float32)))))
+			case float64:
+				vargs[n] = NewVariant(VT_R8, *(*int64)(unsafe.Pointer(&vv)))
+			case *float64:
+				vargs[n] = NewVariant(VT_R8|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*float64)))))
+			case *big.Int:
+				vargs[n] = NewVariant(VT_DECIMAL, v.(*big.Int).Int64())
+			case string:
+				vargs[n] = NewVariant(VT_BSTR, int64(uintptr(unsafe.Pointer(SysAllocStringLen(v.(string))))))
+			case *string:
+				vargs[n] = NewVariant(VT_BSTR|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*string)))))
+			case time.Time:
+				s := vv.Format("2006-01-02 15:04:05")
+				vargs[n] = NewVariant(VT_BSTR, int64(uintptr(unsafe.Pointer(SysAllocStringLen(s)))))
+			case *time.Time:
+				s := vv.Format("2006-01-02 15:04:05")
+				vargs[n] = NewVariant(VT_BSTR|VT_BYREF, int64(uintptr(unsafe.Pointer(&s))))
+			case *IDispatch:
+				vargs[n] = NewVariant(VT_DISPATCH, int64(uintptr(unsafe.Pointer(v.(*IDispatch)))))
+			case **IDispatch:
+				vargs[n] = NewVariant(VT_DISPATCH|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(**IDispatch)))))
+			case nil:
+				vargs[n] = NewVariant(VT_NULL, 0)
+			case *VARIANT:
+				vargs[n] = NewVariant(VT_VARIANT|VT_BYREF, int64(uintptr(unsafe.Pointer(v.(*VARIANT)))))
+			case []byte:
+				safeByteArray := safeArrayFromByteSlice(v.([]byte))
+				vargs[n] = NewVariant(VT_ARRAY|VT_UI1, int64(uintptr(unsafe.Pointer(safeByteArray))))
+				defer VariantClear(&vargs[n])
+			case []string:
+				safeByteArray := safeArrayFromStringSlice(v.([]string))
+				vargs[n] = NewVariant(VT_ARRAY|VT_BSTR, int64(uintptr(unsafe.Pointer(safeByteArray))))
+				defer VariantClear(&vargs[n])
+			default:
+				panic("unknown type")
+			}
+		}
+		dispparams.rgvarg = uintptr(unsafe.Pointer(&vargs[0]))
+		dispparams.cArgs = uint32(len(params))
+	}
+
+	result = new(VARIANT)
+	var excepInfo EXCEPINFO
+	VariantInit(result)
+	hr, _, _ := syscall.Syscall9(
+		disp.VTable().Invoke,
+		9,
+		uintptr(unsafe.Pointer(disp)),
+		uintptr(dispid),
+		uintptr(unsafe.Pointer(IID_NULL)),
+		uintptr(GetUserDefaultLCID()),
+		uintptr(dispatch),
+		uintptr(unsafe.Pointer(&dispparams)),
+		uintptr(unsafe.Pointer(result)),
+		uintptr(unsafe.Pointer(&excepInfo)),
+		0)
+	if hr != 0 {
+		err = NewErrorWithSubError(hr, BstrToString(excepInfo.bstrDescription), excepInfo)
+	}
+	for i, varg := range vargs {
+		n := len(params) - i - 1
+		if varg.VT == VT_BSTR && varg.Val != 0 {
+			SysFreeString(((*int16)(unsafe.Pointer(uintptr(varg.Val)))))
+		}
+		if varg.VT == (VT_BSTR|VT_BYREF) && varg.Val != 0 {
+			*(params[n].(*string)) = LpOleStrToString(*(**uint16)(unsafe.Pointer(uintptr(varg.Val))))
+		}
+	}
+	return
+}

vendor/github.com/go-ole/go-ole/ienumvariant.go

@@ -0,0 +1,19 @@
+package ole
+
+import "unsafe"
+
+type IEnumVARIANT struct {
+	IUnknown
+}
+
+type IEnumVARIANTVtbl struct {
+	IUnknownVtbl
+	Next  uintptr
+	Skip  uintptr
+	Reset uintptr
+	Clone uintptr
+}
+
+func (v *IEnumVARIANT) VTable() *IEnumVARIANTVtbl {
+	return (*IEnumVARIANTVtbl)(unsafe.Pointer(v.RawVTable))
+}

vendor/github.com/go-ole/go-ole/ienumvariant_func.go

@@ -0,0 +1,19 @@
+// +build !windows
+
+package ole
+
+func (enum *IEnumVARIANT) Clone() (*IEnumVARIANT, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+func (enum *IEnumVARIANT) Reset() error {
+	return NewError(E_NOTIMPL)
+}
+
+func (enum *IEnumVARIANT) Skip(celt uint) error {
+	return NewError(E_NOTIMPL)
+}
+
+func (enum *IEnumVARIANT) Next(celt uint) (VARIANT, uint, error) {
+	return NewVariant(VT_NULL, int64(0)), 0, NewError(E_NOTIMPL)
+}

vendor/github.com/go-ole/go-ole/ienumvariant_windows.go

@@ -0,0 +1,63 @@
+// +build windows
+
+package ole
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+func (enum *IEnumVARIANT) Clone() (cloned *IEnumVARIANT, err error) {
+	hr, _, _ := syscall.Syscall(
+		enum.VTable().Clone,
+		2,
+		uintptr(unsafe.Pointer(enum)),
+		uintptr(unsafe.Pointer(&cloned)),
+		0)
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func (enum *IEnumVARIANT) Reset() (err error) {
+	hr, _, _ := syscall.Syscall(
+		enum.VTable().Reset,
+		1,
+		uintptr(unsafe.Pointer(enum)),
+		0,
+		0)
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func (enum *IEnumVARIANT) Skip(celt uint) (err error) {
+	hr, _, _ := syscall.Syscall(
+		enum.VTable().Skip,
+		2,
+		uintptr(unsafe.Pointer(enum)),
+		uintptr(celt),
+		0)
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func (enum *IEnumVARIANT) Next(celt uint) (array VARIANT, length uint, err error) {
+	hr, _, _ := syscall.Syscall6(
+		enum.VTable().Next,
+		4,
+		uintptr(unsafe.Pointer(enum)),
+		uintptr(celt),
+		uintptr(unsafe.Pointer(&array)),
+		uintptr(unsafe.Pointer(&length)),
+		0,
+		0)
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}

vendor/github.com/go-ole/go-ole/iinspectable.go

@@ -0,0 +1,18 @@
+package ole
+
+import "unsafe"
+
+type IInspectable struct {
+	IUnknown
+}
+
+type IInspectableVtbl struct {
+	IUnknownVtbl
+	GetIIds             uintptr
+	GetRuntimeClassName uintptr
+	GetTrustLevel       uintptr
+}
+
+func (v *IInspectable) VTable() *IInspectableVtbl {
+	return (*IInspectableVtbl)(unsafe.Pointer(v.RawVTable))
+}

vendor/github.com/go-ole/go-ole/iinspectable_func.go

@@ -0,0 +1,15 @@
+// +build !windows
+
+package ole
+
+func (v *IInspectable) GetIids() ([]*GUID, error) {
+	return []*GUID{}, NewError(E_NOTIMPL)
+}
+
+func (v *IInspectable) GetRuntimeClassName() (string, error) {
+	return "", NewError(E_NOTIMPL)
+}
+
+func (v *IInspectable) GetTrustLevel() (uint32, error) {
+	return uint32(0), NewError(E_NOTIMPL)
+}

vendor/github.com/go-ole/go-ole/iinspectable_windows.go

@@ -0,0 +1,72 @@
+// +build windows
+
+package ole
+
+import (
+	"bytes"
+	"encoding/binary"
+	"reflect"
+	"syscall"
+	"unsafe"
+)
+
+func (v *IInspectable) GetIids() (iids []*GUID, err error) {
+	var count uint32
+	var array uintptr
+	hr, _, _ := syscall.Syscall(
+		v.VTable().GetIIds,
+		3,
+		uintptr(unsafe.Pointer(v)),
+		uintptr(unsafe.Pointer(&count)),
+		uintptr(unsafe.Pointer(&array)))
+	if hr != 0 {
+		err = NewError(hr)
+		return
+	}
+	defer CoTaskMemFree(array)
+
+	iids = make([]*GUID, count)
+	byteCount := count * uint32(unsafe.Sizeof(GUID{}))
+	slicehdr := reflect.SliceHeader{Data: array, Len: int(byteCount), Cap: int(byteCount)}
+	byteSlice := *(*[]byte)(unsafe.Pointer(&slicehdr))
+	reader := bytes.NewReader(byteSlice)
+	for i := range iids {
+		guid := GUID{}
+		err = binary.Read(reader, binary.LittleEndian, &guid)
+		if err != nil {
+			return
+		}
+		iids[i] = &guid
+	}
+	return
+}
+
+func (v *IInspectable) GetRuntimeClassName() (s string, err error) {
+	var hstring HString
+	hr, _, _ := syscall.Syscall(
+		v.VTable().GetRuntimeClassName,
+		2,
+		uintptr(unsafe.Pointer(v)),
+		uintptr(unsafe.Pointer(&hstring)),
+		0)
+	if hr != 0 {
+		err = NewError(hr)
+		return
+	}
+	s = hstring.String()
+	DeleteHString(hstring)
+	return
+}
+
+func (v *IInspectable) GetTrustLevel() (level uint32, err error) {
+	hr, _, _ := syscall.Syscall(
+		v.VTable().GetTrustLevel,
+		2,
+		uintptr(unsafe.Pointer(v)),
+		uintptr(unsafe.Pointer(&level)),
+		0)
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}

vendor/github.com/go-ole/go-ole/iprovideclassinfo.go

@@ -0,0 +1,21 @@
+package ole
+
+import "unsafe"
+
+type IProvideClassInfo struct {
+	IUnknown
+}
+
+type IProvideClassInfoVtbl struct {
+	IUnknownVtbl
+	GetClassInfo uintptr
+}
+
+func (v *IProvideClassInfo) VTable() *IProvideClassInfoVtbl {
+	return (*IProvideClassInfoVtbl)(unsafe.Pointer(v.RawVTable))
+}
+
+func (v *IProvideClassInfo) GetClassInfo() (cinfo *ITypeInfo, err error) {
+	cinfo, err = getClassInfo(v)
+	return
+}

vendor/github.com/go-ole/go-ole/iprovideclassinfo_func.go

@@ -0,0 +1,7 @@
+// +build !windows
+
+package ole
+
+func getClassInfo(disp *IProvideClassInfo) (tinfo *ITypeInfo, err error) {
+	return nil, NewError(E_NOTIMPL)
+}

vendor/github.com/go-ole/go-ole/iprovideclassinfo_windows.go

@@ -0,0 +1,21 @@
+// +build windows
+
+package ole
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+func getClassInfo(disp *IProvideClassInfo) (tinfo *ITypeInfo, err error) {
+	hr, _, _ := syscall.Syscall(
+		disp.VTable().GetClassInfo,
+		2,
+		uintptr(unsafe.Pointer(disp)),
+		uintptr(unsafe.Pointer(&tinfo)),
+		0)
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}

vendor/github.com/go-ole/go-ole/itypeinfo.go

@@ -0,0 +1,34 @@
+package ole
+
+import "unsafe"
+
+type ITypeInfo struct {
+	IUnknown
+}
+
+type ITypeInfoVtbl struct {
+	IUnknownVtbl
+	GetTypeAttr          uintptr
+	GetTypeComp          uintptr
+	GetFuncDesc          uintptr
+	GetVarDesc           uintptr
+	GetNames             uintptr
+	GetRefTypeOfImplType uintptr
+	GetImplTypeFlags     uintptr
+	GetIDsOfNames        uintptr
+	Invoke               uintptr
+	GetDocumentation     uintptr
+	GetDllEntry          uintptr
+	GetRefTypeInfo       uintptr
+	AddressOfMember      uintptr
+	CreateInstance       uintptr
+	GetMops              uintptr
+	GetContainingTypeLib uintptr
+	ReleaseTypeAttr      uintptr
+	ReleaseFuncDesc      uintptr
+	ReleaseVarDesc       uintptr
+}
+
+func (v *ITypeInfo) VTable() *ITypeInfoVtbl {
+	return (*ITypeInfoVtbl)(unsafe.Pointer(v.RawVTable))
+}

vendor/github.com/go-ole/go-ole/itypeinfo_func.go

@@ -0,0 +1,7 @@
+// +build !windows
+
+package ole
+
+func (v *ITypeInfo) GetTypeAttr() (*TYPEATTR, error) {
+	return nil, NewError(E_NOTIMPL)
+}

vendor/github.com/go-ole/go-ole/itypeinfo_windows.go

@@ -0,0 +1,21 @@
+// +build windows
+
+package ole
+
+import (
+	"syscall"
+	"unsafe"
+)
+
+func (v *ITypeInfo) GetTypeAttr() (tattr *TYPEATTR, err error) {
+	hr, _, _ := syscall.Syscall(
+		uintptr(v.VTable().GetTypeAttr),
+		2,
+		uintptr(unsafe.Pointer(v)),
+		uintptr(unsafe.Pointer(&tattr)),
+		0)
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}

vendor/github.com/go-ole/go-ole/iunknown.go

@@ -0,0 +1,57 @@
+package ole
+
+import "unsafe"
+
+type IUnknown struct {
+	RawVTable *interface{}
+}
+
+type IUnknownVtbl struct {
+	QueryInterface uintptr
+	AddRef         uintptr
+	Release        uintptr
+}
+
+type UnknownLike interface {
+	QueryInterface(iid *GUID) (disp *IDispatch, err error)
+	AddRef() int32
+	Release() int32
+}
+
+func (v *IUnknown) VTable() *IUnknownVtbl {
+	return (*IUnknownVtbl)(unsafe.Pointer(v.RawVTable))
+}
+
+func (v *IUnknown) PutQueryInterface(interfaceID *GUID, obj interface{}) error {
+	return reflectQueryInterface(v, v.VTable().QueryInterface, interfaceID, obj)
+}
+
+func (v *IUnknown) IDispatch(interfaceID *GUID) (dispatch *IDispatch, err error) {
+	err = v.PutQueryInterface(interfaceID, &dispatch)
+	return
+}
+
+func (v *IUnknown) IEnumVARIANT(interfaceID *GUID) (enum *IEnumVARIANT, err error) {
+	err = v.PutQueryInterface(interfaceID, &enum)
+	return
+}
+
+func (v *IUnknown) QueryInterface(iid *GUID) (*IDispatch, error) {
+	return queryInterface(v, iid)
+}
+
+func (v *IUnknown) MustQueryInterface(iid *GUID) (disp *IDispatch) {
+	unk, err := queryInterface(v, iid)
+	if err != nil {
+		panic(err)
+	}
+	return unk
+}
+
+func (v *IUnknown) AddRef() int32 {
+	return addRef(v)
+}
+
+func (v *IUnknown) Release() int32 {
+	return release(v)
+}

vendor/github.com/go-ole/go-ole/iunknown_func.go

@@ -0,0 +1,19 @@
+// +build !windows
+
+package ole
+
+func reflectQueryInterface(self interface{}, method uintptr, interfaceID *GUID, obj interface{}) (err error) {
+	return NewError(E_NOTIMPL)
+}
+
+func queryInterface(unk *IUnknown, iid *GUID) (disp *IDispatch, err error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+func addRef(unk *IUnknown) int32 {
+	return 0
+}
+
+func release(unk *IUnknown) int32 {
+	return 0
+}

vendor/github.com/go-ole/go-ole/iunknown_windows.go

@@ -0,0 +1,58 @@
+// +build windows
+
+package ole
+
+import (
+	"reflect"
+	"syscall"
+	"unsafe"
+)
+
+func reflectQueryInterface(self interface{}, method uintptr, interfaceID *GUID, obj interface{}) (err error) {
+	selfValue := reflect.ValueOf(self).Elem()
+	objValue := reflect.ValueOf(obj).Elem()
+
+	hr, _, _ := syscall.Syscall(
+		method,
+		3,
+		selfValue.UnsafeAddr(),
+		uintptr(unsafe.Pointer(interfaceID)),
+		objValue.Addr().Pointer())
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func queryInterface(unk *IUnknown, iid *GUID) (disp *IDispatch, err error) {
+	hr, _, _ := syscall.Syscall(
+		unk.VTable().QueryInterface,
+		3,
+		uintptr(unsafe.Pointer(unk)),
+		uintptr(unsafe.Pointer(iid)),
+		uintptr(unsafe.Pointer(&disp)))
+	if hr != 0 {
+		err = NewError(hr)
+	}
+	return
+}
+
+func addRef(unk *IUnknown) int32 {
+	ret, _, _ := syscall.Syscall(
+		unk.VTable().AddRef,
+		1,
+		uintptr(unsafe.Pointer(unk)),
+		0,
+		0)
+	return int32(ret)
+}
+
+func release(unk *IUnknown) int32 {
+	ret, _, _ := syscall.Syscall(
+		unk.VTable().Release,
+		1,
+		uintptr(unsafe.Pointer(unk)),
+		0,
+		0)
+	return int32(ret)
+}

vendor/github.com/go-ole/go-ole/ole.go

@@ -0,0 +1,157 @@
+package ole
+
+import (
+	"fmt"
+	"strings"
+)
+
+// DISPPARAMS are the arguments that passed to methods or property.
+type DISPPARAMS struct {
+	rgvarg            uintptr
+	rgdispidNamedArgs uintptr
+	cArgs             uint32
+	cNamedArgs        uint32
+}
+
+// EXCEPINFO defines exception info.
+type EXCEPINFO struct {
+	wCode             uint16
+	wReserved         uint16
+	bstrSource        *uint16
+	bstrDescription   *uint16
+	bstrHelpFile      *uint16
+	dwHelpContext     uint32
+	pvReserved        uintptr
+	pfnDeferredFillIn uintptr
+	scode             uint32
+}
+
+// WCode return wCode in EXCEPINFO.
+func (e EXCEPINFO) WCode() uint16 {
+	return e.wCode
+}
+
+// SCODE return scode in EXCEPINFO.
+func (e EXCEPINFO) SCODE() uint32 {
+	return e.scode
+}
+
+// String convert EXCEPINFO to string.
+func (e EXCEPINFO) String() string {
+	var src, desc, hlp string
+	if e.bstrSource == nil {
+		src = "<nil>"
+	} else {
+		src = BstrToString(e.bstrSource)
+	}
+
+	if e.bstrDescription == nil {
+		desc = "<nil>"
+	} else {
+		desc = BstrToString(e.bstrDescription)
+	}
+
+	if e.bstrHelpFile == nil {
+		hlp = "<nil>"
+	} else {
+		hlp = BstrToString(e.bstrHelpFile)
+	}
+
+	return fmt.Sprintf(
+		"wCode: %#x, bstrSource: %v, bstrDescription: %v, bstrHelpFile: %v, dwHelpContext: %#x, scode: %#x",
+		e.wCode, src, desc, hlp, e.dwHelpContext, e.scode,
+	)
+}
+
+// Error implements error interface and returns error string.
+func (e EXCEPINFO) Error() string {
+	if e.bstrDescription != nil {
+		return strings.TrimSpace(BstrToString(e.bstrDescription))
+	}
+
+	src := "Unknown"
+	if e.bstrSource != nil {
+		src = BstrToString(e.bstrSource)
+	}
+
+	code := e.scode
+	if e.wCode != 0 {
+		code = uint32(e.wCode)
+	}
+
+	return fmt.Sprintf("%v: %#x", src, code)
+}
+
+// PARAMDATA defines parameter data type.
+type PARAMDATA struct {
+	Name *int16
+	Vt   uint16
+}
+
+// METHODDATA defines method info.
+type METHODDATA struct {
+	Name     *uint16
+	Data     *PARAMDATA
+	Dispid   int32
+	Meth     uint32
+	CC       int32
+	CArgs    uint32
+	Flags    uint16
+	VtReturn uint32
+}
+
+// INTERFACEDATA defines interface info.
+type INTERFACEDATA struct {
+	MethodData *METHODDATA
+	CMembers   uint32
+}
+
+// Point is 2D vector type.
+type Point struct {
+	X int32
+	Y int32
+}
+
+// Msg is message between processes.
+type Msg struct {
+	Hwnd    uint32
+	Message uint32
+	Wparam  int32
+	Lparam  int32
+	Time    uint32
+	Pt      Point
+}
+
+// TYPEDESC defines data type.
+type TYPEDESC struct {
+	Hreftype uint32
+	VT       uint16
+}
+
+// IDLDESC defines IDL info.
+type IDLDESC struct {
+	DwReserved uint32
+	WIDLFlags  uint16
+}
+
+// TYPEATTR defines type info.
+type TYPEATTR struct {
+	Guid             GUID
+	Lcid             uint32
+	dwReserved       uint32
+	MemidConstructor int32
+	MemidDestructor  int32
+	LpstrSchema      *uint16
+	CbSizeInstance   uint32
+	Typekind         int32
+	CFuncs           uint16
+	CVars            uint16
+	CImplTypes       uint16
+	CbSizeVft        uint16
+	CbAlignment      uint16
+	WTypeFlags       uint16
+	WMajorVerNum     uint16
+	WMinorVerNum     uint16
+	TdescAlias       TYPEDESC
+	IdldescType      IDLDESC
+}

vendor/github.com/go-ole/go-ole/oleutil/connection.go

@@ -0,0 +1,100 @@
+// +build windows
+
+package oleutil
+
+import (
+	"reflect"
+	"unsafe"
+
+	ole "github.com/go-ole/go-ole"
+)
+
+type stdDispatch struct {
+	lpVtbl  *stdDispatchVtbl
+	ref     int32
+	iid     *ole.GUID
+	iface   interface{}
+	funcMap map[string]int32
+}
+
+type stdDispatchVtbl struct {
+	pQueryInterface   uintptr
+	pAddRef           uintptr
+	pRelease          uintptr
+	pGetTypeInfoCount uintptr
+	pGetTypeInfo      uintptr
+	pGetIDsOfNames    uintptr
+	pInvoke           uintptr
+}
+
+func dispQueryInterface(this *ole.IUnknown, iid *ole.GUID, punk **ole.IUnknown) uint32 {
+	pthis := (*stdDispatch)(unsafe.Pointer(this))
+	*punk = nil
+	if ole.IsEqualGUID(iid, ole.IID_IUnknown) ||
+		ole.IsEqualGUID(iid, ole.IID_IDispatch) {
+		dispAddRef(this)
+		*punk = this
+		return ole.S_OK
+	}
+	if ole.IsEqualGUID(iid, pthis.iid) {
+		dispAddRef(this)
+		*punk = this
+		return ole.S_OK
+	}
+	return ole.E_NOINTERFACE
+}
+
+func dispAddRef(this *ole.IUnknown) int32 {
+	pthis := (*stdDispatch)(unsafe.Pointer(this))
+	pthis.ref++
+	return pthis.ref
+}
+
+func dispRelease(this *ole.IUnknown) int32 {
+	pthis := (*stdDispatch)(unsafe.Pointer(this))
+	pthis.ref--
+	return pthis.ref
+}
+
+func dispGetIDsOfNames(this *ole.IUnknown, iid *ole.GUID, wnames []*uint16, namelen int, lcid int, pdisp []int32) uintptr {
+	pthis := (*stdDispatch)(unsafe.Pointer(this))
+	names := make([]string, len(wnames))
+	for i := 0; i < len(names); i++ {
+		names[i] = ole.LpOleStrToString(wnames[i])
+	}
+	for n := 0; n < namelen; n++ {
+		if id, ok := pthis.funcMap[names[n]]; ok {
+			pdisp[n] = id
+		}
+	}
+	return ole.S_OK
+}
+
+func dispGetTypeInfoCount(pcount *int) uintptr {
+	if pcount != nil {
+		*pcount = 0
+	}
+	return ole.S_OK
+}
+
+func dispGetTypeInfo(ptypeif *uintptr) uintptr {
+	return ole.E_NOTIMPL
+}
+
+func dispInvoke(this *ole.IDispatch, dispid int32, riid *ole.GUID, lcid int, flags int16, dispparams *ole.DISPPARAMS, result *ole.VARIANT, pexcepinfo *ole.EXCEPINFO, nerr *uint) uintptr {
+	pthis := (*stdDispatch)(unsafe.Pointer(this))
+	found := ""
+	for name, id := range pthis.funcMap {
+		if id == dispid {
+			found = name
+		}
+	}
+	if found != "" {
+		rv := reflect.ValueOf(pthis.iface).Elem()
+		rm := rv.MethodByName(found)
+		rr := rm.Call([]reflect.Value{})
+		println(len(rr))
+		return ole.S_OK
+	}
+	return ole.E_NOTIMPL
+}

vendor/github.com/go-ole/go-ole/oleutil/connection_func.go

@@ -0,0 +1,10 @@
+// +build !windows
+
+package oleutil
+
+import ole "github.com/go-ole/go-ole"
+
+// ConnectObject creates a connection point between two services for communication.
+func ConnectObject(disp *ole.IDispatch, iid *ole.GUID, idisp interface{}) (uint32, error) {
+	return 0, ole.NewError(ole.E_NOTIMPL)
+}

vendor/github.com/go-ole/go-ole/oleutil/connection_windows.go

@@ -0,0 +1,58 @@
+// +build windows
+
+package oleutil
+
+import (
+	"reflect"
+	"syscall"
+	"unsafe"
+
+	ole "github.com/go-ole/go-ole"
+)
+
+// ConnectObject creates a connection point between two services for communication.
+func ConnectObject(disp *ole.IDispatch, iid *ole.GUID, idisp interface{}) (cookie uint32, err error) {
+	unknown, err := disp.QueryInterface(ole.IID_IConnectionPointContainer)
+	if err != nil {
+		return
+	}
+
+	container := (*ole.IConnectionPointContainer)(unsafe.Pointer(unknown))
+	var point *ole.IConnectionPoint
+	err = container.FindConnectionPoint(iid, &point)
+	if err != nil {
+		return
+	}
+	if edisp, ok := idisp.(*ole.IUnknown); ok {
+		cookie, err = point.Advise(edisp)
+		container.Release()
+		if err != nil {
+			return
+		}
+	}
+	rv := reflect.ValueOf(disp).Elem()
+	if rv.Type().Kind() == reflect.Struct {
+		dest := &stdDispatch{}
+		dest.lpVtbl = &stdDispatchVtbl{}
+		dest.lpVtbl.pQueryInterface = syscall.NewCallback(dispQueryInterface)
+		dest.lpVtbl.pAddRef = syscall.NewCallback(dispAddRef)
+		dest.lpVtbl.pRelease = syscall.NewCallback(dispRelease)
+		dest.lpVtbl.pGetTypeInfoCount = syscall.NewCallback(dispGetTypeInfoCount)
+		dest.lpVtbl.pGetTypeInfo = syscall.NewCallback(dispGetTypeInfo)
+		dest.lpVtbl.pGetIDsOfNames = syscall.NewCallback(dispGetIDsOfNames)
+		dest.lpVtbl.pInvoke = syscall.NewCallback(dispInvoke)
+		dest.iface = disp
+		dest.iid = iid
+		cookie, err = point.Advise((*ole.IUnknown)(unsafe.Pointer(dest)))
+		container.Release()
+		if err != nil {
+			point.Release()
+			return
+		}
+		return
+	}
+
+	container.Release()
+
+	return 0, ole.NewError(ole.E_INVALIDARG)
+}

vendor/github.com/go-ole/go-ole/oleutil/go-get.go

@@ -0,0 +1,6 @@
+// This file is here so go get succeeds as without it errors with:
+// no buildable Go source files in ...
+//
+// +build !windows
+
+package oleutil

vendor/github.com/go-ole/go-ole/oleutil/oleutil.go

@@ -0,0 +1,127 @@
+package oleutil
+
+import ole "github.com/go-ole/go-ole"
+
+// ClassIDFrom retrieves class ID whether given is program ID or application string.
+func ClassIDFrom(programID string) (classID *ole.GUID, err error) {
+	return ole.ClassIDFrom(programID)
+}
+
+// CreateObject creates object from programID based on interface type.
+//
+// Only supports IUnknown.
+//
+// Program ID can be either program ID or application string.
+func CreateObject(programID string) (unknown *ole.IUnknown, err error) {
+	classID, err := ole.ClassIDFrom(programID)
+	if err != nil {
+		return
+	}
+
+	unknown, err = ole.CreateInstance(classID, ole.IID_IUnknown)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// GetActiveObject retrieves active object for program ID and interface ID based
+// on interface type.
+//
+// Only supports IUnknown.
+//
+// Program ID can be either program ID or application string.
+func GetActiveObject(programID string) (unknown *ole.IUnknown, err error) {
+	classID, err := ole.ClassIDFrom(programID)
+	if err != nil {
+		return
+	}
+
+	unknown, err = ole.GetActiveObject(classID, ole.IID_IUnknown)
+	if err != nil {
+		return
+	}
+
+	return
+}
+
+// CallMethod calls method on IDispatch with parameters.
+func CallMethod(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT, err error) {
+	return disp.InvokeWithOptionalArgs(name, ole.DISPATCH_METHOD, params)
+}
+
+// MustCallMethod calls method on IDispatch with parameters or panics.
+func MustCallMethod(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT) {
+	r, err := CallMethod(disp, name, params...)
+	if err != nil {
+		panic(err.Error())
+	}
+	return r
+}
+
+// GetProperty retrieves property from IDispatch.
+func GetProperty(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT, err error) {
+	return disp.InvokeWithOptionalArgs(name, ole.DISPATCH_PROPERTYGET, params)
+}
+
+// MustGetProperty retrieves property from IDispatch or panics.
+func MustGetProperty(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT) {
+	r, err := GetProperty(disp, name, params...)
+	if err != nil {
+		panic(err.Error())
+	}
+	return r
+}
+
+// PutProperty mutates property.
+func PutProperty(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT, err error) {
+	return disp.InvokeWithOptionalArgs(name, ole.DISPATCH_PROPERTYPUT, params)
+}
+
+// MustPutProperty mutates property or panics.
+func MustPutProperty(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT) {
+	r, err := PutProperty(disp, name, params...)
+	if err != nil {
+		panic(err.Error())
+	}
+	return r
+}
+
+// PutPropertyRef mutates property reference.
+func PutPropertyRef(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT, err error) {
+	return disp.InvokeWithOptionalArgs(name, ole.DISPATCH_PROPERTYPUTREF, params)
+}
+
+// MustPutPropertyRef mutates property reference or panics.
+func MustPutPropertyRef(disp *ole.IDispatch, name string, params ...interface{}) (result *ole.VARIANT) {
+	r, err := PutPropertyRef(disp, name, params...)
+	if err != nil {
+		panic(err.Error())
+	}
+	return r
+}
+
+func ForEach(disp *ole.IDispatch, f func(v *ole.VARIANT) error) error {
+	newEnum, err := disp.GetProperty("_NewEnum")
+	if err != nil {
+		return err
+	}
+	defer newEnum.Clear()
+
+	enum, err := newEnum.ToIUnknown().IEnumVARIANT(ole.IID_IEnumVariant)
+	if err != nil {
+		return err
+	}
+	defer enum.Release()
+
+	for item, length, err := enum.Next(1); length > 0; item, length, err = enum.Next(1) {
+		if err != nil {
+			return err
+		}
+		if ferr := f(&item); ferr != nil {
+			return ferr
+		}
+	}
+	return nil
+}

vendor/github.com/go-ole/go-ole/safearray.go

@@ -0,0 +1,27 @@
+// Package is meant to retrieve and process safe array data returned from COM.
+
+package ole
+
+// SafeArrayBound defines the SafeArray boundaries.
+type SafeArrayBound struct {
+	Elements   uint32
+	LowerBound int32
+}
+
+// SafeArray is how COM handles arrays.
+type SafeArray struct {
+	Dimensions   uint16
+	FeaturesFlag uint16
+	ElementsSize uint32
+	LocksAmount  uint32
+	Data         uint32
+	Bounds       [16]byte
+}
+
+// SAFEARRAY is obsolete, exists for backwards compatibility.
+// Use SafeArray
+type SAFEARRAY SafeArray
+
+// SAFEARRAYBOUND is obsolete, exists for backwards compatibility.
+// Use SafeArrayBound
+type SAFEARRAYBOUND SafeArrayBound

vendor/github.com/go-ole/go-ole/safearray_func.go

@@ -0,0 +1,211 @@
+// +build !windows
+
+package ole
+
+import (
+	"unsafe"
+)
+
+// safeArrayAccessData returns raw array pointer.
+//
+// AKA: SafeArrayAccessData in Windows API.
+func safeArrayAccessData(safearray *SafeArray) (uintptr, error) {
+	return uintptr(0), NewError(E_NOTIMPL)
+}
+
+// safeArrayUnaccessData releases raw array.
+//
+// AKA: SafeArrayUnaccessData in Windows API.
+func safeArrayUnaccessData(safearray *SafeArray) error {
+	return NewError(E_NOTIMPL)
+}
+
+// safeArrayAllocData allocates SafeArray.
+//
+// AKA: SafeArrayAllocData in Windows API.
+func safeArrayAllocData(safearray *SafeArray) error {
+	return NewError(E_NOTIMPL)
+}
+
+// safeArrayAllocDescriptor allocates SafeArray.
+//
+// AKA: SafeArrayAllocDescriptor in Windows API.
+func safeArrayAllocDescriptor(dimensions uint32) (*SafeArray, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// safeArrayAllocDescriptorEx allocates SafeArray.
+//
+// AKA: SafeArrayAllocDescriptorEx in Windows API.
+func safeArrayAllocDescriptorEx(variantType VT, dimensions uint32) (*SafeArray, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// safeArrayCopy returns copy of SafeArray.
+//
+// AKA: SafeArrayCopy in Windows API.
+func safeArrayCopy(original *SafeArray) (*SafeArray, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// safeArrayCopyData duplicates SafeArray into another SafeArray object.
+//
+// AKA: SafeArrayCopyData in Windows API.
+func safeArrayCopyData(original *SafeArray, duplicate *SafeArray) error {
+	return NewError(E_NOTIMPL)
+}
+
+// safeArrayCreate creates SafeArray.
+//
+// AKA: SafeArrayCreate in Windows API.
+func safeArrayCreate(variantType VT, dimensions uint32, bounds *SafeArrayBound) (*SafeArray, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// safeArrayCreateEx creates SafeArray.
+//
+// AKA: SafeArrayCreateEx in Windows API.
+func safeArrayCreateEx(variantType VT, dimensions uint32, bounds *SafeArrayBound, extra uintptr) (*SafeArray, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// safeArrayCreateVector creates SafeArray.
+//
+// AKA: SafeArrayCreateVector in Windows API.
+func safeArrayCreateVector(variantType VT, lowerBound int32, length uint32) (*SafeArray, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// safeArrayCreateVectorEx creates SafeArray.
+//
+// AKA: SafeArrayCreateVectorEx in Windows API.
+func safeArrayCreateVectorEx(variantType VT, lowerBound int32, length uint32, extra uintptr) (*SafeArray, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// safeArrayDestroy destroys SafeArray object.
+//
+// AKA: SafeArrayDestroy in Windows API.
+func safeArrayDestroy(safearray *SafeArray) error {
+	return NewError(E_NOTIMPL)
+}
+
+// safeArrayDestroyData destroys SafeArray object.
+//
+// AKA: SafeArrayDestroyData in Windows API.
+func safeArrayDestroyData(safearray *SafeArray) error {
+	return NewError(E_NOTIMPL)
+}
+
+// safeArrayDestroyDescriptor destroys SafeArray object.
+//
+// AKA: SafeArrayDestroyDescriptor in Windows API.
+func safeArrayDestroyDescriptor(safearray *SafeArray) error {
+	return NewError(E_NOTIMPL)
+}
+
+// safeArrayGetDim is the amount of dimensions in the SafeArray.
+//
+// SafeArrays may have multiple dimensions. Meaning, it could be
+// multidimensional array.
+//
+// AKA: SafeArrayGetDim in Windows API.
+func safeArrayGetDim(safearray *SafeArray) (*uint32, error) {
+	u := uint32(0)
+	return &u, NewError(E_NOTIMPL)
+}
+
+// safeArrayGetElementSize is the element size in bytes.
+//
+// AKA: SafeArrayGetElemsize in Windows API.
+func safeArrayGetElementSize(safearray *SafeArray) (*uint32, error) {
+	u := uint32(0)
+	return &u, NewError(E_NOTIMPL)
+}
+
+// safeArrayGetElement retrieves element at given index.
+func safeArrayGetElement(safearray *SafeArray, index int32, pv unsafe.Pointer) error {
+	return NewError(E_NOTIMPL)
+}
+
+// safeArrayGetElement retrieves element at given index and converts to string.
+func safeArrayGetElementString(safearray *SafeArray, index int32) (string, error) {
+	return "", NewError(E_NOTIMPL)
+}
+
+// safeArrayGetIID is the InterfaceID of the elements in the SafeArray.
+//
+// AKA: SafeArrayGetIID in Windows API.
+func safeArrayGetIID(safearray *SafeArray) (*GUID, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// safeArrayGetLBound returns lower bounds of SafeArray.
+//
+// SafeArrays may have multiple dimensions. Meaning, it could be
+// multidimensional array.
+//
+// AKA: SafeArrayGetLBound in Windows API.
+func safeArrayGetLBound(safearray *SafeArray, dimension uint32) (int32, error) {
+	return int32(0), NewError(E_NOTIMPL)
+}
+
+// safeArrayGetUBound returns upper bounds of SafeArray.
+//
+// SafeArrays may have multiple dimensions. Meaning, it could be
+// multidimensional array.
+//
+// AKA: SafeArrayGetUBound in Windows API.
+func safeArrayGetUBound(safearray *SafeArray, dimension uint32) (int32, error) {
+	return int32(0), NewError(E_NOTIMPL)
+}
+
+// safeArrayGetVartype returns data type of SafeArray.
+//
+// AKA: SafeArrayGetVartype in Windows API.
+func safeArrayGetVartype(safearray *SafeArray) (uint16, error) {
+	return uint16(0), NewError(E_NOTIMPL)
+}
+
+// safeArrayLock locks SafeArray for reading to modify SafeArray.
+//
+// This must be called during some calls to ensure that another process does not
+// read or write to the SafeArray during editing.
+//
+// AKA: SafeArrayLock in Windows API.
+func safeArrayLock(safearray *SafeArray) error {
+	return NewError(E_NOTIMPL)
+}
+
+// safeArrayUnlock unlocks SafeArray for reading.
+//
+// AKA: SafeArrayUnlock in Windows API.
+func safeArrayUnlock(safearray *SafeArray) error {
+	return NewError(E_NOTIMPL)
+}
+
+// safeArrayPutElement stores the data element at the specified location in the
+// array.
+//
+// AKA: SafeArrayPutElement in Windows API.
+func safeArrayPutElement(safearray *SafeArray, index int64, element uintptr) error {
+	return NewError(E_NOTIMPL)
+}
+
+// safeArrayGetRecordInfo accesses IRecordInfo info for custom types.
+//
+// AKA: SafeArrayGetRecordInfo in Windows API.
+//
+// XXX: Must implement IRecordInfo interface for this to return.
+func safeArrayGetRecordInfo(safearray *SafeArray) (interface{}, error) {
+	return nil, NewError(E_NOTIMPL)
+}
+
+// safeArraySetRecordInfo mutates IRecordInfo info for custom types.
+//
+// AKA: SafeArraySetRecordInfo in Windows API.
+//
+// XXX: Must implement IRecordInfo interface for this to return.
+func safeArraySetRecordInfo(safearray *SafeArray, recordInfo interface{}) error {
+	return NewError(E_NOTIMPL)
+}

vendor/github.com/go-ole/go-ole/safearray_windows.go

@@ -0,0 +1,337 @@
+// +build windows
+
+package ole
+
+import (
+	"unsafe"
+)
+
+var (
+	procSafeArrayAccessData        = modoleaut32.NewProc("SafeArrayAccessData")
+	procSafeArrayAllocData         = modoleaut32.NewProc("SafeArrayAllocData")
+	procSafeArrayAllocDescriptor   = modoleaut32.NewProc("SafeArrayAllocDescriptor")
+	procSafeArrayAllocDescriptorEx = modoleaut32.NewProc("SafeArrayAllocDescriptorEx")
+	procSafeArrayCopy              = modoleaut32.NewProc("SafeArrayCopy")
+	procSafeArrayCopyData          = modoleaut32.NewProc("SafeArrayCopyData")
+	procSafeArrayCreate            = modoleaut32.NewProc("SafeArrayCreate")
+	procSafeArrayCreateEx          = modoleaut32.NewProc("SafeArrayCreateEx")
+	procSafeArrayCreateVector      = modoleaut32.NewProc("SafeArrayCreateVector")
+	procSafeArrayCreateVectorEx    = modoleaut32.NewProc("SafeArrayCreateVectorEx")
+	procSafeArrayDestroy           = modoleaut32.NewProc("SafeArrayDestroy")
+	procSafeArrayDestroyData       = modoleaut32.NewProc("SafeArrayDestroyData")
+	procSafeArrayDestroyDescriptor = modoleaut32.NewProc("SafeArrayDestroyDescriptor")
+	procSafeArrayGetDim            = modoleaut32.NewProc("SafeArrayGetDim")
+	procSafeArrayGetElement        = modoleaut32.NewProc("SafeArrayGetElement")
+	procSafeArrayGetElemsize       = modoleaut32.NewProc("SafeArrayGetElemsize")
+	procSafeArrayGetIID            = modoleaut32.NewProc("SafeArrayGetIID")
+	procSafeArrayGetLBound         = modoleaut32.NewProc("SafeArrayGetLBound")
+	procSafeArrayGetUBound         = modoleaut32.NewProc("SafeArrayGetUBound")
+	procSafeArrayGetVartype        = modoleaut32.NewProc("SafeArrayGetVartype")
+	procSafeArrayLock              = modoleaut32.NewProc("SafeArrayLock")
+	procSafeArrayPtrOfIndex        = modoleaut32.NewProc("SafeArrayPtrOfIndex")
+	procSafeArrayUnaccessData      = modoleaut32.NewProc("SafeArrayUnaccessData")
+	procSafeArrayUnlock            = modoleaut32.NewProc("SafeArrayUnlock")
+	procSafeArrayPutElement        = modoleaut32.NewProc("SafeArrayPutElement")
+	//procSafeArrayRedim             = modoleaut32.NewProc("SafeArrayRedim") // TODO
+	//procSafeArraySetIID            = modoleaut32.NewProc("SafeArraySetIID") // TODO
+	procSafeArrayGetRecordInfo = modoleaut32.NewProc("SafeArrayGetRecordInfo")
+	procSafeArraySetRecordInfo = modoleaut32.NewProc("SafeArraySetRecordInfo")
+)
+
+// safeArrayAccessData returns raw array pointer.
+//
+// AKA: SafeArrayAccessData in Windows API.
+// Todo: Test
+func safeArrayAccessData(safearray *SafeArray) (element uintptr, err error) {
+	err = convertHresultToError(
+		procSafeArrayAccessData.Call(
+			uintptr(unsafe.Pointer(safearray)),
+			uintptr(unsafe.Pointer(&element))))
+	return
+}
+
+// safeArrayUnaccessData releases raw array.
+//
+// AKA: SafeArrayUnaccessData in Windows API.
+func safeArrayUnaccessData(safearray *SafeArray) (err error) {
+	err = convertHresultToError(procSafeArrayUnaccessData.Call(uintptr(unsafe.Pointer(safearray))))
+	return
+}
+
+// safeArrayAllocData allocates SafeArray.
+//
+// AKA: SafeArrayAllocData in Windows API.
+func safeArrayAllocData(safearray *SafeArray) (err error) {
+	err = convertHresultToError(procSafeArrayAllocData.Call(uintptr(unsafe.Pointer(safearray))))
+	return
+}
+
+// safeArrayAllocDescriptor allocates SafeArray.
+//
+// AKA: SafeArrayAllocDescriptor in Windows API.
+func safeArrayAllocDescriptor(dimensions uint32) (safearray *SafeArray, err error) {
+	err = convertHresultToError(
+		procSafeArrayAllocDescriptor.Call(uintptr(dimensions), uintptr(unsafe.Pointer(&safearray))))
+	return
+}
+
+// safeArrayAllocDescriptorEx allocates SafeArray.
+//
+// AKA: SafeArrayAllocDescriptorEx in Windows API.
+func safeArrayAllocDescriptorEx(variantType VT, dimensions uint32) (safearray *SafeArray, err error) {
+	err = convertHresultToError(
+		procSafeArrayAllocDescriptorEx.Call(
+			uintptr(variantType),
+			uintptr(dimensions),
+			uintptr(unsafe.Pointer(&safearray))))
+	return
+}
+
+// safeArrayCopy returns copy of SafeArray.
+//
+// AKA: SafeArrayCopy in Windows API.
+func safeArrayCopy(original *SafeArray) (safearray *SafeArray, err error) {
+	err = convertHresultToError(
+		procSafeArrayCopy.Call(
+			uintptr(unsafe.Pointer(original)),
+			uintptr(unsafe.Pointer(&safearray))))
+	return
+}
+
+// safeArrayCopyData duplicates SafeArray into another SafeArray object.
+//
+// AKA: SafeArrayCopyData in Windows API.
+func safeArrayCopyData(original *SafeArray, duplicate *SafeArray) (err error) {
+	err = convertHresultToError(
+		procSafeArrayCopyData.Call(
+			uintptr(unsafe.Pointer(original)),
+			uintptr(unsafe.Pointer(duplicate))))
+	return
+}
+
+// safeArrayCreate creates SafeArray.
+//
+// AKA: SafeArrayCreate in Windows API.
+func safeArrayCreate(variantType VT, dimensions uint32, bounds *SafeArrayBound) (safearray *SafeArray, err error) {
+	sa, _, err := procSafeArrayCreate.Call(
+		uintptr(variantType),
+		uintptr(dimensions),
+		uintptr(unsafe.Pointer(bounds)))
+	safearray = (*SafeArray)(unsafe.Pointer(&sa))
+	return
+}
+
+// safeArrayCreateEx creates SafeArray.
+//
+// AKA: SafeArrayCreateEx in Windows API.
+func safeArrayCreateEx(variantType VT, dimensions uint32, bounds *SafeArrayBound, extra uintptr) (safearray *SafeArray, err error) {
+	sa, _, err := procSafeArrayCreateEx.Call(
+		uintptr(variantType),
+		uintptr(dimensions),
+		uintptr(unsafe.Pointer(bounds)),
+		extra)
+	safearray = (*SafeArray)(unsafe.Pointer(sa))
+	return
+}
+
+// safeArrayCreateVector creates SafeArray.
+//
+// AKA: SafeArrayCreateVector in Windows API.
+func safeArrayCreateVector(variantType VT, lowerBound int32, length uint32) (safearray *SafeArray, err error) {
+	sa, _, err := procSafeArrayCreateVector.Call(
+		uintptr(variantType),
+		uintptr(lowerBound),
+		uintptr(length))
+	safearray = (*SafeArray)(unsafe.Pointer(sa))
+	return
+}
+
+// safeArrayCreateVectorEx creates SafeArray.
+//
+// AKA: SafeArrayCreateVectorEx in Windows API.
+func safeArrayCreateVectorEx(variantType VT, lowerBound int32, length uint32, extra uintptr) (safearray *SafeArray, err error) {
+	sa, _, err := procSafeArrayCreateVectorEx.Call(
+		uintptr(variantType),
+		uintptr(lowerBound),
+		uintptr(length),
+		extra)
+	safearray = (*SafeArray)(unsafe.Pointer(sa))
+	return
+}
+
+// safeArrayDestroy destroys SafeArray object.
+//
+// AKA: SafeArrayDestroy in Windows API.
+func safeArrayDestroy(safearray *SafeArray) (err error) {
+	err = convertHresultToError(procSafeArrayDestroy.Call(uintptr(unsafe.Pointer(safearray))))
+	return
+}
+
+// safeArrayDestroyData destroys SafeArray object.
+//
+// AKA: SafeArrayDestroyData in Windows API.
+func safeArrayDestroyData(safearray *SafeArray) (err error) {
+	err = convertHresultToError(procSafeArrayDestroyData.Call(uintptr(unsafe.Pointer(safearray))))
+	return
+}
+
+// safeArrayDestroyDescriptor destroys SafeArray object.
+//
+// AKA: SafeArrayDestroyDescriptor in Windows API.
+func safeArrayDestroyDescriptor(safearray *SafeArray) (err error) {
+	err = convertHresultToError(procSafeArrayDestroyDescriptor.Call(uintptr(unsafe.Pointer(safearray))))
+	return
+}
+
+// safeArrayGetDim is the amount of dimensions in the SafeArray.
+//
+// SafeArrays may have multiple dimensions. Meaning, it could be
+// multidimensional array.
+//
+// AKA: SafeArrayGetDim in Windows API.
+func safeArrayGetDim(safearray *SafeArray) (dimensions *uint32, err error) {
+	l, _, err := procSafeArrayGetDim.Call(uintptr(unsafe.Pointer(safearray)))
+	dimensions = (*uint32)(unsafe.Pointer(l))
+	return
+}
+
+// safeArrayGetElementSize is the element size in bytes.
+//
+// AKA: SafeArrayGetElemsize in Windows API.
+func safeArrayGetElementSize(safearray *SafeArray) (length *uint32, err error) {
+	l, _, err := procSafeArrayGetElemsize.Call(uintptr(unsafe.Pointer(safearray)))
+	length = (*uint32)(unsafe.Pointer(l))
+	return
+}
+
+// safeArrayGetElement retrieves element at given index.
+func safeArrayGetElement(safearray *SafeArray, index int32, pv unsafe.Pointer) error {
+	return convertHresultToError(
+		procSafeArrayGetElement.Call(
+			uintptr(unsafe.Pointer(safearray)),
+			uintptr(unsafe.Pointer(&index)),
+			uintptr(pv)))
+}
+
+// safeArrayGetElementString retrieves element at given index and converts to string.
+func safeArrayGetElementString(safearray *SafeArray, index int32) (str string, err error) {
+	var element *int16
+	err = convertHresultToError(
+		procSafeArrayGetElement.Call(
+			uintptr(unsafe.Pointer(safearray)),
+			uintptr(unsafe.Pointer(&index)),
+			uintptr(unsafe.Pointer(&element))))
+	str = BstrToString(*(**uint16)(unsafe.Pointer(&element)))
+	SysFreeString(element)
+	return
+}
+
+// safeArrayGetIID is the InterfaceID of the elements in the SafeArray.
+//
+// AKA: SafeArrayGetIID in Windows API.
+func safeArrayGetIID(safearray *SafeArray) (guid *GUID, err error) {
+	err = convertHresultToError(
+		procSafeArrayGetIID.Call(
+			uintptr(unsafe.Pointer(safearray)),
+			uintptr(unsafe.Pointer(&guid))))
+	return
+}
+
+// safeArrayGetLBound returns lower bounds of SafeArray.
+//
+// SafeArrays may have multiple dimensions. Meaning, it could be
+// multidimensional array.
+//
+// AKA: SafeArrayGetLBound in Windows API.
+func safeArrayGetLBound(safearray *SafeArray, dimension uint32) (lowerBound int32, err error) {
+	err = convertHresultToError(
+		procSafeArrayGetLBound.Call(
+			uintptr(unsafe.Pointer(safearray)),
+			uintptr(dimension),
+			uintptr(unsafe.Pointer(&lowerBound))))
+	return
+}
+
+// safeArrayGetUBound returns upper bounds of SafeArray.
+//
+// SafeArrays may have multiple dimensions. Meaning, it could be
+// multidimensional array.
+//
+// AKA: SafeArrayGetUBound in Windows API.
+func safeArrayGetUBound(safearray *SafeArray, dimension uint32) (upperBound int32, err error) {
+	err = convertHresultToError(
+		procSafeArrayGetUBound.Call(
+			uintptr(unsafe.Pointer(safearray)),
+			uintptr(dimension),
+			uintptr(unsafe.Pointer(&upperBound))))
+	return
+}
+
+// safeArrayGetVartype returns data type of SafeArray.
+//
+// AKA: SafeArrayGetVartype in Windows API.
+func safeArrayGetVartype(safearray *SafeArray) (varType uint16, err error) {
+	err = convertHresultToError(
+		procSafeArrayGetVartype.Call(
+			uintptr(unsafe.Pointer(safearray)),
+			uintptr(unsafe.Pointer(&varType))))
+	return
+}
+
+// safeArrayLock locks SafeArray for reading to modify SafeArray.
+//
+// This must be called during some calls to ensure that another process does not
+// read or write to the SafeArray during editing.
+//
+// AKA: SafeArrayLock in Windows API.
+func safeArrayLock(safearray *SafeArray) (err error) {
+	err = convertHresultToError(procSafeArrayLock.Call(uintptr(unsafe.Pointer(safearray))))
+	return
+}
+
+// safeArrayUnlock unlocks SafeArray for reading.
+//
+// AKA: SafeArrayUnlock in Windows API.
+func safeArrayUnlock(safearray *SafeArray) (err error) {
+	err = convertHresultToError(procSafeArrayUnlock.Call(uintptr(unsafe.Pointer(safearray))))
+	return
+}
+
+// safeArrayPutElement stores the data element at the specified location in the
+// array.
+//
+// AKA: SafeArrayPutElement in Windows API.
+func safeArrayPutElement(safearray *SafeArray, index int64, element uintptr) (err error) {
+	err = convertHresultToError(
+		procSafeArrayPutElement.Call(
+			uintptr(unsafe.Pointer(safearray)),
+			uintptr(unsafe.Pointer(&index)),
+			uintptr(unsafe.Pointer(element))))
+	return
+}
+
+// safeArrayGetRecordInfo accesses IRecordInfo info for custom types.
+//
+// AKA: SafeArrayGetRecordInfo in Windows API.
+//
+// XXX: Must implement IRecordInfo interface for this to return.
+func safeArrayGetRecordInfo(safearray *SafeArray) (recordInfo interface{}, err error) {
+	err = convertHresultToError(
+		procSafeArrayGetRecordInfo.Call(
+			uintptr(unsafe.Pointer(safearray)),
+			uintptr(unsafe.Pointer(&recordInfo))))
+	return
+}
+
+// safeArraySetRecordInfo mutates IRecordInfo info for custom types.
+//
+// AKA: SafeArraySetRecordInfo in Windows API.
+//
+// XXX: Must implement IRecordInfo interface for this to return.
+func safeArraySetRecordInfo(safearray *SafeArray, recordInfo interface{}) (err error) {
+	err = convertHresultToError(
+		procSafeArraySetRecordInfo.Call(
+			uintptr(unsafe.Pointer(safearray)),
+			uintptr(unsafe.Pointer(&recordInfo))))
+	return
+}

vendor/github.com/go-ole/go-ole/safearrayconversion.go

@@ -0,0 +1,140 @@
+// Helper for converting SafeArray to array of objects.
+
+package ole
+
+import (
+	"unsafe"
+)
+
+type SafeArrayConversion struct {
+	Array *SafeArray
+}
+
+func (sac *SafeArrayConversion) ToStringArray() (strings []string) {
+	totalElements, _ := sac.TotalElements(0)
+	strings = make([]string, totalElements)
+
+	for i := int32(0); i < totalElements; i++ {
+		strings[int32(i)], _ = safeArrayGetElementString(sac.Array, i)
+	}
+
+	return
+}
+
+func (sac *SafeArrayConversion) ToByteArray() (bytes []byte) {
+	totalElements, _ := sac.TotalElements(0)
+	bytes = make([]byte, totalElements)
+
+	for i := int32(0); i < totalElements; i++ {
+		safeArrayGetElement(sac.Array, i, unsafe.Pointer(&bytes[int32(i)]))
+	}
+
+	return
+}
+
+func (sac *SafeArrayConversion) ToValueArray() (values []interface{}) {
+	totalElements, _ := sac.TotalElements(0)
+	values = make([]interface{}, totalElements)
+	vt, _ := safeArrayGetVartype(sac.Array)
+
+	for i := int32(0); i < totalElements; i++ {
+		switch VT(vt) {
+		case VT_BOOL:
+			var v bool
+			safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v))
+			values[i] = v
+		case VT_I1:
+			var v int8
+			safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v))
+			values[i] = v
+		case VT_I2:
+			var v int16
+			safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v))
+			values[i] = v
+		case VT_I4:
+			var v int32
+			safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v))
+			values[i] = v
+		case VT_I8:
+			var v int64
+			safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v))
+			values[i] = v
+		case VT_UI1:
+			var v uint8
+			safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v))
+			values[i] = v
+		case VT_UI2:
+			var v uint16
+			safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v))
+			values[i] = v
+		case VT_UI4:
+			var v uint32
+			safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v))
+			values[i] = v
+		case VT_UI8:
+			var v uint64
+			safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v))
+			values[i] = v
+		case VT_R4:
+			var v float32
+			safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v))
+			values[i] = v
+		case VT_R8:
+			var v float64
+			safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v))
+			values[i] = v
+		case VT_BSTR:
+			var v string
+			safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v))
+			values[i] = v
+		case VT_VARIANT:
+			var v VARIANT
+			safeArrayGetElement(sac.Array, i, unsafe.Pointer(&v))
+			values[i] = v.Value()
+		default:
+			// TODO
+		}
+	}
+
+	return
+}
+
+func (sac *SafeArrayConversion) GetType() (varType uint16, err error) {
+	return safeArrayGetVartype(sac.Array)
+}
+
+func (sac *SafeArrayConversion) GetDimensions() (dimensions *uint32, err error) {
+	return safeArrayGetDim(sac.Array)
+}
+
+func (sac *SafeArrayConversion) GetSize() (length *uint32, err error) {
+	return safeArrayGetElementSize(sac.Array)
+}
+
+func (sac *SafeArrayConversion) TotalElements(index uint32) (totalElements int32, err error) {
+	if index < 1 {
+		index = 1
+	}
+
+	// Get array bounds
+	var LowerBounds int32
+	var UpperBounds int32
+
+	LowerBounds, err = safeArrayGetLBound(sac.Array, index)
+	if err != nil {
+		return
+	}
+
+	UpperBounds, err = safeArrayGetUBound(sac.Array, index)
+	if err != nil {
+		return
+	}
+
+	totalElements = UpperBounds - LowerBounds + 1
+	return
+}
+
+// Release Safe Array memory
+func (sac *SafeArrayConversion) Release() {
+	safeArrayDestroy(sac.Array)
+}