Golang Context.Infof方法代码示例

func lookupShelfDatastore(ctx ae.Context, user string) (shelf *data.Bookshelf, err error) {
	ancestor := ds.NewKey(ctx, data.KindBookshelf, user, 0, nil)
	query := ds.NewQuery(data.KindBookInfo).Ancestor(ancestor)

	targetMeta := new(data.BookMetaData)
	targetShelf := new(data.Bookshelf)

	switch err = ds.Get(ctx, ancestor, shelf); err {
	case nil:
		// all good
	case ds.ErrNoSuchEntity:
		targetShelf.Version = Latest
	default:
		return
	}

	it := query.Run(ctx)

	for _, err = it.Next(targetMeta); err == nil; _, err = it.Next(targetMeta) {
		targetShelf.Books = append(targetShelf.Books, *targetMeta)
		targetMeta = new(data.BookMetaData)
	}

	if err == ds.Done {
		err = nil
		shelf = targetShelf
	}

	ctx.Infof("Found %d items in datastore for key %v (error: %v)", len(targetShelf.Books), ancestor, err)

	return
}

// extracts the URL from an Feed. If the feed has publication date, we only
// add the URL since the last feed update
func getLinksFromFeed(dsFeed *data.Feed, r *http.Request, c appengine.Context) ([]string, error) {
	c.Infof("DS Feed @ importer: %v", dsFeed)
	_, body, err := extract.GetURL(dsFeed.URL, r)
	if err != nil {
		return nil, err
	}

	rss, err := parseFeedContent(body)
	if err != nil {
		return nil, err
	}

	var urls []string
	stopURL := dsFeed.LastURL
	for index, i := range rss.ItemList {
		if index == 0 {
			dsFeed.LastURL = i.Link
		}
		if i.Link == stopURL {
			break
		}
		urls = append(urls, i.Link)
	}

	return urls, nil
}

func dumpMessage(c appengine.Context, msg *mail.Message) {
	iw := InfoWriter{c}

	c.Infof("--BEGIN MESSAGE")
	io.Copy(iw, msg.Body)
	c.Infof("END MESSAGE--")
}

func read(c appengine.Context, name string) (fi *FileInfo, data []byte, err error) {
	name, _, _ = mangle(c, name)
	fi1, err := stat(c, name)
	if err != nil {
		return nil, nil, err
	}
	if fi1.IsDir {
		dt, err := readdir(c, name)
		if err != nil {
			return nil, nil, err
		}
		fi = fi1
		data = dt
		return fi, data, nil
	}

	root := datastore.NewKey(c, "RootKey", "v2:", 0, nil)
	dkey := datastore.NewKey(c, "FileData", "", fi1.Qid, root)
	var fd FileData
	c.Infof("DATASTORE Read %q", name)
	if err := datastore.Get(c, dkey, &fd); err != nil {
		return nil, nil, err
	}
	fi = fi1
	data = fd.Data
	return fi, data, nil
}

func cachePathTime(c appengine.Context, path string) (t int64, err error) {
	t, err = cacheTime(c)
	if err != nil {
		return 0, err
	}

	key := fmt.Sprintf("%d,mtime,%s", t, path)
	item, err := memcache.Get(c, key)
	if err == nil {
		v, err := strconv.ParseInt(string(item.Value), 10, 64)
		if err == nil {
			if chatty {
				c.Infof("cachePathTime %q = %v", key, v)
			}
			return v, nil
		}
		c.Criticalf("memcache.Get %q = %q (%v) - deleting", key, item.Value, err)
		memcache.Delete(c, key)
	}

	var seq int64
	if fi, err := stat(c, path); err == nil {
		seq = fi.Seq
	}

	c.Infof("cachePathTime save %q = %v", key, seq)
	item = &memcache.Item{Key: key, Value: []byte(strconv.FormatInt(seq, 10))}
	if err := memcache.Set(c, item); err != nil {
		c.Criticalf("memcache.Set %q %q: %v", key, item.Value, err)
	}
	return seq, nil
}

// Object usually too big (1MB limit), so shard.
// http://stackoverflow.com/questions/9127982/
func BytesToShardedMemcache(c appengine.Context, key string, b []byte) {
	/*
		var buf bytes.Buffer
		if err := gob.NewEncoder(&buf).Encode(f); err != nil {
			db.C.Errorf("fdb error encoding item: %v", err)
			return
		}
		b := buf.Bytes()
	*/

	items := []*memcache.Item{}
	for i := 0; i < len(b); i += chunksize {
		k := fmt.Sprintf("=%d=%s", i, key)
		s, e := i, i+chunksize-1
		if e >= len(b) {
			e = len(b) - 1
		}
		c.Infof(" #=== [%7d, %7d] (%d) %s", s, e, len(b), k)
		items = append(items, &memcache.Item{Key: k, Value: b[s : e+1]}) // slice sytax is [s,e)
	}

	if err := memcache.SetMulti(c, items); err != nil {
		c.Errorf(" #=== cdb sharded store fail: %v", err)
	}

	c.Infof(" #=== Stored '%s' (len=%d)!", key, len(b))
}

// This will reimburse the bid's price and fee to the buyer.
func RetireBid(c appengine.Context, key *datastore.Key) error {
	f := func(c appengine.Context) error {
		now := time.Now()
		dao := NewGaeAccountingDao(c, true)
		var bid Bid
		if err := datastore.Get(c, key, bidCodec{&bid}); err != nil {
			return err
		}

		if bid.State == Matched {
			c.Infof("Not retiring matched bid %v", key)
			return nil
		}

		if err := bid.Retire(dao, key.Encode(), now); err != nil {
			return err
		}

		if _, err := datastore.Put(c, key, bidCodec{&bid}); err != nil {
			return err
		}

		return dao.Flush()
	}

	if err := datastore.RunInTransaction(c, f, &datastore.TransactionOptions{XG: true}); err != nil {
		return err
	}

	return nil
}

func UpdateUnreadCounts(c appengine.Context, ch chan<- Subscription, subscriptionKey *datastore.Key, subscription Subscription) {
	originalSubscriptionCount := subscription.UnreadCount
	q := datastore.NewQuery("Article").Ancestor(subscriptionKey).Filter("Properties =", "unread")

	if count, err := q.Count(c); err != nil {
		c.Errorf("Error getting unread count: %s", err)
		goto done
	} else if count != originalSubscriptionCount {
		subscription.UnreadCount = count
		if _, err := datastore.Put(c, subscriptionKey, &subscription); err != nil {
			c.Errorf("Error writing unread count: %s", err)
			goto done
		}
	}

	if originalSubscriptionCount != subscription.UnreadCount {
		c.Infof("Subscription count corrected to %d (was: %d)",
			subscription.UnreadCount, originalSubscriptionCount)
	}

done:
	if ch != nil {
		ch <- subscription
	}
}

func sendSubscription(addr string, c appengine.Context) {
	code := getSubCode()
	msg := &gaeMail.Message{
		Sender:  "[email protected]",
		To:      []string{addr},
		Subject: "confirm " + code,
		Body:    "Reply without changing subject",
	}
	if err := gaeMail.Send(c, msg); err != nil {
		c.Errorf("Couldn't send email to %s for %s: %v", addr, code, err)
	}

	// XXXX if successful, register the code as (email, code, 0 (retry)) tuple.
	confirmation := Confirmation{
		Email: addr,
		Code:  code,
		Retry: 0,
	}

	_, err := datastore.Put(c,
		datastore.NewIncompleteKey(c, CONFIRM_MODEL, nil),
		&confirmation)
	if err != nil {
		c.Errorf("Couldn't write confirmation code for %s, %s: %v", addr, code, err)
		return
	}
	c.Infof("Wrote confirmation successfully for %s, %s", addr, code)
}

// sendAlert sends an alert email about the potential car hijacking.
func sendAlert(c appengine.Context, accKeyID int64, alertMsg, bodyTempl string) {
	// load account
	acc := new(ds.Account)
	key := datastore.NewKey(c, ds.ENameAccount, "", accKeyID, nil)
	if err := datastore.Get(c, key, acc); err != nil {
		c.Errorf("Failed to load account: %v", err)
		return
	}

	const adminEmail = "Andras Belicza <[email protected]>"
	msg := &mail.Message{
		Sender:  adminEmail,
		To:      []string{acc.Email},
		ReplyTo: adminEmail,
		Subject: "[IczaGPS] ALERT: " + alertMsg,
		Body:    fmt.Sprintf(bodyTempl, acc.Email),
	}
	if len(acc.ContactEmail) > 0 {
		msg.Cc = []string{acc.ContactEmail}
	}
	if err := mail.Send(c, msg); err == nil {
		c.Infof("Sent successful alert email: %s", alertMsg)
	} else {
		c.Errorf("Couldn't send alert email: %s, %v", alertMsg, err)
	}
}

func UpdateAllSubscriptions(c appengine.Context, userID UserID) error {
	userKey, err := userID.key(c)
	if err != nil {
		return err
	}

	var subscriptions []Subscription

	q := datastore.NewQuery("Subscription").Ancestor(userKey).Limit(defaultBatchSize)
	subscriptionKeys, err := q.GetAll(c, &subscriptions)
	if err != nil {
		return err
	}

	started := time.Now()
	doneChannel := make(chan Subscription)
	subscriptionCount := len(subscriptions)

	for i := 0; i < subscriptionCount; i++ {
		go updateSubscriptionAsync(c, subscriptionKeys[i], subscriptions[i], doneChannel)
	}

	for i := 0; i < subscriptionCount; i++ {
		<-doneChannel
	}

	c.Infof("%d subscriptions completed in %s", subscriptionCount, time.Since(started))

	return nil
}

func parse_chunk_map(c appengine.Context) error {
	var err error

	if chunkMapParsed == true {
		return nil
	}

	bytes, err := readGzFile("chunks.json.gz")
	if err != nil {
		return err
	}

	//log.Fatal("read bytes:", string(bytes))

	err = json.Unmarshal(bytes, &chunkMap)

	c.Infof("Parsed %d bytes of JSON into %d map entries", len(bytes), len(chunkMap))

	if err != nil {
		return err
	}

	chunkMapParsed = true

	return nil
}

func SearchIndex(c appengine.Context, q string) (pairs [][]string, err error) {
	client := urlfetch.Client(c)
	u := searchFindUrl
	u.RawQuery = url.Values{"q": []string{q}}.Encode()
	res, err := client.Get(u.String())
	if err == nil {
		defer res.Body.Close()
		if res.StatusCode != 200 {
			err = fmt.Errorf("%s -> %d", u.String(), res.StatusCode)
			return
		}
	}

	b, err := ioutil.ReadAll(res.Body)
	if err != nil {
		return
	}
	c.Infof("Response from search: %s", b)

	m := make(map[string]interface{})
	err = json.Unmarshal(b, &m)
	if err != nil {
		return
	}

	nuts := m["Nuts"].([]interface{})
	pairs = make([][]string, len(nuts))
	for i, n := range nuts {
		nm := n.(map[string]interface{})
		pairs[i] = []string{nm["Vendor"].(string), nm["Name"].(string)}
	}
	return
}

// Sends post notification mail
func SendMail(c appengine.Context, entry Entry) error {
	config, err := ParseConfig("./config/mailConfig.json")
	if err != nil {
		return err
	}

	// Prepares email message
	msg := new(mail.Message)
	msg.Sender = config.Sender
	msg.To = make([]string, 1)
	msg.To[0] = config.To
	msg.Subject = "New post made from Legacy-BBS-Go"
	var body bytes.Buffer
	var mailTemplate = template.Must(template.ParseFiles("template/notificationMailTemplate.txt"))
	if err := mailTemplate.Execute(&body, entry); err != nil {
		return err
	}
	msg.Body = body.String()
	if err := mail.Send(c, msg); err != nil {
		return err
	}

	c.Infof("Notification mail sent to \"" + config.To + "\"")

	return nil
}

func orderHandler(c appengine.Context, w http.ResponseWriter, r *http.Request) (interface{}, error) {
	oid := r.URL.Path[len(ORDERS_API):]
	c.Infof("Received oid %v", oid)
	if len(oid) > 0 {
		switch r.Method {
		case "GET":
			oid64, err := strconv.ParseInt(oid, 10, 64)
			if err != nil {
				return nil, err
			}
			order := new(Order)
			order.Id = OrderId(oid64)
			return order.get(c)
		default:
			return nil, fmt.Errorf(r.Method + " on " + r.URL.Path + " not implemented")
		}
	} else {
		switch r.Method {
		case "POST":
			return orderSaveEntryPoint(c, r)
		case "GET":
			return getAllOrders(c)
		default:
			return nil, fmt.Errorf(r.Method + " on " + r.URL.Path + " not implemented")
		}
	}
	return nil, nil
}