Beispiel #1
0
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
}
Beispiel #2
0
// 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
}
Beispiel #3
0
func dumpMessage(c appengine.Context, msg *mail.Message) {
	iw := InfoWriter{c}

	c.Infof("--BEGIN MESSAGE")
	io.Copy(iw, msg.Body)
	c.Infof("END MESSAGE--")
}
Beispiel #4
0
Datei: app.go Projekt: 0x7cc/rsc
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
}
Beispiel #5
0
Datei: app.go Projekt: 0x7cc/rsc
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
}
Beispiel #6
0
// 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))
}
Beispiel #7
0
// 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
}
Beispiel #8
0
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
	}
}
Beispiel #9
0
func sendSubscription(addr string, c appengine.Context) {
	code := getSubCode()
	msg := &gaeMail.Message{
		Sender:  "*****@*****.**",
		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)
}
Beispiel #10
0
// 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 <*****@*****.**>"
	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)
	}
}
Beispiel #11
0
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
}
Beispiel #12
0
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
}
Beispiel #13
0
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
}
Beispiel #14
0
// 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
}
Beispiel #15
0
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
}
Beispiel #16
0
func unregisterUser(addr string, c appengine.Context) {
	q := datastore.NewQuery(USER_MODEL).
		Filter("Email =", addr).
		KeysOnly()
	keys, err := q.GetAll(c, nil)
	if err != nil {
		c.Errorf("Cound not query the model for %s: %v", addr, err)
		return
	}
	if len(keys) == 0 {
		c.Infof("No such user to unregister: %s", addr)
		return
	}
	for i := range keys {
		datastore.Delete(c, keys[i])
	}
	c.Infof("Removed user %s", addr)

	msg := &gaeMail.Message{
		Sender:  "*****@*****.**",
		To:      []string{addr},
		Subject: "Email unregistered",
		Body:    "user " + addr + " has been unregistered",
	}
	gaeMail.Send(c, msg)
}
Beispiel #17
0
// notifyOnFailure checks whether the supplied Commit or the subsequent
// Commit (if present) breaks the build for this builder.
// If either of those commits break the build an email notification is sent
// from a delayed task. (We use a task because this way the mail won't be
// sent if the enclosing datastore transaction fails.)
//
// This must be run in a datastore transaction, and the provided *Commit must
// have been retrieved from the datastore within that transaction.
func notifyOnFailure(c appengine.Context, com *Commit, builder string) error {
	if failIgnore[builder] {
		return nil
	}

	// TODO(adg): implement notifications for packages
	if com.PackagePath != "" {
		return nil
	}

	p := &Package{Path: com.PackagePath}
	var broken *Commit
	cr := com.Result(builder, "")
	if cr == nil {
		return fmt.Errorf("no result for %s/%s", com.Hash, builder)
	}
	q := datastore.NewQuery("Commit").Ancestor(p.Key(c))
	if cr.OK {
		// This commit is OK. Notify if next Commit is broken.
		next := new(Commit)
		q = q.Filter("ParentHash=", com.Hash)
		if err := firstMatch(c, q, next); err != nil {
			if err == datastore.ErrNoSuchEntity {
				// OK at tip, no notification necessary.
				return nil
			}
			return err
		}
		if nr := next.Result(builder, ""); nr != nil && !nr.OK {
			c.Debugf("commit ok: %#v\nresult: %#v", com, cr)
			c.Debugf("next commit broken: %#v\nnext result:%#v", next, nr)
			broken = next
		}
	} else {
		// This commit is broken. Notify if the previous Commit is OK.
		prev := new(Commit)
		q = q.Filter("Hash=", com.ParentHash)
		if err := firstMatch(c, q, prev); err != nil {
			if err == datastore.ErrNoSuchEntity {
				// No previous result, let the backfill of
				// this result trigger the notification.
				return nil
			}
			return err
		}
		if pr := prev.Result(builder, ""); pr != nil && pr.OK {
			c.Debugf("commit broken: %#v\nresult: %#v", com, cr)
			c.Debugf("previous commit ok: %#v\nprevious result:%#v", prev, pr)
			broken = com
		}
	}
	var err error
	if broken != nil && !broken.FailNotificationSent {
		c.Infof("%s is broken commit; notifying", broken.Hash)
		sendFailMailLater.Call(c, broken, builder) // add task to queue
		broken.FailNotificationSent = true
		_, err = datastore.Put(c, broken.Key(c), broken)
	}
	return err
}
Beispiel #18
0
func loadRev(c appengine.Context, uuid string, ch chan revRes) {
	rv := revRes{}
	if item, err := memcache.Get(c, "rev."+uuid); err == nil {
		rv.rev = string(item.Value)
	}

	if rv.rev == "" {
		req, err := http.NewRequest("HEAD", baseDBURL+uniqueDB+"/unique_"+uuid, nil)
		if err != nil {
			rv.err = err
			ch <- rv
			return
		}
		req.Header.Set("Authorization", authHeader)

		t := &urlfetch.Transport{Context: c}
		resp, err := t.RoundTrip(req)
		if err != nil {
			rv.err = err
			ch <- rv
			return
		}

		if resp.StatusCode == 200 {
			rv.rev = resp.Header.Get("etag")
			if len(rv.rev) > 1 {
				rv.rev = rv.rev[1 : len(rv.rev)-1]
			}
		} else {
			c.Infof("Got unfavorable response for key: %v", resp.Status)
		}
	}

	ch <- rv
}
Beispiel #19
0
/*
Does the actual google books API call.
*/
func lookupISBN(ctx appengine.Context, country string, isbn isbn13.ISBN13) (resp *data.BookMetaData, err error) {
	var r *http.Response
	url := fmt.Sprintf(lookupURLTemplate, uint64(isbn), country, apiKey)
	ctx.Debugf("Calling %s", fmt.Sprintf(lookupURLTemplate, uint64(isbn), country, "<hidden>"))

	client := urlfetch.Client(ctx)
	if r, err = client.Get(url); err == nil {
		if r.StatusCode != http.StatusOK {
			err = fmt.Errorf("Google API returned %s", r.Status)
		} else {
			reply := new(data.LookupReply)
			decode := json.NewDecoder(r.Body)
			defer r.Body.Close()

			ctx.Infof("Completed API call, result %s\n", r.Status)

			if err = decode.Decode(reply); err == nil {

				if reply.Count == 1 {
					resp = &reply.BookInfos[0]
				} else {
					ctx.Infof("Google books reported %d matching items: %v", reply.Count, reply)
					resp = new(data.BookMetaData)
					resp.Volume.Title = placeHolderText + isbn.String()
				}

				resp.Parent = country
				resp.ISBN = isbn.String()
			}
		}
	}

	return
}
Beispiel #20
0
func mailissue(ctxt appengine.Context, kind, key string) error {
	ctxt.Infof("mailissue %s", key)
	var cl CL
	err := app.ReadData(ctxt, "CL", key, &cl)
	if err != nil {
		return nil // error already logged
	}

	if len(cl.NeedMailIssue) == 0 {
		return nil
	}

	var mailed []string
	for _, issue := range cl.NeedMailIssue {
		err := postIssueComment(ctxt, issue, "CL https://codereview.appspot.com/"+cl.CL+" mentions this issue.")
		if err != nil {
			ctxt.Criticalf("posting to issue %v: %v", issue, err)
			continue
		}
		mailed = append(mailed, issue)
	}

	err = app.Transaction(ctxt, func(ctxt appengine.Context) error {
		var old CL
		if err := app.ReadData(ctxt, "CL", key, &old); err != nil {
			return err
		}
		old.MailedIssue = append(old.MailedIssue, mailed...)
		return app.WriteData(ctxt, "CL", key, &old)
	})

	return err
}
Beispiel #21
0
// Marks a bid as placed. This is purely informational for the user.
func PlaceBid(c appengine.Context, bidId string) error {
	var key *datastore.Key
	if k, err := datastore.DecodeKey(bidId); err != nil {
		return err
	} else {
		key = k
	}

	f := func(c appengine.Context) error {
		var bid Bid
		if err := datastore.Get(c, key, bidCodec{&bid}); err != nil {
			return err
		}

		if bid.State != InQueue {
			c.Infof("Not placing bid %v : State=%v", key, bid.State)
			return nil
		}

		bid.State = Placed

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

	return datastore.RunInTransaction(c, f, nil)
}
Beispiel #22
0
func fetchNomRoll(c appengine.Context, skey string, actId int) os.Error {
	///  req,err := http.NewRequest("GET", fmt.Sprintf("https://cadetone.aafc.org.au/activities/nominalroll.php?ActID=%d",actId), nil)
	///  if err != nil {
	///    c.Errorf("Fetch Roll - actId:%d - %s", actId, err.String())
	///    return err
	///  }
	///  session := c1SessionCookie(skey)
	///  injectSession(req,session)
	///  resp, err := GetClient(c).Do(req)
	///  if err != nil {
	///    c.Errorf("Fetch Roll - actId:%d - %s", actId, err.String())
	///    return err
	///  }
	///  defer resp.Body.Close()

	///  c.Infof("Fetch Roll OK - actId:%d", actId)

	///  res,err := parseNomRoll(c, &resp.Body)
	res, err := parseNomRoll(c)
	if err != nil {
		c.Errorf("Fetch Roll - actId:%d - %s", actId, err.String())
		return err
	}
	res.ActId = actId

	c.Infof(fmt.Sprint(res.ActId))
	for _, r := range res.Roll {
		c.Infof(fmt.Sprint(*r))
	}

	return err
}
Beispiel #23
0
Datei: app.go Projekt: 0x7cc/rsc
func updateCacheTime(c appengine.Context, seq int64) {
	const key = rootMemcacheKey
	bseq := []byte(strconv.FormatInt(seq, 10))
	for tries := 0; tries < 10; tries++ {
		item, err := memcache.Get(c, key)
		if err != nil {
			c.Infof("memcache.Get %q: %v", key, err)
			err = memcache.Add(c, &memcache.Item{Key: key, Value: bseq})
			if err == nil {
				c.Infof("memcache.Add %q %q ok", key, bseq)
				return
			}
			c.Infof("memcache.Add %q %q: %v", key, bseq, err)
		}
		v, err := strconv.ParseInt(string(item.Value), 10, 64)
		if err != nil {
			c.Criticalf("memcache.Get %q = %q (%v)", key, item.Value, err)
			return
		}
		if v >= seq {
			return
		}
		item.Value = bseq
		err = memcache.CompareAndSwap(c, item)
		if err == nil {
			c.Infof("memcache.CAS %q %d->%d ok", key, v, seq)
			return
		}
		c.Infof("memcache.CAS %q %d->%d: %v", key, v, seq, err)
	}
	c.Criticalf("repeatedly failed to update root key")
}
func loadFullFeed(domain string, ctx appengine.Context, r *http.Request) (buf *bytes.Buffer) {
	newctx := newappengine.NewContext(r)

	tok, err := config.Exchange(newctx, r.FormValue("code"))
	if err != nil {
		ctx.Errorf("exchange error: %v", err)
		return
	}

	ctx.Infof("tok: %v", tok)

	client := config.Client(newctx, tok)
	expFeedUrl := fmt.Sprintf(feedUrl, domain)
	expFeedUrl = expFeedUrl + "&max-results=50000"
	res, err := client.Get(expFeedUrl)
	if err != nil {
		ctx.Errorf("get: %v", err)
		return
	}

	defer res.Body.Close()

	buf = new(bytes.Buffer)
	io.Copy(buf, res.Body)
	return
}
Beispiel #25
0
func GetAllAccounts(c appengine.Context) ([]string, error) {

	accounts := []string{}
	_, err := memcache.Gob.Get(c, "AccountsArray", &accounts)
	if err == nil {
		return accounts, nil
	}

	var accountsDS []AccountDS
	query := datastore.NewQuery("Account")
	_, err = query.GetAll(c, &accountsDS)
	if err != nil {
		return []string{}, err
	}

	for _, account := range accountsDS {
		accounts = append(accounts, account.UserID)
	}

	cacheItem := &memcache.Item{
		Key:    "AccountsArray",
		Object: accounts,
	}

	err = memcache.Gob.Set(c, cacheItem)
	if err != nil {
		c.Infof("Accounts array not cached (%v)", err)
	}

	return accounts, err
}
Beispiel #26
0
func verifyMassageWithPaypal(ctx appengine.Context, content string, testIpnField string) error {

	paypalIpnUrl := PaypalIpn
	if testIpnField != "" {
		if testIpnField == "1" {
			paypalIpnUrl = PaypalIpnSandBox
		} else {
			paypalIpnUrl = localIpn
		}
	}

	ctx.Infof("Sending msg to: " + paypalIpnUrl)
	extraData := []byte("cmd=_notify-validate&")
	client := urlfetch.Client(ctx)
	resp, err := client.Post(paypalIpnUrl, FromEncodedContentType, bytes.NewBuffer(append(extraData, content...)))
	if err != nil {
		return err
	}

	respBody, err := ioutil.ReadAll(resp.Body)
	resp.Body.Close()

	ctx.Debugf("Ipn Validation response " + string(respBody))

	if err == nil && string(respBody) != "VERIFIED" {
		return IpnMessageCouldNotBeValidated
	}

	return err
}
Beispiel #27
0
// AppEngineLogHandler sends logs to AppEngine.
// The record must contain the appengine request context.
func AppEngineLogHandler() log15.Handler {
	logFormat := log15.JsonFormat()
	return log15.FuncHandler(func(r *log15.Record) error {
		var c appengine.Context
		index := 0
		for i, e := range r.Ctx {
			if ct, ok := e.(appengine.Context); ok {
				c = ct
				index = i
				break
			}
		}
		if c == nil {
			// not in the context of a request
			return nil
		}
		r.Ctx = append(r.Ctx[:index-1], r.Ctx[index+1:]...)
		log := string(logFormat.Format(r))
		switch r.Lvl {
		case log15.LvlCrit:
			c.Criticalf(log)
		case log15.LvlError:
			c.Errorf(log)
		case log15.LvlWarn:
			c.Warningf(log)
		case log15.LvlInfo:
			c.Infof(log)
		case log15.LvlDebug:
			c.Debugf(log)
		}
		return nil
	})
}
Beispiel #28
0
// Log is a helper function that logs the given message to appenging
// with the given priority. Accepted priorities are "debug", "info",
// "warn", "error", and "crit". Other values default to "error".
func Log(c appengine.Context, r *http.Request, priority string,
	message string, params ...interface{}) {

	message = fmt.Sprintf("[%s] [%s] [%s]: %s", r.RemoteAddr, r.Method,
		r.URL, message)

	switch priority {
	case "debug":
		c.Debugf(message, params...)

	case "info":
		c.Infof(message, params...)

	case "warn":
		c.Warningf(message, params...)

	case "error":
		c.Errorf(message, params...)

	case "crit":
		c.Criticalf(message, params...)

	default:
		c.Errorf(message, params...)
	}
}
Beispiel #29
0
func (e Event) GetHTMLView(c appengine.Context) string {
	buffer := new(bytes.Buffer)
	var tmpltxt = `<label>Event Title: </label><a href="https://orgreminders.appspot.com/editevent?id={{.Key}}">{{.Title}}</a>
	<br>
	<label>When Due: </label>{{.DueFormatted}}
	<br>
	<label>Organization(s): </label>{{range .Orgs}}{{.}},{{end}}
	<br>
	<label>Email enabled: </label>{{.Email}}
	<br>
	<label>Text Enabled: </label>{{.Text}}
	<br>
	<label>Email Message: </label><br><div class="msgbody">{{.EmailMessage}}</div>
	<br>
	<label>Text Message: </label><br><div class="msgbody"><pre>{{.TextMessage}}</pre></div>
	<br>`

	template, terr := template.New("foo").Parse(tmpltxt)

	if terr != nil {
		c.Infof("error parsing event html template: %v", terr)
		return ""
	}

	template.Execute(buffer, e)
	return buffer.String()
}
Beispiel #30
0
func SaveQuestion(c appengine.Context, question Question) {
	key := datastore.NewIncompleteKey(c, "Question", QuestionKey(c))
	_, err := datastore.Put(c, key, &question)
	if err != nil {
		c.Infof("Error in saving question: ", err)
	}
}