本文整理汇总了Golang中github.com/golang/protobuf/ptypes.TimestampProto函数的典型用法代码示例。如果您正苦于以下问题:Golang TimestampProto函数的具体用法?Golang TimestampProto怎么用?Golang TimestampProto使用的例子?那么恭喜您, 这里精选的函数代码示例或许可以为您提供帮助。
在下文中一共展示了TimestampProto函数的15个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: AppendPackageEvent
func AppendPackageEvent(site, path, foundWay string, t time.Time, a sppb.HistoryEvent_Action_Enum) error {
return UpdatePackageHistory(site, path, func(hi *sppb.HistoryInfo) error {
if hi.FoundTime == nil {
// The first time the package was found
hi.FoundTime, _ = ptypes.TimestampProto(t)
hi.FoundWay = foundWay
}
if a == sppb.HistoryEvent_Action_None {
return nil
}
// Insert the event
tsp, _ := ptypes.TimestampProto(t)
hi.Events = append([]*sppb.HistoryEvent{{
Action: a,
Timestamp: tsp,
}}, hi.Events...)
if len(hi.Events) > maxHistoryEvents {
hi.Events = hi.Events[:maxHistoryEvents]
}
switch a {
case sppb.HistoryEvent_Action_Success:
hi.LatestSuccess = tsp
case sppb.HistoryEvent_Action_Failed:
hi.LatestFailed = tsp
}
return nil
})
}
示例2: TestProtoBefore
func TestProtoBefore(t *testing.T) {
now := utcNow()
nowpb, err := ptypes.TimestampProto(now)
require.NoError(t, err)
cases := []struct {
ts time.Time
before bool
}{
{
ts: now.Add(time.Second),
before: true,
}, {
ts: now.Add(-time.Second),
before: false,
}, {
ts: now.Add(time.Nanosecond),
before: true,
}, {
ts: now.Add(-time.Nanosecond),
before: false,
}, {
ts: now,
before: false,
},
}
for _, c := range cases {
tspb, err := ptypes.TimestampProto(c.ts)
require.NoError(t, err)
res := protoBefore(nowpb, tspb)
require.Equal(t, c.before, res, "protoBefore returned unexpected result")
}
}
示例3: SetTimeRange
// SetTimeRange adjust the time range of a silence if allowed. If start or end
// are zero times, the current value remains unmodified.
func (s *Silences) SetTimeRange(id string, start, end time.Time) error {
now, err := s.nowProto()
if err != nil {
return err
}
s.mtx.Lock()
defer s.mtx.Unlock()
sil, ok := s.getSilence(id)
if !ok {
return ErrNotFound
}
// Retrieve protobuf start and end time, default to current value
// of the silence.
var startp, endp *timestamp.Timestamp
if start.IsZero() {
startp = sil.StartsAt
} else if startp, err = ptypes.TimestampProto(start); err != nil {
return err
}
if end.IsZero() {
endp = sil.EndsAt
} else if endp, err = ptypes.TimestampProto(end); err != nil {
return err
}
if sil, err = silenceSetTimeRange(sil, now, startp, endp); err != nil {
return err
}
return s.setSilence(sil)
}
示例4: TestCheckPackageStatus
func TestCheckPackageStatus(t *testing.T) {
// No crawling info, new package
assert.Equal(t, "CheckPackageStatus", CheckPackageStatus(&stpb.PackageInfo{}, nil), OutOfDate)
pkgCrawlTime, _ := ptypes.TimestampProto(time.Now().Add(-5 * timep.Day))
newRepoInfoCrawlTime, _ := ptypes.TimestampProto(time.Now().Add(-3 * timep.Day))
newPkgUpdateTime, _ := ptypes.TimestampProto(time.Now().Add(-4 * timep.Day))
assert.Equal(t, "CheckPackageStatus", CheckPackageStatus(&stpb.PackageInfo{
CrawlingInfo: &sppb.CrawlingInfo{
CrawlingTime: pkgCrawlTime,
},
}, &sppb.RepoInfo{
CrawlingTime: newRepoInfoCrawlTime,
LastUpdated: newPkgUpdateTime,
}), OutOfDate)
newPkgUpdateTime, _ = ptypes.TimestampProto(time.Now().Add(-6 * timep.Day))
assert.Equal(t, "CheckPackageStatus", CheckPackageStatus(&stpb.PackageInfo{
CrawlingInfo: &sppb.CrawlingInfo{
CrawlingTime: pkgCrawlTime,
},
}, &sppb.RepoInfo{
CrawlingTime: newRepoInfoCrawlTime,
LastUpdated: newPkgUpdateTime,
}), UpToDate)
}
示例5: repoInfoFromGithub
func repoInfoFromGithub(repo *github.Repository) *sppb.RepoInfo {
ri := &sppb.RepoInfo{
Description: stringsp.Get(repo.Description),
Stars: int32(getInt(repo.StargazersCount)),
}
ri.CrawlingTime, _ = ptypes.TimestampProto(time.Now())
ri.LastUpdated, _ = ptypes.TimestampProto(getTimestamp(repo.PushedAt).Time)
if repo.Source != nil {
ri.Source = stringsp.Get(repo.Source.Name)
}
return ri
}
示例6: TestAppendPackageEvent
func TestAppendPackageEvent(t *testing.T) {
const (
site = "TestAppendPackageEvent.com"
path = "gcse"
foundWay = "test"
)
// Insert a found only event, no action.
foundTm := time.Now()
foundTs, _ := ptypes.TimestampProto(foundTm)
assert.NoError(t, AppendPackageEvent(site, path, "test", foundTm, sppb.HistoryEvent_Action_None))
h, err := ReadPackageHistory(site, path)
assert.NoError(t, err)
assert.Equal(t, "h", h, &sppb.HistoryInfo{FoundWay: foundWay, FoundTime: foundTs})
// Inser a Success action
succTm := foundTm.Add(time.Hour)
succTs, _ := ptypes.TimestampProto(succTm)
assert.NoError(t, AppendPackageEvent(site, path, "non-test", succTm, sppb.HistoryEvent_Action_Success))
h, err = ReadPackageHistory(site, path)
assert.NoError(t, err)
assert.Equal(t, "h", h, &sppb.HistoryInfo{
FoundWay: foundWay,
FoundTime: foundTs,
Events: []*sppb.HistoryEvent{{
Timestamp: succTs,
Action: sppb.HistoryEvent_Action_Success,
}},
LatestSuccess: succTs,
})
// Inser a Failed action
failedTm := succTm.Add(time.Hour)
failedTs, _ := ptypes.TimestampProto(failedTm)
assert.NoError(t, AppendPackageEvent(site, path, "", failedTm, sppb.HistoryEvent_Action_Failed))
h, err = ReadPackageHistory(site, path)
assert.NoError(t, err)
assert.Equal(t, "h", h, &sppb.HistoryInfo{
FoundWay: foundWay,
FoundTime: foundTs,
Events: []*sppb.HistoryEvent{{
Timestamp: failedTs,
Action: sppb.HistoryEvent_Action_Failed,
}, {
Timestamp: succTs,
Action: sppb.HistoryEvent_Action_Success,
}},
LatestSuccess: succTs,
LatestFailed: failedTs,
})
}
示例7: Events
func (s *apiServer) Events(r *types.EventsRequest, stream types.API_EventsServer) error {
t := time.Time{}
if r.Timestamp != nil {
from, err := ptypes.Timestamp(r.Timestamp)
if err != nil {
return err
}
t = from
}
events := s.sv.Events.Events(t)
defer s.sv.Events.Unsubscribe(events)
for e := range events {
tsp, err := ptypes.TimestampProto(e.Timestamp)
if err != nil {
return err
}
if err := stream.Send(&types.Event{
Id: e.ID,
Type: e.Type,
Timestamp: tsp,
Pid: e.PID,
Status: uint32(e.Status),
}); err != nil {
return err
}
}
return nil
}
示例8: Events
func (s *apiServer) Events(r *types.EventsRequest, stream types.API_EventsServer) error {
t := time.Time{}
if r.Timestamp != nil {
from, err := ptypes.Timestamp(r.Timestamp)
if err != nil {
return err
}
t = from
}
if r.StoredOnly && t.IsZero() {
return fmt.Errorf("invalid parameter: StoredOnly cannot be specified without setting a valid Timestamp")
}
events := s.sv.Events(t, r.StoredOnly, r.Id)
defer s.sv.Unsubscribe(events)
for e := range events {
tsp, err := ptypes.TimestampProto(e.Timestamp)
if err != nil {
return err
}
if r.Id == "" || e.ID == r.Id {
if err := stream.Send(&types.Event{
Id: e.ID,
Type: e.Type,
Timestamp: tsp,
Pid: e.PID,
Status: uint32(e.Status),
}); err != nil {
return err
}
}
}
return nil
}
示例9: waitForExit
func waitForExit(c types.APIClient, events types.API_EventsClient, id, pid string, closer func()) {
timestamp := time.Now()
for {
e, err := events.Recv()
if err != nil {
if grpc.ErrorDesc(err) == transport.ErrConnClosing.Desc {
closer()
os.Exit(128 + int(syscall.SIGHUP))
}
time.Sleep(1 * time.Second)
tsp, err := ptypes.TimestampProto(timestamp)
if err != nil {
closer()
fmt.Fprintf(os.Stderr, "%s", err.Error())
os.Exit(1)
}
events, _ = c.Events(netcontext.Background(), &types.EventsRequest{Timestamp: tsp})
continue
}
timestamp, err = ptypes.Timestamp(e.Timestamp)
if e.Id == id && e.Type == "exit" && e.Pid == pid {
closer()
os.Exit(int(e.Status))
}
}
}
示例10: mustTimestampProto
func mustTimestampProto(ts time.Time) *timestamp.Timestamp {
res, err := ptypes.TimestampProto(ts)
if err != nil {
panic(err)
}
return res
}
示例11: entryToPBEntry
func entryToPBEntry(entry *Entry) (*protologpb.Entry, error) {
contexts, err := messagesToEntryMessages(entry.Contexts)
if err != nil {
return nil, err
}
event, err := messageToEntryMessage(entry.Event)
if err != nil {
return nil, err
}
pbLevel, ok := levelToPB[entry.Level]
if !ok {
return nil, fmt.Errorf("protolog: unknown level: %v", entry.Level)
}
timestamp, err := ptypes.TimestampProto(entry.Time)
if err != nil {
return nil, err
}
return &protologpb.Entry{
Id: entry.ID,
Level: pbLevel,
Timestamp: timestamp,
Context: contexts,
Fields: entry.Fields,
Event: event,
Message: entry.Message,
WriterOutput: entry.WriterOutput,
}, nil
}
示例12: TestRepoInfoAge
func TestRepoInfoAge(t *testing.T) {
ts, _ := ptypes.TimestampProto(time.Now().Add(-time.Hour))
age := RepoInfoAge(&sppb.RepoInfo{
CrawlingTime: ts,
})
assert.ValueShould(t, "age", age, age >= time.Hour && age < time.Hour+time.Minute, "age out of expected range")
}
示例13: containerEvents
func containerEvents(c types.APIClient, container string) <-chan *types.Event {
evChan := make(chan *types.Event)
ts := time.Now()
go func() {
for {
tsp, err := ptypes.TimestampProto(ts)
if err != nil {
close(evChan)
return
}
events, err := c.Events(netcontext.Background(), &types.EventsRequest{Timestamp: tsp})
if err != nil {
fmt.Printf("c.Events error: %v", err)
// TODO try to find a way to kill the process ?
close(evChan)
return
}
for {
e, err := events.Recv()
if err != nil {
time.Sleep(1 * time.Second)
break
}
ts, err = ptypes.Timestamp(e.Timestamp)
if e.Id == container {
evChan <- e
}
}
}
}()
return evChan
}
示例14: bestMomentInHistory
func bestMomentInHistory() (*Operation, error) {
t, err := time.Parse("2006-01-02 15:04:05.999999999 -0700 MST", "2009-11-10 23:00:00 +0000 UTC")
if err != nil {
return nil, err
}
resp, err := ptypes.TimestampProto(t)
if err != nil {
return nil, err
}
respAny, err := ptypes.MarshalAny(resp)
if err != nil {
return nil, err
}
metaAny, err := ptypes.MarshalAny(ptypes.DurationProto(1 * time.Hour))
return &Operation{
proto: &pb.Operation{
Name: "best-moment",
Done: true,
Metadata: metaAny,
Result: &pb.Operation_Response{
Response: respAny,
},
},
}, err
}
示例15: toLogEntry
func toLogEntry(e Entry) (*logpb.LogEntry, error) {
if e.LogName != "" {
return nil, errors.New("logging: Entry.LogName should be not be set when writing")
}
t := e.Timestamp
if t.IsZero() {
t = now()
}
ts, err := ptypes.TimestampProto(t)
if err != nil {
return nil, err
}
ent := &logpb.LogEntry{
Timestamp: ts,
Severity: logtypepb.LogSeverity(e.Severity),
InsertId: e.InsertID,
HttpRequest: fromHTTPRequest(e.HTTPRequest),
Operation: e.Operation,
Labels: e.Labels,
}
switch p := e.Payload.(type) {
case string:
ent.Payload = &logpb.LogEntry_TextPayload{p}
default:
s, err := toProtoStruct(p)
if err != nil {
return nil, err
}
ent.Payload = &logpb.LogEntry_JsonPayload{s}
}
return ent, nil
}