Beispiel #1
0
func TestSlot_list(t *testing.T) {
	_, client := mockServerClient(t)
	layout := "2006-01-02"

	prev, err := time.Parse(layout, "2015-12-14")
	if err != nil {
		t.Fatal(err)
	}
	to, _ := time.Parse(layout, "2015-12-15")
	_ = prev
	params := SlotParams{
		From:              prev,
		To:                to,
		SelectedResources: []int{},
	}
	slots, err := client.ServiceSlot(427, params)
	if err != nil {
		t.Error(err)
	}

	if e := 4; len(slots) != e {
		t.Fatalf("wrong number of slots returned got: %d wanted: %d",
			len(slots), e)
	}
}
Beispiel #2
0
func (ctl *controller) getActivity(c web.C, w http.ResponseWriter, r *http.Request) {
	teamID, _ := c.Env["team_id"].(string)

	p := api.ActivityQueryParams{
		AppID:      r.URL.Query().Get("app"),
		GroupID:    r.URL.Query().Get("group"),
		ChannelID:  r.URL.Query().Get("channel"),
		InstanceID: r.URL.Query().Get("instance"),
		Version:    r.URL.Query().Get("version"),
	}
	p.Severity, _ = strconv.Atoi(r.URL.Query().Get("severity"))
	p.Start, _ = time.Parse(time.RFC3339, r.URL.Query().Get("start"))
	p.End, _ = time.Parse(time.RFC3339, r.URL.Query().Get("end"))
	p.Page, _ = strconv.ParseUint(r.URL.Query().Get("page"), 10, 64)
	p.PerPage, _ = strconv.ParseUint(r.URL.Query().Get("perpage"), 10, 64)

	activityEntriesJSON, err := ctl.api.GetActivityJSON(teamID, p)
	switch err {
	case nil:
		w.Write(activityEntriesJSON)
	case sql.ErrNoRows:
		w.Write([]byte(`[]`))
	default:
		logger.Error("getActivity", "error", err, "teamID", teamID, "p", p)
		http.Error(w, http.StatusText(400), 400)
	}
}
Beispiel #3
0
func parseDateTime(str string, loc *time.Location) (t time.Time, err error) {
	switch len(str) {
	case 10: // YYYY-MM-DD
		if str == "0000-00-00" {
			return
		}
		t, err = time.Parse(timeFormat[:10], str)
	case 19: // YYYY-MM-DD HH:MM:SS
		if str == "0000-00-00 00:00:00" {
			return
		}
		t, err = time.Parse(timeFormat, str)
	default:
		err = fmt.Errorf("Invalid Time-String: %s", str)
		return
	}

	// Adjust location
	if err == nil && loc != time.UTC {
		y, mo, d := t.Date()
		h, mi, s := t.Clock()
		t, err = time.Date(y, mo, d, h, mi, s, t.Nanosecond(), loc), nil
	}

	return
}
Beispiel #4
0
func checkstatus(p *os.Process, pname string, timest string) bool {
	fmt.Println("checkstatus", pname, p)
	reportlog[timest]["status"] = pname + " running"
	reportlog[timest][pname+"start"] = time.Now().Format("20060102150405")
	liner, _ := json.Marshal(reportlog)
	ioutil.WriteFile("static/data/reportlog.json", liner, 0)
	pw, _ := p.Wait()
	fmt.Println("checkstatus over", p)
	fmt.Println("timest=", timest)
	reportlog[timest][pname+"stop"] = time.Now().Format("20060102150405")
	t1, _ := time.Parse("20060102150405", reportlog[timest][pname+"stop"])
	t2, _ := time.Parse("20060102150405", reportlog[timest][pname+"start"])
	reportlog[timest][pname+"time"] = strconv.Itoa(int(t1.Sub(t2)) / 1e9)
	fmt.Println("t1=", t1)
	fmt.Println("t2=", t2)
	fmt.Println("cost=", t1.Sub(t2))
	status := pw.Success()
	if status == true {
		reportlog[timest]["status"] = pname + " success"
		fmt.Println("checkstatus over success ", pname, p)
	} else {
		reportlog[timest]["status"] = pname + " failed"
		fmt.Println("checkstatus over failed ", pname, p)
	}
	liner, _ = json.Marshal(reportlog)
	ioutil.WriteFile("static/data/reportlog.json", liner, 0)
	return status

}
func (s *DockerSuite) TestLogsSinceFutureFollow(c *check.C) {
	// TODO Windows TP5 - Figure out why this test is so flakey. Disabled for now.
	testRequires(c, DaemonIsLinux)
	name := "testlogssincefuturefollow"
	out, _ := dockerCmd(c, "run", "-d", "--name", name, "busybox", "/bin/sh", "-c", `for i in $(seq 1 5); do echo log$i; sleep 1; done`)

	// Extract one timestamp from the log file to give us a starting point for
	// our `--since` argument. Because the log producer runs in the background,
	// we need to check repeatedly for some output to be produced.
	var timestamp string
	for i := 0; i != 100 && timestamp == ""; i++ {
		if out, _ = dockerCmd(c, "logs", "-t", name); out == "" {
			time.Sleep(time.Millisecond * 100) // Retry
		} else {
			timestamp = strings.Split(strings.Split(out, "\n")[0], " ")[0]
		}
	}

	c.Assert(timestamp, checker.Not(checker.Equals), "")
	t, err := time.Parse(time.RFC3339Nano, timestamp)
	c.Assert(err, check.IsNil)

	since := t.Unix() + 2
	out, _ = dockerCmd(c, "logs", "-t", "-f", fmt.Sprintf("--since=%v", since), name)
	c.Assert(out, checker.Not(checker.HasLen), 0, check.Commentf("cannot read from empty log"))
	lines := strings.Split(strings.TrimSpace(out), "\n")
	for _, v := range lines {
		ts, err := time.Parse(time.RFC3339Nano, strings.Split(v, " ")[0])
		c.Assert(err, checker.IsNil, check.Commentf("cannot parse timestamp output from log: '%v'", v))
		c.Assert(ts.Unix() >= since, checker.Equals, true, check.Commentf("earlier log found. since=%v logdate=%v", since, ts))
	}
}
Beispiel #6
0
func decodeTime(r io.Reader, f reflect.Value) error {
	s, err := decodeStr(r)
	if err != nil {
		return err
	}
	var t time.Time
	if s != "" {
		// Samsung has trailing dots.
		s = strings.TrimRight(s, ".")

		// Jolla Sailfish has trailing "Z".
		s = strings.TrimRight(s, "Z")

		t, err = time.Parse(timeFormat, s)
		if err != nil {
			// Nokia lumia has numTZ
			t, err = time.Parse(timeFormatNumTZ, s)
			if err != nil {
				return err
			}
		}
	}
	f.Set(reflect.ValueOf(t))
	return nil
}
func NewAppointment(name string, day time.Weekday, start string, end string,
	participants []int) (*Appointment, error) {

	start_time, err := time.Parse(time.Kitchen, start)
	if err != nil {
		return nil, errors.New(start + " is not a valid start time.  Format times like \"XX:YYPM\".")
	}
	end_time, err := time.Parse(time.Kitchen, end)
	if err != nil {
		return nil, errors.New(end + " is not a valid end time.  Format times like \"XX:YYPM\".")
	}
	if !isValidTime(&start_time) || !isValidTime(&end_time) {
		return nil, errors.New("Appointment times must start and end at XY:00 or XY:30.")
	}
	if end_time.Sub(start_time) <= 0 {
		return nil, errors.New("Appointment must end after it starts.")
	}

	var parts [n]bool
	for _, i := range participants {
		if i < 1 || i > n {
			return nil, fmt.Errorf("%d is not a valid user ID.", i)
		}
		parts[i-1] = true
	}
	a := Appointment{name, day, start_time, end_time, parts}
	return &a, nil
}
Beispiel #8
0
func (t *TimePeriod) SetBSON(raw bson.Raw) error {
	var str string
	err := raw.Unmarshal(&str)
	if err == nil {
		str = strings.Replace(str, "\"", "", -1)
		split := strings.Split(str, "/")

		if len(split) == 2 {
			t.FromTime, err = time.Parse(STD_TIME_FORMAT_PERIOD, split[0])
			if err != nil {
				return err
			}
			t.ToTime, err = time.Parse(STD_TIME_FORMAT_PERIOD, split[1])
			if err != nil {
				return err
			}
		} else {
			t.FromTime, err = time.Parse(STD_TIME_FORMAT_INSTANT, split[0])
			if err != nil {
				return err
			}
		}
	}
	return err
}
Beispiel #9
0
func rangeIntoDays(start, end string) ([]timeBlock, error) {
	sT, err := time.Parse("20060102", start)
	if err != nil {
		return nil, err
	}

	eT, err := time.Parse("20060102", end)
	if err != nil {
		return nil, err
	}

	days := int(eT.Sub(sT).Hours())/24 + 1
	dates := make([]timeBlock, days)
	for i := 0; i < days; i++ {
		durString := fmt.Sprintf("%dh", 24*i)
		d, err := time.ParseDuration(durString)
		if err != nil {
			return nil, err
		}

		dayBegin := sT.Add(d)
		dayEnd := dayBegin.Add(time.Duration(86399000000000))
		dates[i] = timeBlock{dayBegin, dayEnd}
	}
	return dates, nil
}
Beispiel #10
0
func parseTxtInvoice(version, lino int, line string) (invoice *Invoice,
	err error) {
	invoice = &Invoice{}
	var raised, due string
	if version == fileVersion {
		if _, err = fmt.Sscanf(line, "INVOICE ID=%d CUSTOMER=%d "+
			"DEPARTMENT=%s RAISED=%s DUE=%s PAID=%t", &invoice.Id,
			&invoice.CustomerId, &invoice.DepartmentId, &raised, &due,
			&invoice.Paid); err != nil {
			return nil, fmt.Errorf("invalid invoice %v line %d", err, lino)
		}
	} else {
		if _, err = fmt.Sscanf(line, "INVOICE ID=%d CUSTOMER=%d "+
			"RAISED=%s DUE=%s PAID=%t", &invoice.Id,
			&invoice.CustomerId, &raised, &due, &invoice.Paid); err != nil {
			return nil, fmt.Errorf("invalid invoice %v line %d", err, lino)
		}
	}
	if invoice.Raised, err = time.Parse(dateFormat, raised); err != nil {
		return nil, fmt.Errorf("invalid raised %v line %d", err, lino)
	}
	if invoice.Due, err = time.Parse(dateFormat, due); err != nil {
		return nil, fmt.Errorf("invalid due %v line %d", err, lino)
	}
	if i := strings.Index(line, noteSep); i > -1 {
		invoice.Note = strings.TrimSpace(line[i+len(noteSep):])
	}
	if version < fileVersion {
		updateInvoice(invoice)
	}
	return invoice, nil
}
Beispiel #11
0
func (s *Summary) UnmarshalJSON(b []byte) error {
	e := new(encodedSummary)
	if err := json.Unmarshal(b, e); err != nil {
		return err
	}
	s.Port = e.Port
	s.Success = e.Success
	s.Failure = e.Failure
	s.Total = e.Total
	var err error
	if s.StartTime, err = time.Parse(time.RFC3339, e.StartTime); err != nil {
		return err
	}
	if s.EndTime, err = time.Parse(time.RFC3339, e.EndTime); err != nil {
		return err
	}
	s.Duration = s.EndTime.Sub(s.StartTime)
	s.Senders = e.Senders
	s.Timeout = time.Duration(e.Timeout) * time.Second
	if e.TLSVersion != nil {
		s.TLSVersion = *e.TLSVersion
	}
	if e.MailType != nil {
		s.MailType = *e.MailType
	}
	if e.CAFile != nil {
		s.CAFile = *e.CAFile
	}
	return nil
}
Beispiel #12
0
func getFeeds(feedSetting FeedSetting) {

	resp, err := http.Get(feedSetting.URL)

	//there's no reason to panic on this
	if err != nil {
		fmt.Printf("Couldn't reach URL: %v \n\n", feedSetting.URL)
		return
	}

	var results Result

	decoder := xml.NewDecoder(resp.Body)
	decoder.CharsetReader = charset.NewReaderLabel
	err = decoder.Decode(&results)
	checkError(err)

	//xml.Unmarshal([]byte(tempStr), &results)

	session, _ := mgo.Dial("localhost")
	feeds := session.DB("wcproc").C("feeds")

	feed := Feed{}
	feeds.Find(bson.M{"category": feedSetting.Name}).Sort("-date").One(&feed)

	//convert the feed.date string to time.Time since unmarshal wont do it for me
	for iter, element := range results.ItemList {

		lastThree := element.PubDate[len(element.PubDate)-3:]
		results.ItemList[iter].Link = strings.Trim(element.Link, " ")

		if _, err := strconv.Atoi(lastThree); err == nil {
			results.ItemList[iter].Date, err = time.Parse(time.RFC1123Z, element.PubDate)
			checkError(err)
		} else {
			results.ItemList[iter].Date, err = time.Parse(time.RFC1123, element.PubDate)
			checkError(err)
		}

	}

	//check to see if any articles exist past the last article date in db
	for iter, element := range results.ItemList {

		if element.Date.After(feed.Date.Local()) {

			//check title name against db for duplicates, some news feeds like to change the pubdate over the length of 6 hours
			matchup := Feed{}
			feeds.Find(bson.M{"title": element.Title, "category": feedSetting.Name}).One(&matchup)

			if matchup.Category == "" {
				fmt.Printf("adding:  %v -- %v \n", element.Date, element.Title)
				results.ItemList[iter].ArticleId = feedSetting.ArticleId
				results.ItemList[iter].Category = feedSetting.Name
				_ = feeds.Insert(results.ItemList[iter])
			}
		}
	}
	session.Close()
}
Beispiel #13
0
func machineFromMongodb(db *mongodb.MongoDB) (*machines, error) {
	from, err := time.Parse(time.RFC3339, "2015-03-07T13:15:00Z")
	if err != nil {
		return nil, err
	}

	to, err := time.Parse(time.RFC3339, "2015-04-10T07:30:00Z")
	if err != nil {
		return nil, err
	}

	machines := newMachines()
	err = db.Run("jMachines", func(c *mgo.Collection) error {
		var m koding.Machine
		iter := c.Find(
			bson.M{
				"createdAt": bson.M{
					"$gte": from.UTC(),
					"$lt":  to.UTC(),
				},
				// "status.state": machinestate.Stopped.String(),
			},
		).Iter()

		for iter.Next(&m) {
			machines.docs = append(machines.docs, m)
		}

		return iter.Close()
	})

	return machines, err
}
Beispiel #14
0
func (s *S) TestListHealingHistoryCmdRun(c *check.C) {
	var buf bytes.Buffer
	context := cmd.Context{Stdout: &buf}
	trans := &cmdtest.ConditionalTransport{
		Transport: cmdtest.Transport{Message: healingJsonData, Status: http.StatusOK},
		CondFunc: func(req *http.Request) bool {
			return req.URL.Path == "/docker/healing"
		},
	}
	manager := cmd.Manager{}
	client := cmd.NewClient(&http.Client{Transport: trans}, nil, &manager)
	healing := &ListHealingHistoryCmd{}
	err := healing.Run(&context, client)
	c.Assert(err, check.IsNil)
	startT, _ := time.Parse(time.RFC3339, "2014-10-23T08:00:00.000Z")
	endT, _ := time.Parse(time.RFC3339, "2014-10-23T08:30:00.000Z")
	startTStr := startT.Local().Format(time.Stamp)
	endTStr := endT.Local().Format(time.Stamp)
	expected := fmt.Sprintf(`Node:
+-----------------+-----------------+---------+---------+---------+-------+
| Start           | Finish          | Success | Failing | Created | Error |
+-----------------+-----------------+---------+---------+---------+-------+
| %s | %s | true    | addr1   | addr2   |       |
+-----------------+-----------------+---------+---------+---------+-------+
Container:
+-----------------+-----------------+---------+------------+------------+-------+
| Start           | Finish          | Success | Failing    | Created    | Error |
+-----------------+-----------------+---------+------------+------------+-------+
| %s | %s | false   | 1234567890 |            | err1  |
+-----------------+-----------------+---------+------------+------------+-------+
| %s | %s | true    | 1234567890 | 9234567890 |       |
+-----------------+-----------------+---------+------------+------------+-------+
`, startTStr, endTStr, startTStr, endTStr, startTStr, endTStr)
	c.Assert(buf.String(), check.Equals, expected)
}
Beispiel #15
0
// Extract will retrieve a Config resource from an operation result.
func (r commonResult) Extract() (*Config, error) {
	if r.Err != nil {
		return nil, r.Err
	}

	var response struct {
		Config Config `mapstructure:"configuration"`
	}

	err := mapstructure.Decode(r.Body, &response)
	val := r.Body.(map[string]interface{})["configuration"].(map[string]interface{})

	if t, ok := val["created"].(string); ok && t != "" {
		creationTime, err := time.Parse(time.RFC3339, t)
		if err != nil {
			return &response.Config, err
		}
		response.Config.Created = creationTime
	}

	if t, ok := val["updated"].(string); ok && t != "" {
		updatedTime, err := time.Parse(time.RFC3339, t)
		if err != nil {
			return &response.Config, err
		}
		response.Config.Updated = updatedTime
	}

	return &response.Config, err
}
Beispiel #16
0
// Status sorts by taking the CreationDate attribute, converting it to UNIX
// epoch, and adds it to the weighted value of the status tag. It sorts from
// newest to oldest AMIs.
func Status(a1, a2 *AMI) bool {
	var dateFmt = "2006-01-02T15:04:05.000Z"
	var icdate, istatus uint64
	var jcdate, jstatus uint64

	// Parse the CreationDate attribute
	if a1.Image.CreationDate != nil {
		if date, err := time.Parse(dateFmt, *a1.Image.CreationDate); err == nil {
			icdate = uint64(date.Unix())
		}
	}

	if a2.Image.CreationDate != nil {
		if date, err := time.Parse(dateFmt, *a2.Image.CreationDate); err == nil {
			jcdate = uint64(date.Unix())
		}
	}

	// Get the status tag
	if status := a1.Tag("status"); status != "" {
		istatus, _ = statusWeight[strings.ToLower(status)]
	}

	if status := a2.Tag("status"); status != "" {
		jstatus, _ = statusWeight[strings.ToLower(status)]
	}

	return icdate+istatus > jcdate+jstatus
}
Beispiel #17
0
func shouldUpdate(resp *http.Response, fi os.FileInfo, newer, newermetamtime bool) bool {
	var stale bool = false
	filemtime := fi.ModTime()
	if newermetamtime {
		parsed, err := time.Parse(time.RFC1123, resp.Header.Get("x-amz-meta-last-modified"))
		if err != nil {
			// can't see metamtime upload anyhow
			stale = true
			fmt.Fprint(os.Stderr, "Can't read metamtime, setting stale to upload again\n")
		}
		if parsed.Before(filemtime) {
			stale = true
		}
	}
	if newer {
		parsed, err := time.Parse(time.RFC1123, resp.Header.Get("Last-Modified"))
		if err != nil {
			// can't see metamtime upload anyhow
			stale = true
			fmt.Fprint(os.Stderr, "Can't read metamtime, setting stale to upload again\n")
		}
		if parsed.Before(filemtime) {
			stale = true
		}
	}
	return stale
}
Beispiel #18
0
func cliInit(c *cli.Context) (dates map[string]time.Time) {
	var err error

	dates = make(map[string]time.Time)

	if len(c.String("from")) > 0 {
		dates["fromDate"], err = time.Parse("2006-01-02", c.String("from"))
		if err != nil {
			fmt.Printf("%v", err)
			os.Exit(1)
		}
	} else {
		dates["fromDate"] = time.Date(time.Now().Year(), 1, 1, 0, 0, 0, 0, time.UTC)
	}

	if len(c.String("to")) > 0 {
		dates["toDate"], err = time.Parse(isoDateFmt, c.String("to"))
		if err != nil {
			fmt.Printf("%v", err)
			os.Exit(1)
		}
	} else {
		dates["toDate"] = time.Date(time.Now().Year(), 12, 31, 0, 0, 0, 0, time.UTC)
	}

	return dates
}
Beispiel #19
0
func getEventRequest(o *eventReqOpts) (*Request, bool, error) {
	ereq := NewRequest(o)
	stream := false

	ereq.EventType[o.etype] = true

	if o.maxEvents > 0 {
		ereq.maxEventsReturned = o.maxEvents
	}

	if len(o.startTime) > 0 {
		newTime, err := time.Parse(time.RFC3339, o.startTime)
		if err == nil {
			ereq.StartTime = newTime
		}
	}

	if len(o.endTime) > 0 {
		newTime, err := time.Parse(time.RFC3339, o.endTime)
		if err == nil {
			ereq.EndTime = newTime
		}
	}
	return ereq, stream, nil
}
// setMetaData sets the fs data from a storage.Object
func (o *FsObjectStorage) setMetaData(info *storage.Object) {
	o.url = info.MediaLink
	o.bytes = int64(info.Size)

	// Read md5sum
	md5sumData, err := base64.StdEncoding.DecodeString(info.Md5Hash)
	if err != nil {
		fs.Log(o, "Bad MD5 decode: %v", err)
	} else {
		o.md5sum = hex.EncodeToString(md5sumData)
	}

	// read mtime out of metadata if available
	mtimeString, ok := info.Metadata[metaMtime]
	if ok {
		modTime, err := time.Parse(timeFormatIn, mtimeString)
		if err == nil {
			o.modTime = modTime
			return
		} else {
			fs.Debug(o, "Failed to read mtime from metadata: %s", err)
		}
	}

	// Fallback to the Updated time
	modTime, err := time.Parse(timeFormatIn, info.Updated)
	if err != nil {
		fs.Log(o, "Bad time decode: %v", err)
	} else {
		o.modTime = modTime
	}
}
Beispiel #21
0
/*
requestTime method will parse the time from the request "x-amz-date" or "date" headers.
If the "x-amz-date" header is present, that will take priority over the "date" header.
If neither header is defined or we are unable to parse either header as a valid date
then we will create a new "x-amz-date" header with the current time.
*/
func (s *V4Signer) requestTime(req *http.Request) time.Time {

	// Get "x-amz-date" header
	date := req.Header.Get("x-amz-date")

	// Attempt to parse as ISO8601BasicFormat
	t, err := time.Parse(ISO8601BasicFormat, date)
	if err == nil {
		return t
	}

	// Attempt to parse as http.TimeFormat
	t, err = time.Parse(http.TimeFormat, date)
	if err == nil {
		req.Header.Set("x-amz-date", t.Format(ISO8601BasicFormat))
		return t
	}

	// Get "date" header
	date = req.Header.Get("date")

	// Attempt to parse as http.TimeFormat
	t, err = time.Parse(http.TimeFormat, date)
	if err == nil {
		return t
	}

	// Create a current time header to be used
	t = time.Now().UTC()
	req.Header.Set("x-amz-date", t.Format(ISO8601BasicFormat))
	return t
}
func TestRecord_GetRecordTime(t *testing.T) {
	recorder := &Recpt1Recorder{}
	r, _ := ParseRecord([]byte(`{
    "_id": "12345",
    "channel_name": "MyChannel",
    "title": "Title",
    "start_at": "2012-01-01T01:00:00Z",
    "end_at":   "2012-01-01T02:00:00Z"
  }`))
	now, _ := time.Parse(time.RFC3339, "2012-01-01T00:00:00Z")
	rec := recorder.GetRecordTime(r, now)
	if rec.Hours() != 1.0 {
		t.Errorf("GetRecordTime() => %f, want %f", rec.Hours(), 1.0)
	}

	now, _ = time.Parse(time.RFC3339, "2012-01-01T01:30:00Z")
	rec = recorder.GetRecordTime(r, now)
	if rec.Hours() != 0.5 {
		t.Errorf("GetRecordTime() => %f, want %f", rec.Hours(), 0.5)
	}

	now, _ = time.Parse(time.RFC3339, "2012-01-01T02:30:00Z")
	rec = recorder.GetRecordTime(r, now)
	if rec.Hours() != 0 {
		t.Errorf("GetRecordTime() => %f, want %f", rec.Hours(), 0)
	}
}
Beispiel #23
0
// RunEvents is the handler for 'scw events'
func RunEvents(ctx CommandContext, args EventsArgs) error {
	events, err := ctx.API.GetTasks()
	if err != nil {
		return fmt.Errorf("unable to fetch tasks from the Scaleway API: %v", err)
	}

	for _, event := range *events {
		startedAt, err := time.Parse("2006-01-02T15:04:05.000000+00:00", event.StartDate)
		if err != nil {
			return fmt.Errorf("unable to parse started date from the Scaleway API: %v", err)
		}

		terminatedAt := ""
		if event.TerminationDate != "" {
			terminatedAtTime, err := time.Parse("2006-01-02T15:04:05.000000+00:00", event.TerminationDate)
			if err != nil {
				return fmt.Errorf("unable to parse terminated date from the Scaleway API: %v", err)
			}
			terminatedAt = units.HumanDuration(time.Now().UTC().Sub(terminatedAtTime))
		}

		fmt.Printf("%s %s: %s (%s %d) %s\n", startedAt, event.HrefFrom, event.Description, event.Status, event.Progress, terminatedAt)
	}
	return nil
}
func main() {

	p := fmt.Println

	t := time.Now()
	p(t.Format(time.RFC3339))

	t1, e := time.Parse(
		time.RFC3339,
		"2012-11-01T22:08:41+00:00")
	p(t1)
	p(t.Format("3:04PM"))
	p(t.Format("Mon Jan _2 15:04:05 2006"))
	p(t.Format("2006-01-02T15:04:05.999999-07:00"))
	form := "3 04 PM"

	t2, e := time.Parse(form, "8 41 PM")
	p(t2)

	fmt.Printf("%d-%02d-%02dT%02d:%02d:%02d-00:00\n",
		t.Year(), t.Month(), t.Day(),
		t.Hour(), t.Minute(), t.Second())

	ansic := "Mon Jan _2 15:04:05 2006"
	_, e = time.Parse(ansic, "8:41PM")
	p(e)
}
Beispiel #25
0
func parseOffset(value string) (*time.Location, error) {
	var err error
	var t time.Time
	var loc *time.Location

	t, err = time.Parse("-07:00", value)
	if err == nil {
		return fixedZone(t), nil
	}

	t, err = time.Parse("-0700", value)
	if err == nil {
		return fixedZone(t), nil
	}

	_, err = time.Parse("MST", value)
	if err == nil {
		var offset int
		offset, err = timezone.GetOffset(value)
		if err != nil {
			return loc, err
		}

		return time.FixedZone(value, offset), nil
	}

	return loc, errInvalidOffset
}
Beispiel #26
0
func (b *Booking) PostGet(exe gorp.SqlExecutor) error {
	var (
		obj interface{}
		err error
	)

	obj, err = exe.Get(User{}, b.UserId)
	if err != nil {
		return fmt.Errorf("Error loading a booking's user (%d): %s", b.UserId, err)
	}
	b.User = obj.(*User)

	obj, err = exe.Get(Hotel{}, b.HotelId)
	if err != nil {
		return fmt.Errorf("Error loading a booking's hotel (%d): %s", b.HotelId, err)
	}
	b.Hotel = obj.(*Hotel)

	if b.CheckInDate, err = time.Parse(SQL_DATE_FORMAT, b.CheckInStr); err != nil {
		return fmt.Errorf("Error parsing check in date '%s':", b.CheckInStr, err)
	}
	if b.CheckOutDate, err = time.Parse(SQL_DATE_FORMAT, b.CheckOutStr); err != nil {
		return fmt.Errorf("Error parsing check out date '%s':", b.CheckOutStr, err)
	}
	return nil
}
Beispiel #27
0
func getCreationStartTime(t *testing.T, ctx *testutils.RktRunCtx, imageID string) (creation time.Time, start time.Time) {
	// Run rkt list --full
	rktCmd := fmt.Sprintf("%s list --full", ctx.Cmd())
	child := spawnOrFail(t, rktCmd)
	child.Wait()

	// Get creation time
	match := fmt.Sprintf(".*%s\t.*\t(.*)\t(.*)\t", imageID)
	result, out, err := expectRegexWithOutput(child, match)
	if err != nil {
		t.Fatalf("%q regex not found, Error: %v\nOutput: %v", match, err, out)
	}
	tmStr := strings.TrimSpace(result[1])
	creation, err = time.Parse(defaultTimeLayout, tmStr)
	if err != nil {
		t.Fatalf("Error parsing creation time: %q", err)
	}

	tmStr = strings.TrimSpace(result[2])
	start, err = time.Parse(defaultTimeLayout, tmStr)
	if err != nil {
		t.Fatalf("Error parsing start time: %q", err)
	}

	return creation, start
}
Beispiel #28
0
func TestKeyExpiry(t *testing.T) {
	kring, _ := ReadKeyRing(readerFromHex(expiringKeyHex))
	entity := kring[0]

	const timeFormat = "2006-01-02"
	time1, _ := time.Parse(timeFormat, "2013-07-01")
	// The expiringKeyHex key is structured as:
	//
	// pub  1024R/5E237D8C  created: 2013-07-01  expires: 2013-07-31  usage: SC
	// sub  1024R/1ABB25A0  created: 2013-07-01  expires: 2013-07-08  usage: E
	// sub  1024R/96A672F5  created: 2013-07-01  expires: 2013-07-31  usage: E
	//
	// So this should select the first, non-expired encryption key.
	key, _ := entity.encryptionKey(time1)
	if id := key.PublicKey.KeyIdShortString(); id != "1ABB25A0" {
		t.Errorf("Expected key 1ABB25A0 at time %s, but got key %s", time1.Format(timeFormat), id)
	}

	// Once the first encryption subkey has expired, the second should be
	// selected.
	time2, _ := time.Parse(timeFormat, "2013-07-09")
	key, _ = entity.encryptionKey(time2)
	if id := key.PublicKey.KeyIdShortString(); id != "96A672F5" {
		t.Errorf("Expected key 96A672F5 at time %s, but got key %s", time2.Format(timeFormat), id)
	}

	// Once all the keys have expired, nothing should be returned.
	time3, _ := time.Parse(timeFormat, "2013-08-01")
	if key, ok := entity.encryptionKey(time3); ok {
		t.Errorf("Expected no key at time %s, but got key %s", time3.Format(timeFormat), key.PublicKey.KeyIdShortString())
	}
}
Beispiel #29
0
func (image *ImageDetails) CreatedAt() (time.Time, error) {
	t, e := time.Parse("2006-01-02T15:04:05.999999999Z", image.Created)
	if e != nil {
		t, e = time.Parse("2006-01-02T15:04:05.999999999-07:00", image.Created)
	}
	return t, e
}
Beispiel #30
0
Datei: web.go Projekt: jmj/bosun
func Incidents(t miniprofiler.Timer, w http.ResponseWriter, r *http.Request) (interface{}, error) {
	alert := r.FormValue("alert")
	toTime := time.Now().UTC()
	fromTime := toTime.Add(-14 * 24 * time.Hour) // 2 weeks

	if from := r.FormValue("from"); from != "" {
		t, err := time.Parse(tsdbFormatSecs, from)
		if err != nil {
			return nil, err
		}
		fromTime = t
	}
	if to := r.FormValue("to"); to != "" {
		t, err := time.Parse(tsdbFormatSecs, to)
		if err != nil {
			return nil, err
		}
		toTime = t
	}
	incidents := schedule.GetIncidents(alert, fromTime, toTime)
	maxIncidents := 200
	if len(incidents) > maxIncidents {
		incidents = incidents[:maxIncidents]
	}
	return incidents, nil
}