From bb0ce0cb5f6e8a2c340f687f6616f7ee3cb043d9 Mon Sep 17 00:00:00 2001 From: Nick Craig-Wood Date: Fri, 10 Nov 2017 10:16:38 +0000 Subject: [PATCH] vendor: vfs add vendor/github.com/djherbis/times --- Gopkg.lock | 8 +- vendor/github.com/djherbis/times/.travis.yml | 22 +++++ vendor/github.com/djherbis/times/LICENSE | 22 +++++ vendor/github.com/djherbis/times/README.md | 63 ++++++++++++ .../github.com/djherbis/times/bench_test.go | 29 ++++++ .../djherbis/times/ctime_windows.go | 96 +++++++++++++++++++ vendor/github.com/djherbis/times/times.go | 79 +++++++++++++++ .../github.com/djherbis/times/times_darwin.go | 40 ++++++++ .../djherbis/times/times_dragonfly.go | 39 ++++++++ .../djherbis/times/times_freebsd.go | 40 ++++++++ .../github.com/djherbis/times/times_linux.go | 39 ++++++++ .../github.com/djherbis/times/times_nacl.go | 39 ++++++++ .../github.com/djherbis/times/times_netbsd.go | 40 ++++++++ .../djherbis/times/times_openbsd.go | 39 ++++++++ .../github.com/djherbis/times/times_plan9.go | 34 +++++++ .../djherbis/times/times_solaris.go | 39 ++++++++ .../github.com/djherbis/times/times_test.go | 65 +++++++++++++ .../djherbis/times/times_windows.go | 36 +++++++ .../djherbis/times/use_generic_stat.go | 10 ++ vendor/github.com/djherbis/times/util_test.go | 50 ++++++++++ 20 files changed, 828 insertions(+), 1 deletion(-) create mode 100644 vendor/github.com/djherbis/times/.travis.yml create mode 100644 vendor/github.com/djherbis/times/LICENSE create mode 100644 vendor/github.com/djherbis/times/README.md create mode 100644 vendor/github.com/djherbis/times/bench_test.go create mode 100644 vendor/github.com/djherbis/times/ctime_windows.go create mode 100644 vendor/github.com/djherbis/times/times.go create mode 100644 vendor/github.com/djherbis/times/times_darwin.go create mode 100644 vendor/github.com/djherbis/times/times_dragonfly.go create mode 100644 vendor/github.com/djherbis/times/times_freebsd.go create mode 100644 vendor/github.com/djherbis/times/times_linux.go create mode 100644 vendor/github.com/djherbis/times/times_nacl.go create mode 100644 vendor/github.com/djherbis/times/times_netbsd.go create mode 100644 vendor/github.com/djherbis/times/times_openbsd.go create mode 100644 vendor/github.com/djherbis/times/times_plan9.go create mode 100644 vendor/github.com/djherbis/times/times_solaris.go create mode 100644 vendor/github.com/djherbis/times/times_test.go create mode 100644 vendor/github.com/djherbis/times/times_windows.go create mode 100644 vendor/github.com/djherbis/times/use_generic_stat.go create mode 100644 vendor/github.com/djherbis/times/util_test.go diff --git a/Gopkg.lock b/Gopkg.lock index 0e5059da1..6302d1f35 100644 --- a/Gopkg.lock +++ b/Gopkg.lock @@ -79,6 +79,12 @@ revision = "d2709f9f1f31ebcda9651b03077758c1f3a0018c" version = "v3.0.0" +[[projects]] + name = "github.com/djherbis/times" + packages = ["."] + revision = "95292e44976d1217cf3611dc7c8d9466877d3ed5" + version = "v1.0.1" + [[projects]] branch = "master" name = "github.com/dropbox/dropbox-sdk-go-unofficial" @@ -303,6 +309,6 @@ [solve-meta] analyzer-name = "dep" analyzer-version = 1 - inputs-digest = "f53d8d2a21862f225ba86e4575a68ce73db8957959ca507e5eded837c5dbcf73" + inputs-digest = "9d4dcfb143037fc27aa71f0eb309c9754ba348ff7585a39e575fba28265cac7d" solver-name = "gps-cdcl" solver-version = 1 diff --git a/vendor/github.com/djherbis/times/.travis.yml b/vendor/github.com/djherbis/times/.travis.yml new file mode 100644 index 000000000..b6936e213 --- /dev/null +++ b/vendor/github.com/djherbis/times/.travis.yml @@ -0,0 +1,22 @@ +language: go +go: +- 1.5 +before_install: +- go get github.com/golang/lint/golint +- go get github.com/axw/gocov/gocov +- go get github.com/mattn/goveralls +- if ! go get code.google.com/p/go.tools/cmd/cover; then go get golang.org/x/tools/cmd/cover; + fi +script: +- '[ "${TRAVIS_PULL_REQUEST}" != "false" ] || $HOME/gopath/bin/goveralls -service=travis-ci + -repotoken $COVERALLS_TOKEN' +- "$HOME/gopath/bin/golint ./..." +- go vet +- go test -bench=.* -v ./... +notifications: + email: + on_success: never + on_failure: change +env: + global: + secure: JLdvT4dl+oifYzbQN5I0G8mZi1KVj3D3zTC8N3D9eLEvHY26QggS2I6M5CNAYkbGSB2RDp7gZLHui8zVzvudD5GuxP2xZe+WN4+n9lf+jLnCuB77ZjKCuDa1+Wg/o466L4PK0BaiTQahbk9qsDNOdfTzXXLEnqBDo1WtvLJ1mn02pL5Wyt3aAA4yeK3z7eUYFNxyi/KJ22bwhjIv6Qa9RHT7ZfR6x9YQSGeLZIWPUx5S+vmySd7sM7gRTw+lRmR/i0PNMHjlOKoyedAT8YLAWX28xgPtc7E5j+pBm6ZmDcN79tTelhiAS9uifEKkdsugZZjfnLBl9gks19bmXP4mxUIo1iKQgIbKVs7R/QMdH7RXW+isfQP/vtk6SNC86os+r7tSJ1EOtF1cZfQ7H4o2RevA3VVTVZ+45gnrK8v00eckbLmsGGho7RGORIt+JGvD0oe84dXdk/lFtBTzWhOJn2Ujlm6L3z3r/YMN2CGFfH5JGpsUKJh1uRzJ5MPqkdxRwcGrtN4DGC1L8tRMfYPo06dQxa8p4TnbYQSZ6qwuVZMMcNvr9c/edwLizMh9KXivPodmHpLAMAUPSyWLtF8pp305DUhajpRsUEvTvs082KJAK4bUNE+AxRIBwtuB0Z2r0DpgfVwAUIXh42l9RDxEA1mwUyX2EKolyRqxQGPv9NQ= diff --git a/vendor/github.com/djherbis/times/LICENSE b/vendor/github.com/djherbis/times/LICENSE new file mode 100644 index 000000000..1e7b7cc09 --- /dev/null +++ b/vendor/github.com/djherbis/times/LICENSE @@ -0,0 +1,22 @@ +The MIT License (MIT) + +Copyright (c) 2015 Dustin H + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. + diff --git a/vendor/github.com/djherbis/times/README.md b/vendor/github.com/djherbis/times/README.md new file mode 100644 index 000000000..d23075267 --- /dev/null +++ b/vendor/github.com/djherbis/times/README.md @@ -0,0 +1,63 @@ +times +========== + +[![GoDoc](https://godoc.org/github.com/djherbis/times?status.svg)](https://godoc.org/github.com/djherbis/times) +[![Release](https://img.shields.io/github/release/djherbis/times.svg)](https://github.com/djherbis/times/releases/latest) +[![Software License](https://img.shields.io/badge/license-MIT-brightgreen.svg)](LICENSE.txt) +[![Build Status](https://travis-ci.org/djherbis/times.svg?branch=master)](https://travis-ci.org/djherbis/times) +[![Coverage Status](https://coveralls.io/repos/djherbis/times/badge.svg?branch=master)](https://coveralls.io/r/djherbis/times?branch=master) +[![Go Report Card](https://goreportcard.com/badge/github.com/djherbis/times)](https://goreportcard.com/report/github.com/djherbis/times) + +Usage +------------ +File Times for #golang + +Go has a hidden time functions for most platforms, this repo makes them accessible. + +```go +package main + +import ( + "log" + + "github.com/djherbis/times" +) + +func main() { + t, err := times.Stat("myfile") + if err != nil { + log.Fatal(err.Error()) + } + + log.Println(t.AccessTime()) + log.Println(t.ModTime()) + + if t.HasChangeTime() { + log.Println(t.ChangeTime()) + } + + if t.HasBirthTime() { + log.Println(t.BirthTime()) + } +} +``` + +Supported Times +------------ +| | windows | linux | solaris | dragonfly | nacl | freebsd | darwin | netbsd | openbsd | plan9 | +|:-----:|:-------:|:-----:|:-------:|:---------:|:------:|:-------:|:----:|:------:|:-------:|:-----:| +| atime | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | +| mtime | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | +| ctime | ✓* | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | ✓ | | +| btime | ✓ | | | | | ✓ | ✓| ✓ | + +* Windows XP does not have ChangeTime so HasChangeTime = false, +however Vista onward does have ChangeTime so Timespec.HasChangeTime() will +only return false on those platforms when the syscall used to obtain them fails. +* Also note, Get(FileInfo) will now only return values available in FileInfo.Sys(), this means Stat() is required to get ChangeTime on Windows + +Installation +------------ +```sh +go get github.com/djherbis/times +``` diff --git a/vendor/github.com/djherbis/times/bench_test.go b/vendor/github.com/djherbis/times/bench_test.go new file mode 100644 index 000000000..0b556136f --- /dev/null +++ b/vendor/github.com/djherbis/times/bench_test.go @@ -0,0 +1,29 @@ +package times + +import ( + "os" + "testing" +) + +func BenchmarkGet(t *testing.B) { + fileTest(t, func(f *os.File) { + fi, err := os.Stat(f.Name()) + if err != nil { + t.Error(err) + } + + for i := 0; i < t.N; i++ { + Get(fi) + } + }) + t.ReportAllocs() +} + +func BenchmarkStat(t *testing.B) { + fileTest(t, func(f *os.File) { + for i := 0; i < t.N; i++ { + Stat(f.Name()) + } + }) + t.ReportAllocs() +} diff --git a/vendor/github.com/djherbis/times/ctime_windows.go b/vendor/github.com/djherbis/times/ctime_windows.go new file mode 100644 index 000000000..6ca2d4580 --- /dev/null +++ b/vendor/github.com/djherbis/times/ctime_windows.go @@ -0,0 +1,96 @@ +package times + +import ( + "os" + "syscall" + "time" + "unsafe" +) + +type timespecEx struct { + atime + mtime + ctime + btime +} + +// StatFile finds a Windows Timespec with ChangeTime. +func StatFile(file *os.File) (Timespec, error) { + return statFile(syscall.Handle(file.Fd())) +} + +func statFile(h syscall.Handle) (Timespec, error) { + var fileInfo fileBasicInfo + if err := getFileInformationByHandleEx(h, &fileInfo); err != nil { + return nil, err + } + + var t timespecEx + t.atime.v = time.Unix(0, fileInfo.LastAccessTime.Nanoseconds()) + t.mtime.v = time.Unix(0, fileInfo.LastWriteTime.Nanoseconds()) + t.ctime.v = time.Unix(0, fileInfo.ChangeTime.Nanoseconds()) + t.btime.v = time.Unix(0, fileInfo.CreationTime.Nanoseconds()) + return t, nil +} + +const hasPlatformSpecificStat = true + +func platformSpecficStat(name string) (Timespec, error) { + if findProcErr != nil { + return nil, findProcErr + } + + f, err := os.Open(name) + if err != nil { + return nil, err + } + defer f.Close() + + return statFile(syscall.Handle(f.Fd())) +} + +var ( + findProcErr error + procGetFileInformationByHandleEx *syscall.Proc +) + +func init() { + var modkernel32 *syscall.DLL + if modkernel32, findProcErr = syscall.LoadDLL("kernel32.dll"); findProcErr == nil { + procGetFileInformationByHandleEx, findProcErr = modkernel32.FindProc("GetFileInformationByHandleEx") + } +} + +// fileBasicInfo holds the C++ data for FileTimes. +// +// https://msdn.microsoft.com/en-us/library/windows/desktop/aa364217(v=vs.85).aspx +type fileBasicInfo struct { + CreationTime syscall.Filetime + LastAccessTime syscall.Filetime + LastWriteTime syscall.Filetime + ChangeTime syscall.Filetime + FileAttributes uint32 + _ uint32 // padding +} + +type fileInformationClass int + +const ( + fileBasicInfoClass fileInformationClass = iota +) + +func getFileInformationByHandleEx(handle syscall.Handle, data *fileBasicInfo) (err error) { + if findProcErr != nil { + return findProcErr + } + + r1, _, e1 := syscall.Syscall6(procGetFileInformationByHandleEx.Addr(), 4, uintptr(handle), uintptr(fileBasicInfoClass), uintptr(unsafe.Pointer(data)), unsafe.Sizeof(*data), 0, 0) + if r1 == 0 { + if e1 != 0 { + err = error(e1) + } else { + err = syscall.EINVAL + } + } + return +} diff --git a/vendor/github.com/djherbis/times/times.go b/vendor/github.com/djherbis/times/times.go new file mode 100644 index 000000000..09fd6b4a7 --- /dev/null +++ b/vendor/github.com/djherbis/times/times.go @@ -0,0 +1,79 @@ +// Package times provides a platform-independent way to get atime, mtime, ctime and btime for files. +package times + +import ( + "os" + "time" +) + +// Get returns the Timespec for the given FileInfo +func Get(fi os.FileInfo) Timespec { + return getTimespec(fi) +} + +// Stat returns the Timespec for the given filename. +func Stat(name string) (Timespec, error) { + if hasPlatformSpecificStat { + if ts, err := platformSpecficStat(name); err == nil { + return ts, nil + } + } + + fi, err := os.Stat(name) + if err != nil { + return nil, err + } + return getTimespec(fi), nil +} + +// Timespec provides access to file times. +// ChangeTime() panics unless HasChangeTime() is true and +// BirthTime() panics unless HasBirthTime() is true. +type Timespec interface { + ModTime() time.Time + AccessTime() time.Time + ChangeTime() time.Time + BirthTime() time.Time + HasChangeTime() bool + HasBirthTime() bool +} + +type atime struct { + v time.Time +} + +func (a atime) AccessTime() time.Time { return a.v } + +type ctime struct { + v time.Time +} + +func (ctime) HasChangeTime() bool { return true } + +func (c ctime) ChangeTime() time.Time { return c.v } + +type mtime struct { + v time.Time +} + +func (m mtime) ModTime() time.Time { return m.v } + +type btime struct { + v time.Time +} + +func (btime) HasBirthTime() bool { return true } + +func (b btime) BirthTime() time.Time { return b.v } + +type noctime struct{} + +func (noctime) HasChangeTime() bool { return false } + +func (noctime) ChangeTime() time.Time { panic("ctime not available") } + +type nobtime struct{} + +func (nobtime) HasBirthTime() bool { return false } + +func (nobtime) BirthTime() time.Time { panic("birthtime not available") } diff --git a/vendor/github.com/djherbis/times/times_darwin.go b/vendor/github.com/djherbis/times/times_darwin.go new file mode 100644 index 000000000..94c5e4ca4 --- /dev/null +++ b/vendor/github.com/djherbis/times/times_darwin.go @@ -0,0 +1,40 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// http://golang.org/src/os/stat_darwin.go + +package times + +import ( + "os" + "syscall" + "time" +) + +// HasChangeTime and HasBirthTime are true if and only if +// the target OS supports them. +const ( + HasChangeTime = true + HasBirthTime = true +) + +type timespec struct { + atime + mtime + ctime + btime +} + +func timespecToTime(ts syscall.Timespec) time.Time { + return time.Unix(int64(ts.Sec), int64(ts.Nsec)) +} + +func getTimespec(fi os.FileInfo) (t timespec) { + stat := fi.Sys().(*syscall.Stat_t) + t.atime.v = timespecToTime(stat.Atimespec) + t.mtime.v = timespecToTime(stat.Mtimespec) + t.ctime.v = timespecToTime(stat.Ctimespec) + t.btime.v = timespecToTime(stat.Birthtimespec) + return t +} diff --git a/vendor/github.com/djherbis/times/times_dragonfly.go b/vendor/github.com/djherbis/times/times_dragonfly.go new file mode 100644 index 000000000..e11610c72 --- /dev/null +++ b/vendor/github.com/djherbis/times/times_dragonfly.go @@ -0,0 +1,39 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// http://golang.org/src/os/stat_dragonfly.go + +package times + +import ( + "os" + "syscall" + "time" +) + +// HasChangeTime and HasBirthTime are true if and only if +// the target OS supports them. +const ( + HasChangeTime = true + HasBirthTime = false +) + +type timespec struct { + atime + mtime + ctime + nobtime +} + +func timespecToTime(ts syscall.Timespec) time.Time { + return time.Unix(int64(ts.Sec), int64(ts.Nsec)) +} + +func getTimespec(fi os.FileInfo) (t timespec) { + stat := fi.Sys().(*syscall.Stat_t) + t.atime.v = timespecToTime(stat.Atim) + t.mtime.v = timespecToTime(stat.Mtim) + t.ctime.v = timespecToTime(stat.Ctim) + return t +} diff --git a/vendor/github.com/djherbis/times/times_freebsd.go b/vendor/github.com/djherbis/times/times_freebsd.go new file mode 100644 index 000000000..59d4335cc --- /dev/null +++ b/vendor/github.com/djherbis/times/times_freebsd.go @@ -0,0 +1,40 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// http://golang.org/src/os/stat_freebsd.go + +package times + +import ( + "os" + "syscall" + "time" +) + +// HasChangeTime and HasBirthTime are true if and only if +// the target OS supports them. +const ( + HasChangeTime = true + HasBirthTime = true +) + +type timespec struct { + atime + mtime + ctime + btime +} + +func timespecToTime(ts syscall.Timespec) time.Time { + return time.Unix(int64(ts.Sec), int64(ts.Nsec)) +} + +func getTimespec(fi os.FileInfo) (t timespec) { + stat := fi.Sys().(*syscall.Stat_t) + t.atime.v = timespecToTime(stat.Atimespec) + t.mtime.v = timespecToTime(stat.Mtimespec) + t.ctime.v = timespecToTime(stat.Ctimespec) + t.btime.v = timespecToTime(stat.Birthtimespec) + return t +} diff --git a/vendor/github.com/djherbis/times/times_linux.go b/vendor/github.com/djherbis/times/times_linux.go new file mode 100644 index 000000000..d9eb6976e --- /dev/null +++ b/vendor/github.com/djherbis/times/times_linux.go @@ -0,0 +1,39 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// http://golang.org/src/os/stat_linux.go + +package times + +import ( + "os" + "syscall" + "time" +) + +// HasChangeTime and HasBirthTime are true if and only if +// the target OS supports them. +const ( + HasChangeTime = true + HasBirthTime = false +) + +type timespec struct { + atime + mtime + ctime + nobtime +} + +func timespecToTime(ts syscall.Timespec) time.Time { + return time.Unix(int64(ts.Sec), int64(ts.Nsec)) +} + +func getTimespec(fi os.FileInfo) (t timespec) { + stat := fi.Sys().(*syscall.Stat_t) + t.atime.v = timespecToTime(stat.Atim) + t.mtime.v = timespecToTime(stat.Mtim) + t.ctime.v = timespecToTime(stat.Ctim) + return t +} diff --git a/vendor/github.com/djherbis/times/times_nacl.go b/vendor/github.com/djherbis/times/times_nacl.go new file mode 100644 index 000000000..5589fe688 --- /dev/null +++ b/vendor/github.com/djherbis/times/times_nacl.go @@ -0,0 +1,39 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// http://golang.org/src/os/stat_nacl.go + +package times + +import ( + "os" + "syscall" + "time" +) + +// HasChangeTime and HasBirthTime are true if and only if +// the target OS supports them. +const ( + HasChangeTime = true + HasBirthTime = false +) + +type timespec struct { + atime + mtime + ctime + nobtime +} + +func timespecToTime(sec, nsec int64) time.Time { + return time.Unix(sec, nsec) +} + +func getTimespec(fi os.FileInfo) (t timespec) { + stat := fi.Sys().(*syscall.Stat_t) + t.atime.v = timespecToTime(stat.Atime, stat.AtimeNsec) + t.mtime.v = timespecToTime(stat.Mtime, stat.MtimeNsec) + t.ctime.v = timespecToTime(stat.Ctime, stat.CtimeNsec) + return t +} diff --git a/vendor/github.com/djherbis/times/times_netbsd.go b/vendor/github.com/djherbis/times/times_netbsd.go new file mode 100644 index 000000000..fa9149e1b --- /dev/null +++ b/vendor/github.com/djherbis/times/times_netbsd.go @@ -0,0 +1,40 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// http://golang.org/src/os/stat_netbsd.go + +package times + +import ( + "os" + "syscall" + "time" +) + +// HasChangeTime and HasBirthTime are true if and only if +// the target OS supports them. +const ( + HasChangeTime = true + HasBirthTime = true +) + +type timespec struct { + atime + mtime + ctime + btime +} + +func timespecToTime(ts syscall.Timespec) time.Time { + return time.Unix(int64(ts.Sec), int64(ts.Nsec)) +} + +func getTimespec(fi os.FileInfo) (t timespec) { + stat := fi.Sys().(*syscall.Stat_t) + t.atime.v = timespecToTime(stat.Atimespec) + t.mtime.v = timespecToTime(stat.Mtimespec) + t.ctime.v = timespecToTime(stat.Ctimespec) + t.btime.v = timespecToTime(stat.Birthtimespec) + return t +} diff --git a/vendor/github.com/djherbis/times/times_openbsd.go b/vendor/github.com/djherbis/times/times_openbsd.go new file mode 100644 index 000000000..03c7a65a2 --- /dev/null +++ b/vendor/github.com/djherbis/times/times_openbsd.go @@ -0,0 +1,39 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// http://golang.org/src/os/stat_openbsd.go + +package times + +import ( + "os" + "syscall" + "time" +) + +// HasChangeTime and HasBirthTime are true if and only if +// the target OS supports them. +const ( + HasChangeTime = true + HasBirthTime = false +) + +type timespec struct { + atime + mtime + ctime + nobtime +} + +func timespecToTime(ts syscall.Timespec) time.Time { + return time.Unix(int64(ts.Sec), int64(ts.Nsec)) +} + +func getTimespec(fi os.FileInfo) (t timespec) { + stat := fi.Sys().(*syscall.Stat_t) + t.atime.v = timespecToTime(stat.Atim) + t.mtime.v = timespecToTime(stat.Mtim) + t.ctime.v = timespecToTime(stat.Ctim) + return t +} diff --git a/vendor/github.com/djherbis/times/times_plan9.go b/vendor/github.com/djherbis/times/times_plan9.go new file mode 100644 index 000000000..0b1beebf3 --- /dev/null +++ b/vendor/github.com/djherbis/times/times_plan9.go @@ -0,0 +1,34 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// http://golang.org/src/os/stat_plan9.go + +package times + +import ( + "os" + "syscall" + "time" +) + +// HasChangeTime and HasBirthTime are true if and only if +// the target OS supports them. +const ( + HasChangeTime = false + HasBirthTime = false +) + +type timespec struct { + atime + mtime + noctime + nobtime +} + +func getTimespec(fi os.FileInfo) (t timespec) { + stat := fi.Sys().(*syscall.Dir) + t.atime.v = time.Unix(int64(stat.Atime), 0) + t.mtime.v = time.Unix(int64(stat.Mtime), 0) + return t +} diff --git a/vendor/github.com/djherbis/times/times_solaris.go b/vendor/github.com/djherbis/times/times_solaris.go new file mode 100644 index 000000000..b1b15bf9f --- /dev/null +++ b/vendor/github.com/djherbis/times/times_solaris.go @@ -0,0 +1,39 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// http://golang.org/src/os/stat_solaris.go + +package times + +import ( + "os" + "syscall" + "time" +) + +// HasChangeTime and HasBirthTime are true if and only if +// the target OS supports them. +const ( + HasChangeTime = true + HasBirthTime = false +) + +type timespec struct { + atime + mtime + ctime + nobtime +} + +func timespecToTime(ts syscall.Timespec) time.Time { + return time.Unix(int64(ts.Sec), int64(ts.Nsec)) +} + +func getTimespec(fi os.FileInfo) (t timespec) { + stat := fi.Sys().(*syscall.Stat_t) + t.atime.v = timespecToTime(stat.Atim) + t.mtime.v = timespecToTime(stat.Mtim) + t.ctime.v = timespecToTime(stat.Ctim) + return t +} diff --git a/vendor/github.com/djherbis/times/times_test.go b/vendor/github.com/djherbis/times/times_test.go new file mode 100644 index 000000000..db3586ef3 --- /dev/null +++ b/vendor/github.com/djherbis/times/times_test.go @@ -0,0 +1,65 @@ +package times + +import ( + "os" + "testing" + "time" +) + +func TestStat(t *testing.T) { + fileTest(t, func(f *os.File) { + ts, err := Stat(f.Name()) + if err != nil { + t.Error(err.Error()) + } + timespecTest(ts, newInterval(time.Now(), time.Second), t) + }) +} + +func TestGet(t *testing.T) { + fileTest(t, func(f *os.File) { + fi, err := os.Stat(f.Name()) + if err != nil { + t.Error(err.Error()) + } + timespecTest(Get(fi), newInterval(time.Now(), time.Second), t) + }) +} + +func TestStatErr(t *testing.T) { + _, err := Stat("badfile?") + if err == nil { + t.Error("expected an error") + } +} + +func TestCheat(t *testing.T) { + // not all times are available for all platforms + // this allows us to get 100% test coverage for platforms which do not have + // ChangeTime/BirthTime + var c ctime + if c.HasChangeTime() { + c.ChangeTime() + } + + var b btime + if b.HasBirthTime() { + b.BirthTime() + } + + var nc noctime + func() { + if !nc.HasChangeTime() { + defer func() { recover() }() + } + nc.ChangeTime() + }() + + var nb nobtime + func() { + if !nb.HasBirthTime() { + defer func() { recover() }() + } + nb.BirthTime() + }() +} diff --git a/vendor/github.com/djherbis/times/times_windows.go b/vendor/github.com/djherbis/times/times_windows.go new file mode 100644 index 000000000..36828f286 --- /dev/null +++ b/vendor/github.com/djherbis/times/times_windows.go @@ -0,0 +1,36 @@ +// Copyright 2009 The Go Authors. All rights reserved. +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +// http://golang.org/src/os/stat_windows.go + +package times + +import ( + "os" + "syscall" + "time" +) + +// HasChangeTime and HasBirthTime are true if and only if +// the target OS supports them. +const ( + HasChangeTime = false + HasBirthTime = true +) + +type timespec struct { + atime + mtime + noctime + btime +} + +func getTimespec(fi os.FileInfo) Timespec { + var t timespec + stat := fi.Sys().(*syscall.Win32FileAttributeData) + t.atime.v = time.Unix(0, stat.LastAccessTime.Nanoseconds()) + t.mtime.v = time.Unix(0, stat.LastWriteTime.Nanoseconds()) + t.btime.v = time.Unix(0, stat.CreationTime.Nanoseconds()) + return t +} diff --git a/vendor/github.com/djherbis/times/use_generic_stat.go b/vendor/github.com/djherbis/times/use_generic_stat.go new file mode 100644 index 000000000..646b0d476 --- /dev/null +++ b/vendor/github.com/djherbis/times/use_generic_stat.go @@ -0,0 +1,10 @@ +// +build !windows + +package times + +const hasPlatformSpecificStat = false + +// do not use, only here to prevent "undefined" method error. +func platformSpecficStat(name string) (Timespec, error) { + return nil, nil +} diff --git a/vendor/github.com/djherbis/times/util_test.go b/vendor/github.com/djherbis/times/util_test.go new file mode 100644 index 000000000..6d067d88c --- /dev/null +++ b/vendor/github.com/djherbis/times/util_test.go @@ -0,0 +1,50 @@ +package times + +import ( + "io/ioutil" + "os" + "testing" + "time" +) + +type timeRange struct { + start time.Time + end time.Time +} + +func newInterval(t time.Time, dur time.Duration) timeRange { + return timeRange{start: t.Add(-dur), end: t.Add(dur)} +} + +func (t timeRange) Contains(findTime time.Time) bool { + return !findTime.Before(t.start) && !findTime.After(t.end) +} + +// creates a file and cleans it up after the test is run. +func fileTest(t testing.TB, testFunc func(f *os.File)) { + f, err := ioutil.TempFile("", "") + if err != nil { + t.Error(err) + } + defer os.Remove(f.Name()) + defer f.Close() + testFunc(f) +} + +func timespecTest(ts Timespec, r timeRange, t testing.TB) { + if !r.Contains(ts.AccessTime()) { + t.Errorf("expected %s to be in range: %s\n", ts.AccessTime(), r.start) + } + + if !r.Contains(ts.ModTime()) { + t.Errorf("expected %s to be in range: %s\n", ts.ModTime(), r.start) + } + + if ts.HasChangeTime() && !r.Contains(ts.ChangeTime()) { + t.Errorf("expected %s to be in range: %s\n", ts.ChangeTime(), r.start) + } + + if ts.HasBirthTime() && !r.Contains(ts.BirthTime()) { + t.Errorf("expected %s to be in range: %s\n", ts.BirthTime(), r.start) + } +}