Golang blobstore.Create函数代码示例

func (photo *Photo) Upload(r *http.Request) (err error) {
	c := appengine.NewContext(r)

	blob, err := blobstore.Create(c, r.Header.Get("X-File-Type"))
	if err != nil {
		return
	}

	defer r.Body.Close()
	//body, err := ioutil.ReadAll(r.Body)
	var buf bytes.Buffer
	io.Copy(&buf, r.Body)
	_, err = blob.Write(buf.Bytes())
	if err != nil {
		return
	}

	_ = blob.Close()
	key, err := blob.Key()
	if err != nil {
		return
	}

	photo.Blob = string(key)

	err = photo.CreateThumb(r, buf)
	if err != nil {
		log.Println(err)
		err = blobstore.Delete(c, key)
		err = errors.New("Failed to upload image")
	}

	return
}

func PutInBlobstore(c appengine.Context, toStore interface{}) (appengine.BlobKey, error) {
	//TODO: check capabilities
	var k appengine.BlobKey
	var data bytes.Buffer
	enc := gob.NewEncoder(&data)
	err := enc.Encode(toStore)
	if err != nil {
		c.Errorf("Datastore - PutInBlobstore - error 1 - %s", err)
		return k, err
	}

	w, err := blobstore.Create(c, "application/octet-stream")
	if err != nil {
		c.Errorf("Datastore - PutInBlobstore - error 2 - %s", err)
		return k, err
	}
	_, err = w.Write(data.Bytes())
	if err != nil {
		c.Errorf("Datastore - PutInBlobstore - error 3 - %s", err)
		return k, err
	}
	err = w.Close()
	if err != nil {
		c.Errorf("Datastore - PutInBlobstore - error 4 - %s", err)
		return k, err
	}
	k, err = w.Key()
	if err != nil {
		c.Errorf("Datastore - PutInBlobstore - error 5 - %s", err)
	}
	return k, err
}

func saveBlob(context appengine.Context, mimeType string, saveFunc func(*blobstore.Writer) error) (appengine.BlobKey, error) {
	var blobWriter *blobstore.Writer

	if w, err := blobstore.Create(context, mimeType); err == nil {
		blobWriter = w
	} else {
		return "", err
	}

	if err := saveFunc(blobWriter); err != nil {
		return "", err
	}

	if err := blobWriter.Close(); err != nil {
		return "", err
	}

	if k, err := blobWriter.Key(); err == nil {
		return k, nil
	} else {
		return "", err
	}

	return "", nil
}

func (c Creature) Import(context appengine.Context) {
	if c.Exists(context) {
		return
	}

	// Fetch the source contents
	client := urlfetch.Client(context)
	resp, err := client.Get(c.Source)
	if err != nil {
		panic(err)
	}

	defer resp.Body.Close()

	data, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}

	// Store the Blob
	writer, _ := blobstore.Create(context, "image/jpeg")
	writer.Write(data)
	writer.Close()
	c.BlobKey, _ = writer.Key()

	c.Save(context)
}

func handleUpload(r *http.Request, p *multipart.Part) (fi *FileInfo) {
	fi = &FileInfo{
		Name: p.FileName(),
		Type: p.Header.Get("Content-Type"),
	}
	if !fi.ValidateType() {
		return
	}
	defer func() {
		if rec := recover(); rec != nil {
			log.Println(rec)
			fi.Error = rec.(error).Error()
		}
	}()
	lr := &io.LimitedReader{R: p, N: MAX_FILE_SIZE + 1}
	context := appengine.NewContext(r)
	w, err := blobstore.Create(context, fi.Type)
	defer func() {
		w.Close()
		fi.Size = MAX_FILE_SIZE + 1 - lr.N
		fi.Key, err = w.Key()
		check(err)
		if !fi.ValidateSize() {
			err := blobstore.Delete(context, fi.Key)
			check(err)
			return
		}
		delayedDelete(context, fi)
		fi.CreateUrls(r, context)
	}()
	check(err)
	_, err = io.Copy(w, lr)
	return
}

func uploadBlob(w http.ResponseWriter, r *http.Request) {
	bodyData, error := ioutil.ReadAll(r.Body)
	fileType := r.URL.Query()["type"][0]

	var mimeType string

	if fileType == "png" {
		mimeType = "image/png"
	} else {
		mimeType = "application/pdf"
	}

	context := appengine.NewContext(r)

	writer, error := blobstore.Create(context, mimeType)
	if error != nil {
		return
	}

	_, error = writer.Write(bodyData)
	if error != nil {
		return
	}

	error = writer.Close()
	if error != nil {
		return
	}

	var k appengine.BlobKey
	k, _ = writer.Key()

	encoder := json.NewEncoder(w)
	encoder.Encode(&UploadBlobResponse{Key: string(k)})
}

func loadImage(c appengine.Context, f *Feed) string {
	s := f.Link
	if s == "" {
		s = f.Url
	}
	u, err := url.Parse(s)
	if err != nil {
		return ""
	}
	u.Path = "/favicon.ico"
	u.RawQuery = ""
	u.Fragment = ""

	g := goon.FromContext(c)
	i := &Image{Id: u.String()}
	if err := g.Get(i); err == nil {
		return i.Url
	}
	client := urlfetch.Client(c)
	r, err := client.Get(u.String())
	if err != nil || r.StatusCode != http.StatusOK || r.ContentLength == 0 {
		return ""
	}
	b, err := ioutil.ReadAll(r.Body)
	r.Body.Close()
	if err != nil {
		return ""
	}
	buf := bytes.NewBuffer(b)
	_, t, err := image.DecodeConfig(buf)
	if err != nil {
		t = "application/octet-stream"
	} else {
		t = "image/" + t
	}
	w, err := blobstore.Create(c, t)
	if err != nil {
		return ""
	}
	if _, err := w.Write(b); err != nil {
		return ""
	}
	if w.Close() != nil {
		return ""
	}
	i.Blob, _ = w.Key()
	su, err := aimage.ServingURL(c, i.Blob, &aimage.ServingURLOptions{Size: 16})
	if err != nil {
		if err = blobstore.Delete(c, i.Blob); err != nil {
			c.Errorf("blob delete err: %v", err)
		}
		return ""
	}
	i.Url = su.String()
	g.Put(i)
	return i.Url
}

func UpdateServingLogoUrl(w http.ResponseWriter, r *http.Request) {
	c := appengine.NewContext(r)
	const batch = 50
	page, _ := strconv.Atoi(r.FormValue("pg"))
	if page < 1 {
		page = 1
	}
	offset := batch * (page - 1)
	q := datastore.NewQuery("EmpLogo").Offset(offset).Order("IdEmp").Limit(batch)
	n, _ := q.Count(c)
	for i := q.Run(c); ; {
		var e model.Image
		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 = 180
		imgprops.Crop = false
		if e.Sp4 == "" && e.IdEmp != "" {
			var blobkey appengine.BlobKey
			blob, err := blobstore.Create(c, "image/jpeg")
			if err != nil {
				c.Errorf("blobstore Create: %v", e.IdEmp)
			}
			_, err = blob.Write(e.Data)
			if err != nil {
				c.Errorf("blobstore Write: %v", e.IdEmp)
			}
			err = blob.Close()
			if err != nil {
				c.Errorf("blobstore Close: %v", e.IdEmp)
			}
			blobkey, err = blob.Key()
			if err != nil {
				c.Errorf("blobstore Key Gen: %v", e.IdEmp)
			}
			if url, err := image.ServingURL(c, blobkey, &imgprops); err != nil {
				c.Errorf("Cannot construct EmpLogo ServingURL : %v", e.IdEmp)
			} else {
				e.Sp3 = string(blobkey)
				e.Sp4 = url.String()
			}
			_, err = datastore.Put(c, key, &e)
			if err != nil {
				c.Errorf("PutEmpLogo(); Error al intentar actualizar Emplogo : %v", e.IdEmp)
			}
		}
	}
	c.Infof("UpdateServingLogoUrl() Pagina: %d, actualizados: %d, del %d al %d", page, n, offset, offset+n)
	return
}

func saveFile(c appengine.Context, b []byte) (appengine.BlobKey, error) {
	w, err := blobstore.Create(c, "application/json")
	if err != nil {
		return "", err
	}
	if _, err := w.Write(b); err != nil {
		return "", err
	}
	if err := w.Close(); err != nil {
		return "", err
	}
	return w.Key()
}

// createBlob stores a blob in the blobstore.
func createBlob(c appengine.Context, r io.Reader, contentType string) (appengine.BlobKey, error) {
	w, err := blobstore.Create(c, contentType)
	if err != nil {
		return "", err
	}
	if _, err := io.Copy(w, r); err != nil {
		return "", err
	}
	if err := w.Close(); err != nil {
		return "", err
	}
	return w.Key()
}

func (sto *appengineStorage) ReceiveBlob(br *blobref.BlobRef, in io.Reader) (sb blobref.SizedBlobRef, err os.Error) {
	if sto.ctx == nil {
		err = errNoContext
		return
	}

	var b bytes.Buffer
	hash := br.Hash()
	written, err := io.Copy(io.MultiWriter(hash, &b), in)
	if err != nil {
		return
	}

	if !br.HashMatches(hash) {
		err = blobserver.ErrCorruptBlob
		return
	}
	mimeType := "application/octet-stream"
	bw, err := blobstore.Create(sto.ctx, mimeType)
	if err != nil {
		return
	}
	written, err = io.Copy(bw, &b)
	if err != nil {
		// TODO(bradfitz): try to clean up; close it, see if we can find the key, delete it.
		return
	}
	err = bw.Close()
	if err != nil {
		// TODO(bradfitz): try to clean up; see if we can find the key, delete it.
		return
	}
	bkey, err := bw.Key()
	if err != nil {
		return
	}

	var ent blobEnt
	ent.BlobRefStr = br.String()
	ent.Size = written
	ent.BlobKey = bkey

	dkey := datastore.NewKey(sto.ctx, blobKind, br.String(), 0, nil)
	_, err = datastore.Put(sto.ctx, dkey, &ent)
	if err != nil {
		blobstore.Delete(sto.ctx, bkey) // TODO: insert into task queue on error to try later?
		return
	}

	return blobref.SizedBlobRef{br, written}, nil
}

func newBlob(c appengine.Context, p []byte) (appengine.BlobKey, error) {
	var k appengine.BlobKey
	w, err := blobstore.Create(c, "text/plain")
	if err != nil {
		return k, err
	}
	_, err = w.Write(p)
	if err != nil {
		return k, err
	}
	err = w.Close()
	if err != nil {
		return k, err
	}
	return w.Key()
}

func fetch(w http.ResponseWriter, r *http.Request) {

	c := appengine.NewContext(r)

	imageUrl := r.FormValue("image")
	c.Infof("THIS IS IMAGE URL %v", imageUrl)
	client := urlfetch.Client(c)
	resp, err := client.Get(imageUrl)
	if error3(err, c, w) {
		return
	}

	blob, err := blobstore.Create(c, resp.Header.Get("Content-Type"))
	if error3(err, c, w) {
		return
	}
	written, err := io.Copy(blob, resp.Body)
	if error3(err, c, w) {
		return
	}
	if written < 100 {
		c.Infof("image is too small %v", written)
		return
	}
	err = blob.Close()
	if error3(err, c, w) {
		return
	}

	blobkey, err := blob.Key()
	if error3(err, c, w) {
		return
	}

	thumbnailUrl, err := image.ServingURL(c, blobkey, &image.ServingURLOptions{Size: 100})
	if error3(err, c, w) {
		return
	}
	t := thumbnailUrl.String()
	errr := channel.Send(c, "qwerty", t)
	if error3(errr, c, w) {
		return
	}
	// c.Infof("THIS IS IMAGE URL %v", t)
}

func (m *Message) images2urls(c appengine.Context) {
	urlc := make(chan string)
	for _, im := range m.images {
		go func(img *img_attachment) {
			w, err := blobstore.Create(c, img.Type)
			if err != nil {
				urlc <- err.Error()
				return
			}
			_, err = w.Write(img.Data)
			if err != nil {
				urlc <- err.Error()
				return
			}
			err = w.Close()
			if err != nil {
				urlc <- err.Error()
				return
			}
			key, err := w.Key()
			if err != nil {
				urlc <- err.Error()
				return
			}
			url, err := image.ServingURL(c, key, &image.ServingURLOptions{Secure: false, Size: 0, Crop: false})
			if err != nil {
				urlc <- err.Error()
				return
			}
			urlc <- url.String()
		}(&im)
	}

	imagescnt := len(m.images)
	m.ImageUrls = make([]string, 0, imagescnt)
	for i := 0; i < imagescnt; i++ {
		u := <-urlc
		if strings.HasPrefix(u, "http") {
			m.ImageUrls = append(m.ImageUrls, u)
		} else {
			c.Errorf("Error converting image to url: %v", u)
		}
	}
	return
}

func handleUpload(r *http.Request, p *multipart.Part) (fi *FileInfo) {
	fi = &FileInfo{
		Name: p.FileName(),
		Type: p.Header.Get("Content-Type"),
	}
	if !fi.ValidateType() {
		return
	}
	defer func() {
		if rec := recover(); rec != nil {
			log.Println(rec)
			fi.Error = rec.(os.Error).String()
		}
	}()
	var b bytes.Buffer
	lr := &io.LimitedReader{p, MAX_FILE_SIZE + 1}
	context := appengine.NewContext(r)
	w, err := blobstore.Create(context, fi.Type)
	defer func() {
		w.Close()
		fi.Size = MAX_FILE_SIZE + 1 - lr.N
		fi.Key, err = w.Key()
		check(err)
		if !fi.ValidateSize() {
			err := blobstore.Delete(context, fi.Key)
			check(err)
			return
		}
		delayedDelete(context, fi)
		if b.Len() > 0 {
			fi.CreateThumbnail(&b, context)
		}
		fi.CreateUrls(r, context)
	}()
	check(err)
	var wr io.Writer = w
	if imageTypes.MatchString(fi.Type) {
		wr = io.MultiWriter(&b, w)
	}
	_, err = io.Copy(wr, lr)
	return
}