Golang appengine-blobstore.NewReader类(方法)实例源码

func ScanOfertaBlob(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	const batch = 300
	page, _ := strconv.Atoi(r.FormValue("pg"))
	if page < 1 {
		page = 1
	}
	offset := batch * (page - 1)
	q := datastore.NewQuery("Oferta").Offset(offset).Order("-FechaHora").Limit(batch)
	n, _ := q.Count(c)
	for i := q.Run(c); ; {
		var e model.Oferta
		key, err := i.Next(&e)
		if err == datastore.Done {
			break
		}

		// Se crea la URL para servir la oferta desde el CDN, si no se puede
		// se deja en blanco
		var imgprops image.ServingURLOptions
		imgprops.Secure = true
		imgprops.Size = 400
		imgprops.Crop = false
		if e.BlobKey != "none" {
			reader := blobstore.NewReader(c, e.BlobKey)
			if _, err := ioutil.ReadAll(reader); err != nil {
				fmt.Fprintf(w, "Error en idoft: %s, idemp: %s, blobkey: %v, Fecha: %v\n", e.IdOft, e.IdEmp, string(e.BlobKey), e.FechaHora)
				e.BlobKey = "none"
				_, err = datastore.Put(c, key, &e)
			}
		}
	}
	fmt.Fprintf(w, "Batch: %d, count: %d, from  %d to %d\n", page, n, offset, offset+n)
	return
}

func GetPostContent(context appengine.Context, p Post) (string, error) {

	data, err := ioutil.ReadAll(blobstore.NewReader(context, p.Content))
	if err != nil {
		context.Errorf("ioutil.ReadAll: %v", err)
		return "", err
	}
	if len(data) <= 0 {
		context.Errorf("len(data): %v", len(data))
		return "", errors.New("len(data) < 1")
	}

	var decoded interface{}
	err = json.Unmarshal(data, &decoded)
	if err != nil {
		context.Errorf("json.Unmarshal: %v", err)
		return "", err
	}

	q := decoded.(map[string]interface{})
	content, ok := q["data"].(string)
	if !ok {
		context.Errorf("post content has no 'data' field internally")
		return "", errors.New("post has no 'data' field")
	}

	return content, nil
}

func (sto *appengineStorage) Fetch(br blob.Ref) (file io.ReadCloser, size uint32, err error) {
	loan := ctxPool.Get()
	ctx := loan
	defer func() {
		if loan != nil {
			loan.Return()
		}
	}()

	row, err := fetchEnt(ctx, br)
	if err == datastore.ErrNoSuchEntity {
		err = os.ErrNotExist
		return
	}
	if err != nil {
		return
	}
	if !row.inNamespace(sto.namespace) {
		err = os.ErrNotExist
		return
	}

	closeLoan := loan
	var c io.Closer = &onceCloser{fn: func() { closeLoan.Return() }}
	loan = nil // take it, so it's not defer-closed

	reader := blobstore.NewReader(ctx, appengine.BlobKey(string(row.BlobKey)))
	type readCloser struct {
		io.Reader
		io.Closer
	}
	return readCloser{reader, c}, uint32(row.Size), nil
}

func upload(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	blobs, _, err := blobstore.ParseUpload(r)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	file := blobs["file"]
	if len(file) == 0 {
		c.Errorf("No file uploaded")
		http.Redirect(w, r, "/", http.StatusFound)
		return
	}
	reader := blobstore.NewReader(c, file[0].BlobKey)
	var pkg *Package
	switch file[0].ContentType {
	case "application/x-tar":
		pkg, err = parsePackageVarsFromTar(bufio.NewReader(reader))
		if err == nil {
			pkg.Type = TAR
		}
	case "application/octet-stream":
		pkg, err = parsePackageVarsFromFile(bufio.NewReader(reader))
		if err == nil {
			pkg.Type = SINGLE
		}
	default:
		http.Error(w, err.Error(), http.StatusBadRequest)
	}

	if err != nil {
		c.Errorf(fmt.Sprintf("Error reading from upload: %v", err))
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	key := packageKey(c, pkg.Name)
	_, err = datastore.Put(c, key, pkg)
	if err != nil {
		c.Errorf(fmt.Sprintf("Failed to save package %v", pkg.Name))
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	contents := Contents{
		BlobKey:    file[0].BlobKey,
		Version:    pkg.LatestVersion,
		UploadTime: time.Now().UTC(),
	}
	_, err = datastore.Put(c, versionKey(c, pkg.LatestVersion, key), &contents)
	if err != nil {
		c.Errorf(
			fmt.Sprintf(
				"Failed to save contents for version %v, package %v",
				pkg.LatestVersion, pkg.Name))
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	http.Redirect(w, r, "/upload_complete.html?package="+
		url.QueryEscape(pkg.Name), http.StatusFound)
}

func handleHome(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "text/html; charset=utf-8")
	if r.Method != "GET" || r.URL.Path != "/" {
		serve404(w)
		return
	}
	c := appengine.NewContext(r)
	q := datastore.NewQuery("Page").Order("-Date").Limit(4)

	n, _ := q.Count(c)
	//http.Error(w, strconv.Itoa(n), 404)
	pages := make([]Page, 0, 4)
	if n > 0 {
		_, err := q.GetAll(c, &pages)
		if nil != err {
			serveError(c, w, err)
			return
		}
	}
	if 0 == n {
		pages = append(pages, Page{})
	}
	for i := n; i < 4; i++ {
		pages = append(pages, pages[0])
	}
	headPage := pages[0]
	otherPages := pages[1:4]

	reader := blobstore.NewReader(c, headPage.HTML)
	buf := new(bytes.Buffer)
	buf.ReadFrom(reader)

	err := homeTemplate.ExecuteTemplate(w, "Head", headPage)
	if err != nil {
		serveError(c, w, err)
		return
	}

	err = homeTemplate.ExecuteTemplate(w, "Blob", buf)
	if err != nil {
		serveError(c, w, err)
		return
	}

	err = homeTemplate.ExecuteTemplate(w, "Title", headPage.Title)
	if err != nil {
		serveError(c, w, err)
		return
	}

	err = homeTemplate.ExecuteTemplate(w, "Other", otherPages)
	if err != nil {
		serveError(c, w, err)
		return
	}
	return
}

func blob(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	w.Header().Set("Content-Type", "image/png")
	f := blobstore.NewReader(c, appengine.BlobKey("AMIfv97HhOdzO1aYQEe0QBrzbWSjSgWr2-JUxFJh_KnwxAhEdAqqK76TeE7vm5eDJW0ZoMwFVwur0Ub3t1kD_KzP3yJi4LIG6A-dCdJrJYafoJgH7SITCBum4MF9CY-C7na5fBulmKwQXd2mEYMyfk_RDgeQN1SZug"))
	buf := make([]byte, 1024*1024)
	n, err := f.Read(buf)
	if err != nil {
		panic(err)
	}
	w.Write(buf[:n])
}

// GetFileBlob retrieves a specific FileBlob from the datastore and opens an
// io.Reader for that blob.
func GetFileBlob(c appengine.Context, t, n string) (*FileBlob, error) {
	fb := &FileBlob{
		Type: t,
		Name: n,
	}
	err := datastore.Get(c, fb.key(c), fb)
	if err != nil {
		return fb, err
	}
	fb.Data = blobstore.NewReader(c, fb.BlobKey)
	return fb, nil
}

func handleFile(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "text/html; charset=utf-8")
	c := appengine.NewContext(r)
	reader := blobstore.NewReader(c, appengine.BlobKey(r.FormValue("blobKey")))
	buf := new(bytes.Buffer)
	buf.ReadFrom(reader)
	err := pageTemplate.Execute(w, buf)
	if err != nil {
		serveError(c, w, err)
	}
	//blobstore.Send(w, appengine.BlobKey(r.FormValue("blobKey")))
}

func RestoreTask(w http.ResponseWriter, r *http.Request) {
	blobKey := appengine.BlobKey(r.FormValue("blobKey"))
	c := appengine.NewContext(r)
	blobInfo, err := blobstore.Stat(c, blobKey)
	if err != nil {
		c.Errorf("%v", err)
		return
	}
	c.Infof("Restoring from %s", blobInfo.Filename)
	reader := blobstore.NewReader(c, blobKey)
	LoadDB(c, reader)
}

func loadZipMap(c appengine.Context) error {
	b, err := findFileBlob(c, "zipcode.csv")
	if err != nil {
		return err
	}

	reader := blobstore.NewReader(c, b)
	zipMap, err = zipcode.GetMap(reader)
	if err != nil {
		return err
	}

	return nil
}

func importOPMLTask(pfc *PFContext) (TaskMessage, error) {
	c := pfc.C

	var blobKey appengine.BlobKey
	if blobKeyString := pfc.R.PostFormValue("opmlBlobKey"); blobKeyString == "" {
		return TaskMessage{}, errors.New("Missing blob key")
	} else {
		blobKey = appengine.BlobKey(blobKeyString)
	}

	reader := blobstore.NewReader(c, blobKey)

	opml, err := rss.ParseOPML(reader)
	if err != nil {
		// Remove the blob
		if err := blobstore.Delete(c, blobKey); err != nil {
			c.Warningf("Error deleting blob (key %s): %s", blobKey, err)
		}

		return TaskMessage{}, err
	}

	// Remove the blob
	if err := blobstore.Delete(c, blobKey); err != nil {
		c.Warningf("Error deleting blob (key %s): %s", blobKey, err)
	}

	importStarted := time.Now()

	parentRef := storage.FolderRef{
		UserID: pfc.UserID,
	}

	doneChannel := make(chan *rss.Outline)
	importing := importSubscriptions(pfc, doneChannel, pfc.UserID, parentRef, opml.Outlines())

	for i := 0; i < importing; i++ {
		subscription := <-doneChannel
		c.Infof("Completed %s", subscription.Title)
	}

	c.Infof("All completed in %s", time.Since(importStarted))

	return TaskMessage{
		Message: _l("Subscriptions imported successfully"),
		Refresh: true,
	}, nil
}

func GedcomHandler(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)

	key := appengine.BlobKey(r.FormValue("key"))

	buffer := new(bytes.Buffer)
	buffer.ReadFrom(blobstore.NewReader(c, key))
	var raw_data RawGedCom
	if !raw_data.Parse(buffer) {
		w.WriteHeader(http.StatusBadRequest)
		fmt.Fprintf(w, "Bad data")
		return
	}
	w.WriteHeader(http.StatusOK)
	fmt.Fprintf(w, "ok")
}

func GetFromBlobstore(c appengine.Context, blobkey appengine.BlobKey, dst interface{}) (interface{}, error) {
	//TODO: check capabilities

	reader := blobstore.NewReader(c, blobkey)
	data, err := ioutil.ReadAll(reader)
	if err != nil {
		c.Errorf("Datastore - GetFromBlobstore - error 2 - %s", err)
		return nil, err
	}
	dec := gob.NewDecoder(bytes.NewBuffer(data))
	err = dec.Decode(dst)
	if err != nil {
		c.Errorf("Datastore - GetFromBlobstore - error 3 - %s", err)
		return nil, err
	}
	return dst, nil
}

func (sto *appengineStorage) FetchStreaming(br *blobref.BlobRef) (file io.ReadCloser, size int64, err error) {
	ctx := sto.ctx
	var loan ContextLoan
	if ctx == nil {
		loan = ctxPool.Get()
		ctx = loan
		defer func() {
			if loan != nil {
				loan.Return()
			}
		}()
	}

	row, err := fetchEnt(ctx, br)
	if err == datastore.ErrNoSuchEntity {
		err = os.ErrNotExist
		return
	}
	if err != nil {
		return
	}
	if !row.inNamespace(sto.namespace) {
		err = os.ErrNotExist
		return
	}
	size, err = row.size()
	if err != nil {
		return
	}
	var c io.Closer
	if loan != nil {
		closeLoan := loan
		c = &onceCloser{fn: func() { closeLoan.Return() }}
		loan = nil // take it, so it's not defer-closed
	} else {
		c = dummyCloser
	}
	reader := blobstore.NewReader(ctx, appengine.BlobKey(string(row.BlobKey)))
	type readCloser struct {
		io.Reader
		io.Closer
	}
	return readCloser{reader, c}, size, nil
}

func importOPML(pfc *PFContext) (interface{}, error) {
	c := pfc.C
	r := pfc.R

	blobs, other, err := blobstore.ParseUpload(r)
	if err != nil {
		return nil, NewReadableError(_l("Error receiving file"), &err)
	} else if len(other["client"]) > 0 {
		if clientID := other["client"][0]; clientID != "" {
			pfc.ChannelID = string(pfc.UserID) + "," + clientID
		}
	}

	var blobKey appengine.BlobKey
	if blobInfos := blobs["opml"]; len(blobInfos) == 0 {
		return nil, NewReadableError(_l("File not uploaded"), nil)
	} else {
		blobKey = blobInfos[0].BlobKey
		reader := blobstore.NewReader(c, blobKey)

		if _, err := rss.ParseOPML(reader); err != nil {
			if err := blobstore.Delete(c, blobKey); err != nil {
				c.Warningf("Error deleting blob (key %s): %s", blobKey, err)
			}

			return nil, NewReadableError(_l("Error reading OPML file"), &err)
		}
	}

	params := taskParams{
		"opmlBlobKey": string(blobKey),
	}
	if err := startTask(pfc, "import", params, importQueue); err != nil {
		// Remove the blob
		if err := blobstore.Delete(c, blobKey); err != nil {
			c.Warningf("Error deleting blob (key %s): %s", blobKey, err)
		}

		return nil, NewReadableError(_l("Cannot import - too busy"), &err)
	}

	return _l("Importing, please wait…"), nil
}

func updatePage(c appengine.Context, blobKey appengine.BlobKey) (Page, error) {
	reader := blobstore.NewReader(c, blobKey)
	buf := new(bytes.Buffer)
	buf.ReadFrom(reader)
	xmlDoc := new(DocumentXML)
	err := xml.Unmarshal(buf.Bytes(), xmlDoc)
	var newPage Page
	if nil != err {
		c.Errorf("%v", err)
		return newPage, err
	}
	newPage.GetDoc(xmlDoc)
	newPage.Date = time.Now()
	newPage.BlobKey = blobKey
	// if have the same doc
	key := datastore.NewKey(c, "Page", newPage.Title, 0, nil)
	err = datastore.RunInTransaction(c, func(c appengine.Context) error {
		var savedPage Page
		err := datastore.Get(c, key, &savedPage)
		if nil != err && datastore.ErrNoSuchEntity != err {
			c.Errorf("%v", err)
			return err
		}
		if datastore.ErrNoSuchEntity != err {
			err = blobstore.Delete(c, savedPage.BlobKey)
			if nil != err {
				c.Errorf("%v", err)
				return err
			}
		}
		_, err = datastore.Put(c, key, &newPage)
		if nil != err {
			c.Errorf("%v", err)
			return err
		}
		return nil
	}, nil)
	if nil != err {
		return newPage, err
	}
	return newPage, err
}

// - Reads a blobstore key, writes to a cloud storage bucket file.
// - Returns a []byte of a JPEG or a non-nil error
func CompressBlob(c appengine.Context, blobKey appengine.BlobKey, params *Params) ([]byte, error) {
	// Check that the blob is of supported mime-type
	if !allowedMimeTypes[strings.ToLower(params.MimeType)] {
		return nil, errors.New("Unsupported mime-type:" + params.MimeType)
	}

	// Instantiate blobstore reader
	reader := blobstore.NewReader(c, blobKey)

	// Instantiate the image object
	img, _, err := image.Decode(reader)
	if err != nil {
		return nil, err
	}
	// Resize if necessary an maintain aspect ratio
	if params.Size > 0 && (img.Bounds().Max.X > params.Size || img.Bounds().Max.Y > params.Size) {
		size_x := img.Bounds().Max.X
		size_y := img.Bounds().Max.Y
		if size_x > params.Size {
			size_x_before := size_x
			size_x = params.Size
			size_y = int(math.Floor(float64(size_y) * float64(float64(size_x)/float64(size_x_before))))
		}
		if size_y > params.Size {
			size_y_before := size_y
			size_y = params.Size
			size_x = int(math.Floor(float64(size_x) * float64(float64(size_y)/float64(size_y_before))))
		}
		img = Resize(img, img.Bounds(), size_x, size_y)
	}

	// Write JPEG to buffer
	b := new(bytes.Buffer)
	o := &jpeg.Options{Quality: params.Quality}
	if err := jpeg.Encode(b, img, o); err != nil {
		return nil, err
	}

	// Return image content
	return b.Bytes(), nil
}

func handlePages(w http.ResponseWriter, r *http.Request) {
	w.Header().Set("Content-Type", "text/html; charset=utf-8")
	if r.Method != "GET" || r.URL.Path != "/pages" {
		serve404(w)
		return
	}
	title := r.FormValue("Title")
	if r.Method != "GET" || r.URL.Path != "/pages" || "" == title {
		serve404(w)
		return
	}
	c := appengine.NewContext(r)
	key := datastore.NewKey(c, "Page", title, 0, nil)
	page := new(Page)
	err := datastore.Get(c, key, page)
	if nil != err && datastore.ErrNoSuchEntity != err {
		serveError(c, w, err)
		return
	}
	if datastore.ErrNoSuchEntity == err {
		serve404(w)
		return
	}

	reader := blobstore.NewReader(c, page.BlobKey)
	buf := new(bytes.Buffer)
	buf.ReadFrom(reader)

	err = pageTemplate.ExecuteTemplate(w, "Blob", buf)
	if err != nil {
		serveError(c, w, err)
		return
	}
	err = pageTemplate.ExecuteTemplate(w, "Page", page)
	if err != nil {
		serveError(c, w, err)
		return
	}
	return
}

func handleServe(w http.ResponseWriter, r *http.Request) {
	// Instantiate blobstore reader
	reader := blobstore.NewReader(appengine.NewContext(r),
		appengine.BlobKey(r.FormValue("blobKey")))

	lat, lng, _ := getLatLng(reader)

	blobstore.Delete(appengine.NewContext(r),
		appengine.BlobKey(r.FormValue("blobKey")))

	if lat == "" {
		io.WriteString(w, "Sorry but your photo has no GeoTag information...")
		return
	}

	s := "http://maps.googleapis.com/maps/api/staticmap?zoom=5&size=600x300&maptype=roadmap&center="
	s = s + lat + "," + lng + "&markers=color:blue%7Clabel:I%7C" + lat + "," + lng

	img := "<img src='" + s + "' alt='map' />"
	fmt.Fprint(w, img)

}

func serveThumbnail(w http.ResponseWriter, r *http.Request) {
	parts := strings.Split(r.URL.Path, "/")
	if len(parts) == 3 {
		if key := parts[2]; key != "" {
			var data []byte
			c := appengine.NewContext(r)
			item, err := memcache.Get(c, key)
			if err == nil {
				data = item.Value
			} else {
				blobKey := appengine.BlobKey(key)
				if _, err = blobstore.Stat(c, blobKey); err == nil {
					fi := FileInfo{Key: blobKey}
					data, _ = fi.CreateThumbnail(
						blobstore.NewReader(c, blobKey),
						c,
					)
				}
			}
			if err == nil && len(data) > 3 {
				w.Header().Add(
					"Cache-Control",
					fmt.Sprintf("public,max-age=%d", EXPIRATION_TIME),
				)
				contentType := "image/png"
				if string(data[:3]) == "GIF" {
					contentType = "image/gif"
				} else if string(data[1:4]) != "PNG" {
					contentType = "image/jpeg"
				}
				w.Header().Set("Content-Type", contentType)
				fmt.Fprintln(w, string(data))
				return
			}
		}
	}
	http.Error(w, "404 Not Found", http.StatusNotFound)
}