func (e *encoder) timev(tag string, in time.Time) {
s, err := in.MarshalText()
if err != nil {
failf("could not marshal text from input time %s: %s", in, err)
}
e.emitScalar(string(s), "", tag, yaml_PLAIN_SCALAR_STYLE)
}
func marshalTime(t time.Time) string {
if t.IsZero() {
return ""
}
b, _ := t.MarshalText()
return string(b)
}
func (m *baseModel) markUpdated(id string, t time.Time, conn redis.Conn) error {
defer syncFS()
ts, err := t.MarshalText()
if err != nil {
return err
}
_, err = conn.Do("HSET", m.idType+"s:updated", id, ts)
return err
}
// Converts Time t into a Unix timestamp with nanosecond precision
// in the format of: s.nnnnnnnnn
func MarshalTime(t time.Time) ([]byte, error) {
if unixTime == true {
sec := t.Unix()
nsec := t.Nanosecond()
return []byte(fmt.Sprintf("%d.%09d", sec, nsec)), nil
} else {
return t.MarshalText()
}
}
func (c *Client) RawNotificationsSince(since time.Time) (*Notifications, error) {
since = since.In(ZuluTime).Truncate(time.Second)
rfcSince, err := since.MarshalText()
if err != nil {
return nil, err
}
url := "https://api.ft.com/content/notifications/?since=" + string(rfcSince)
result := &Notifications{}
raw, err := c.FromURL(url, result)
result.RawJSON = raw
return result, err
}
func (r *remote) updateEventTimestamp(t time.Time) {
f, err := os.OpenFile(r.eventTsPath, syscall.O_CREAT|syscall.O_WRONLY|syscall.O_TRUNC, 0600)
if err != nil {
logrus.Warnf("libcontainerd: failed to open event timestamp file: %v", err)
return
}
defer f.Close()
b, err := t.MarshalText()
if err != nil {
logrus.Warnf("libcontainerd: failed to encode timestamp: %v", err)
return
}
n, err := f.Write(b)
if err != nil || n != len(b) {
logrus.Warnf("libcontainerd: failed to update event timestamp file: %v", err)
f.Truncate(0)
return
}
}
func Fuzz(data []byte) int {
var t time.Time
if err := t.UnmarshalText(data); err != nil {
return 0
}
data1, err := t.MarshalText()
if err != nil {
panic(err)
}
var t1 time.Time
if err := t1.UnmarshalText(data1); err != nil {
panic(err)
}
if !fuzz.DeepEqual(t, t1) {
fmt.Printf("t0: %#v\n", t)
fmt.Printf("t1: %#v\n", t1)
panic("bad MarshalText")
}
data2, err := t.GobEncode()
if err != nil {
panic(err)
}
var t2 time.Time
if err := t2.GobDecode(data2); err != nil {
panic(err)
}
if !fuzz.DeepEqual(t, t2) {
fmt.Printf("t0: %#v\n", t)
fmt.Printf("t2: %#v\n", t2)
panic("bad GobEncode")
}
data3, err := t.MarshalBinary()
if err != nil {
panic(err)
}
var t3 time.Time
if err := t3.UnmarshalBinary(data3); err != nil {
panic(err)
}
if !fuzz.DeepEqual(t, t3) {
fmt.Printf("t0: %#v\n", t)
fmt.Printf("t3: %#v\n", t3)
panic("bad MarshalBinary")
}
data4, err := t.MarshalJSON()
if err != nil {
panic(err)
}
var t4 time.Time
if err := t4.UnmarshalJSON(data4); err != nil {
panic(err)
}
if !fuzz.DeepEqual(t, t4) {
fmt.Printf("t0: %#v\n", t)
fmt.Printf("t4: %#v\n", t4)
panic("bad MarshalJSON")
}
data5, err := t.MarshalText()
if err != nil {
panic(err)
}
var t5 time.Time
if err := t5.UnmarshalText(data5); err != nil {
panic(err)
}
if !fuzz.DeepEqual(t, t5) {
fmt.Printf("t0: %#v\n", t)
fmt.Printf("t5: %#v\n", t5)
panic("bad MarshalText")
}
data6 := t.Format(time.RFC3339Nano)
t6, err := time.Parse(time.RFC3339Nano, data6)
if err != nil {
panic(err)
}
if !fuzz.DeepEqual(t, t6) {
fmt.Printf("t0: %#v\n", t)
fmt.Printf("t6: %#v\n", t6)
panic("bad Format")
}
return 1
}
