\tBundle app to named tar file or stdout\n", os.Args[0])
fmt.Fprintf(os.Stderr, "\noptional arguments:\n")
flag.PrintDefaults()
}
func main() {
flag.Usage = usage
flag.Parse()
var tags []string
if *vm {
tags = append(tags, "appenginevm")
} else {
tags = append(tags, "appengine")
}
tarFile := *output
if tarFile == "" {
usage()
errorf("Required -o flag not specified.")
}
app, err := analyze(tags)
if err != nil {
errorf("Error analyzing app: %v", err)
}
if err := app.bundle(tarFile); err != nil {
errorf("Unable to bundle app: %v", err)
}
}
// errorf prints the error message and exits.
func errorf(format string, a ...interface{}) {
fmt.Fprintf(os.Stderr, "aebundler: "+format+"\n", a...)
os.Exit(1)
}
type app struct {
hasMain bool
appFiles []string
imports map[string]string
}
// analyze checks the app for building with the given build tags and returns hasMain,
// app files, and a map of full directory import names to original import names.
func analyze(tags []string) (*app, error) {
ctxt := buildContext(tags)
hasMain, appFiles, err := checkMain(ctxt)
if err != nil {
return nil, err
}
gopath := filepath.SplitList(ctxt.GOPATH)
im, err := imports(ctxt, *rootDir, gopath)
return &app{
hasMain: hasMain,
appFiles: appFiles,
imports: im,
}, err
}
// buildContext returns the context for building the source.
func buildContext(tags []string) *build.Context {
return &build.Context{
GOARCH: build.Default.GOARCH,
GOOS: build.Default.GOOS,
GOROOT: build.Default.GOROOT,
GOPATH: build.Default.GOPATH,
Compiler: build.Default.Compiler,
BuildTags: append(build.Default.BuildTags, tags...),
}
}
// bundle bundles the app into the named tarFile ("-"==stdout).
func (s *app) bundle(tarFile string) (err error) {
var out io.Writer
if tarFile == "-" {
out = os.Stdout
} else {
f, err := os.Create(tarFile)
if err != nil {
return err
}
defer func() {
if cerr := f.Close(); err == nil {
err = cerr
}
}()
out = f
}
tw := tar.NewWriter(out)
for srcDir, importName := range s.imports {
dstDir := "_gopath/src/" + importName
if err = copyTree(tw, dstDir, srcDir); err != nil {
return fmt.Errorf("unable to copy directory %v to %v: %v", srcDir, dstDir, err)
}
}
if err := copyTree(tw, ".", *rootDir); err != nil {
return fmt.Errorf("unable to copy root directory to /app: %v", err)
}
if !s.hasMain {
if err := synthesizeMain(tw, s.appFiles); err != nil {
return fmt.Errorf("unable to synthesize new main func: %v", err)
}
}
if err := tw.Close(); err != nil {
return fmt.Errorf("unable to close tar file %v: %v", tarFile, err)
}
return nil
}
// synthesizeMain generates a new main func and writes it to the tarball.
func synthesizeMain(tw *tar.Writer, appFiles []string) error {
appMap := make(map[string]bool)
for _, f := range appFiles {
appMap[f] = true
}
var f string
for i := 0; i < 100; i++ {
f = fmt.Sprintf("app_main%d.go", i)
if !appMap[filepath.Join(*rootDir, f)] {
break
}
}
if appMap[filepath.Join(*rootDir, f)] {
return fmt.Errorf("unable to find unique name for %v", f)
}
hdr := &tar.Header{
Name: f,
Mode: 0644,
Size: int64(len(newMain)),
}
if err := tw.WriteHeader(hdr); err != nil {
return fmt.Errorf("unable to write header for %v: %v", f, err)
}
if _, err := tw.Write([]byte(newMain)); err != nil {
return fmt.Errorf("unable to write %v to tar file: %v", f, err)
}
return nil
}
// imports returns a map of all import directories (recursively) used by the app.
// The return value maps full directory names to original import names.
func imports(ctxt *build.Context, srcDir string, gopath []string) (map[string]string, error) {
pkg, err := ctxt.ImportDir(srcDir, 0)
if err != nil {
return nil, fmt.Errorf("unable to analyze source: %v", err)
}
// Resolve all non-standard-library imports
result := make(map[string]string)
for _, v := range pkg.Imports {
if !strings.Contains(v, ".") {
continue
}
src, err := findInGopath(v, gopath)
if err != nil {
return nil, fmt.Errorf("unable to find import %v in gopath %v: %v", v, gopath, err)
}
result[src] = v
im, err := imports(ctxt, src, gopath)
if err != nil {
return nil, fmt.Errorf("unable to parse package %v: %v", src, err)
}
for k, v := range im {
result[k] = v
}
}
return result, nil
}
// findInGopath searches the gopath for the named import directory.
func findInGopath(dir string, gopath []string) (string, error) {
for _, v := range gopath {
dst := filepath.Join(v, "src", dir)
if _, err := os.Stat(dst); err == nil {
return dst, nil
}
}
return "", fmt.Errorf("unable to find package %v in gopath %v", dir, gopath)
}
// copyTree copies srcDir to tar file dstDir, ignoring skipFiles.
func copyTree(tw *tar.Writer, dstDir, srcDir string) error {
entries, err := ioutil.ReadDir(srcDir)
if err != nil {
return fmt.Errorf("unable to read dir %v: %v", srcDir, err)
}
for _, entry := range entries {
n := entry.Name()
if skipFiles[n] {
continue
}
s := filepath.Join(srcDir, n)
d := filepath.Join(dstDir, n)
if entry.IsDir() {
if err := copyTree(tw, d, s); err != nil {
return fmt.Errorf("unable to copy dir %v to %v: %v", s, d, err)
}
continue
}
if err := copyFile(tw, d, s); err != nil {
return fmt.Errorf("unable to copy dir %v to %v: %v", s, d, err)
}
}
return nil
}
// copyFile copies src to tar file dst.
func copyFile(tw *tar.Writer, dst, src string) error {
s, err := os.Open(src)
if err != nil {
return fmt.Errorf("unable to open %v: %v", src, err)
}
defer s.Close()
fi, err := s.Stat()
if err != nil {
return fmt.Errorf("unable to stat %v: %v", src, err)
}
hdr, err := tar.FileInfoHeader(fi, dst)
if err != nil {
return fmt.Errorf("unable to create tar header for %v: %v", dst, err)
}
hdr.Name = dst
if err := tw.WriteHeader(hdr); err != nil {
return fmt.Errorf("unable to write header for %v: %v", dst, err)
}
_, err = io.Copy(tw, s)
if err != nil {
return fmt.Errorf("unable to copy %v to %v: %v", src, dst, err)
}
return nil
}
// checkMain verifies that there is a single "main" function.
// It also returns a list of all Go source files in the app.
func checkMain(ctxt *build.Context) (bool, []string, error) {
pkg, err := ctxt.ImportDir(*rootDir, 0)
if err != nil {
return false, nil, fmt.Errorf("unable to analyze source: %v", err)
}
if !pkg.IsCommand() {
errorf("Your app's package needs to be changed from %q to \"main\".\n", pkg.Name)
}
// Search for a "func main"
var hasMain bool
var appFiles []string
for _, f := range pkg.GoFiles {
n := filepath.Join(*rootDir, f)
appFiles = append(appFiles, n)
if hasMain, err = readFile(n); err != nil {
return false, nil, fmt.Errorf("error parsing %q: %v", n, err)
}
}
return hasMain, appFiles, nil
}
// isMain returns whether the given function declaration is a main function.
// Such a function must be called "main", not have a receiver, and have no arguments or return types.
func isMain(f *ast.FuncDecl) bool {
ft := f.Type
return f.Name.Name == "main" && f.Recv == nil && ft.Params.NumFields() == 0 && ft.Results.NumFields() == 0
}
// readFile reads and parses the Go source code file and returns whether it has a main function.
func readFile(filename string) (hasMain bool, err error) {
var src []byte
src, err = ioutil.ReadFile(filename)
if err != nil {
return
}
fset := token.NewFileSet()
file, err := parser.ParseFile(fset, filename, src, 0)
for _, decl := range file.Decls {
funcDecl, ok := decl.(*ast.FuncDecl)
if !ok {
continue
}
if !isMain(funcDecl) {
continue
}
hasMain = true
break
}
return
}
================================================
FILE: vendor/google.golang.org/appengine/cmd/aedeploy/aedeploy.go
================================================
// Copyright 2015 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
// Program aedeploy assists with deploying Go Managed VM apps to production.
// A temporary directory is created; the app, its subdirectories, and all its
// dependencies from $GOPATH are copied into the directory; then the app
// is deployed to production with the provided command.
//
// The app must be in "package main".
//
// This command must be issued from within the root directory of the app
// (where the app.yaml file is located).
package main
import (
"flag"
"fmt"
"go/build"
"io"
"io/ioutil"
"os"
"os/exec"
"path/filepath"
"strings"
)
var (
skipFiles = map[string]bool{
".git": true,
".gitconfig": true,
".hg": true,
".travis.yml": true,
}
gopathCache = map[string]string{}
)
func usage() {
fmt.Fprintf(os.Stderr, "Usage of %s:\n", os.Args[0])
fmt.Fprintf(os.Stderr, "\t%s gcloud --verbosity debug preview app deploy --version myversion ./app.yaml\tDeploy app to production\n", os.Args[0])
}
func main() {
flag.Usage = usage
flag.Parse()
if flag.NArg() < 1 {
usage()
os.Exit(1)
}
if err := aedeploy(); err != nil {
fmt.Fprintf(os.Stderr, os.Args[0]+": Error: %v\n", err)
os.Exit(1)
}
}
func aedeploy() error {
tags := []string{"appenginevm"}
app, err := analyze(tags)
if err != nil {
return err
}
tmpDir, err := app.bundle()
if tmpDir != "" {
defer os.RemoveAll(tmpDir)
}
if err != nil {
return err
}
if err := os.Chdir(tmpDir); err != nil {
return fmt.Errorf("unable to chdir to %v: %v", tmpDir, err)
}
return deploy()
}
// deploy calls the provided command to deploy the app from the temporary directory.
func deploy() error {
cmd := exec.Command(flag.Arg(0), flag.Args()[1:]...)
cmd.Stdin, cmd.Stdout, cmd.Stderr = os.Stdin, os.Stdout, os.Stderr
if err := cmd.Run(); err != nil {
return fmt.Errorf("unable to run %q: %v", strings.Join(flag.Args(), " "), err)
}
return nil
}
type app struct {
appFiles []string
imports map[string]string
}
// analyze checks the app for building with the given build tags and returns
// app files, and a map of full directory import names to original import names.
func analyze(tags []string) (*app, error) {
ctxt := buildContext(tags)
appFiles, err := appFiles(ctxt)
if err != nil {
return nil, err
}
gopath := filepath.SplitList(ctxt.GOPATH)
im, err := imports(ctxt, ".", gopath)
return &app{
appFiles: appFiles,
imports: im,
}, err
}
// buildContext returns the context for building the source.
func buildContext(tags []string) *build.Context {
return &build.Context{
GOARCH: "amd64",
GOOS: "linux",
GOROOT: build.Default.GOROOT,
GOPATH: build.Default.GOPATH,
Compiler: build.Default.Compiler,
BuildTags: append(build.Default.BuildTags, tags...),
}
}
// bundle bundles the app into a temporary directory.
func (s *app) bundle() (tmpdir string, err error) {
workDir, err := ioutil.TempDir("", "aedeploy")
if err != nil {
return "", fmt.Errorf("unable to create tmpdir: %v", err)
}
for srcDir, importName := range s.imports {
dstDir := "_gopath/src/" + importName
if err := copyTree(workDir, dstDir, srcDir); err != nil {
return workDir, fmt.Errorf("unable to copy directory %v to %v: %v", srcDir, dstDir, err)
}
}
if err := copyTree(workDir, ".", "."); err != nil {
return workDir, fmt.Errorf("unable to copy root directory to /app: %v", err)
}
return workDir, nil
}
// imports returns a map of all import directories (recursively) used by the app.
// The return value maps full directory names to original import names.
func imports(ctxt *build.Context, srcDir string, gopath []string) (map[string]string, error) {
pkg, err := ctxt.ImportDir(srcDir, 0)
if err != nil {
return nil, err
}
// Resolve all non-standard-library imports
result := make(map[string]string)
for _, v := range pkg.Imports {
if !strings.Contains(v, ".") {
continue
}
src, err := findInGopath(v, gopath)
if err != nil {
return nil, fmt.Errorf("unable to find import %v in gopath %v: %v", v, gopath, err)
}
if _, ok := result[src]; ok { // Already processed
continue
}
result[src] = v
im, err := imports(ctxt, src, gopath)
if err != nil {
return nil, fmt.Errorf("unable to parse package %v: %v", src, err)
}
for k, v := range im {
result[k] = v
}
}
return result, nil
}
// findInGopath searches the gopath for the named import directory.
func findInGopath(dir string, gopath []string) (string, error) {
if v, ok := gopathCache[dir]; ok {
return v, nil
}
for _, v := range gopath {
dst := filepath.Join(v, "src", dir)
if _, err := os.Stat(dst); err == nil {
gopathCache[dir] = dst
return dst, nil
}
}
return "", fmt.Errorf("unable to find package %v in gopath %v", dir, gopath)
}
// copyTree copies srcDir to dstDir relative to dstRoot, ignoring skipFiles.
func copyTree(dstRoot, dstDir, srcDir string) error {
d := filepath.Join(dstRoot, dstDir)
if err := os.MkdirAll(d, 0755); err != nil {
return fmt.Errorf("unable to create directory %q: %v", d, err)
}
entries, err := ioutil.ReadDir(srcDir)
if err != nil {
return fmt.Errorf("unable to read dir %q: %v", srcDir, err)
}
for _, entry := range entries {
n := entry.Name()
if skipFiles[n] {
continue
}
s := filepath.Join(srcDir, n)
if entry.Mode()&os.ModeSymlink == os.ModeSymlink {
if entry, err = os.Stat(s); err != nil {
return fmt.Errorf("unable to stat %v: %v", s, err)
}
}
d := filepath.Join(dstDir, n)
if entry.IsDir() {
if err := copyTree(dstRoot, d, s); err != nil {
return fmt.Errorf("unable to copy dir %q to %q: %v", s, d, err)
}
continue
}
if err := copyFile(dstRoot, d, s); err != nil {
return fmt.Errorf("unable to copy dir %q to %q: %v", s, d, err)
}
}
return nil
}
// copyFile copies src to dst relative to dstRoot.
func copyFile(dstRoot, dst, src string) error {
s, err := os.Open(src)
if err != nil {
return fmt.Errorf("unable to open %q: %v", src, err)
}
defer s.Close()
dst = filepath.Join(dstRoot, dst)
d, err := os.Create(dst)
if err != nil {
return fmt.Errorf("unable to create %q: %v", dst, err)
}
_, err = io.Copy(d, s)
if err != nil {
d.Close() // ignore error, copy already failed.
return fmt.Errorf("unable to copy %q to %q: %v", src, dst, err)
}
if err := d.Close(); err != nil {
return fmt.Errorf("unable to close %q: %v", dst, err)
}
return nil
}
// appFiles returns a list of all Go source files in the app.
func appFiles(ctxt *build.Context) ([]string, error) {
pkg, err := ctxt.ImportDir(".", 0)
if err != nil {
return nil, err
}
if !pkg.IsCommand() {
return nil, fmt.Errorf(`the root of your app needs to be package "main" (currently %q). Please see https://cloud.google.com/appengine/docs/go/managed-vms for more details on structuring your app.`, pkg.Name)
}
var appFiles []string
for _, f := range pkg.GoFiles {
n := filepath.Join(".", f)
appFiles = append(appFiles, n)
}
return appFiles, nil
}
================================================
FILE: vendor/google.golang.org/appengine/datastore/datastore.go
================================================
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
package datastore
import (
"errors"
"fmt"
"reflect"
"github.com/golang/protobuf/proto"
"golang.org/x/net/context"
"google.golang.org/appengine"
"google.golang.org/appengine/internal"
pb "google.golang.org/appengine/internal/datastore"
)
var (
// ErrInvalidEntityType is returned when functions like Get or Next are
// passed a dst or src argument of invalid type.
ErrInvalidEntityType = errors.New("datastore: invalid entity type")
// ErrInvalidKey is returned when an invalid key is presented.
ErrInvalidKey = errors.New("datastore: invalid key")
// ErrNoSuchEntity is returned when no entity was found for a given key.
ErrNoSuchEntity = errors.New("datastore: no such entity")
)
// ErrFieldMismatch is returned when a field is to be loaded into a different
// type than the one it was stored from, or when a field is missing or
// unexported in the destination struct.
// StructType is the type of the struct pointed to by the destination argument
// passed to Get or to Iterator.Next.
type ErrFieldMismatch struct {
StructType reflect.Type
FieldName string
Reason string
}
func (e *ErrFieldMismatch) Error() string {
return fmt.Sprintf("datastore: cannot load field %q into a %q: %s",
e.FieldName, e.StructType, e.Reason)
}
// protoToKey converts a Reference proto to a *Key.
func protoToKey(r *pb.Reference) (k *Key, err error) {
appID := r.GetApp()
namespace := r.GetNameSpace()
for _, e := range r.Path.Element {
k = &Key{
kind: e.GetType(),
stringID: e.GetName(),
intID: e.GetId(),
parent: k,
appID: appID,
namespace: namespace,
}
if !k.valid() {
return nil, ErrInvalidKey
}
}
return
}
// keyToProto converts a *Key to a Reference proto.
func keyToProto(defaultAppID string, k *Key) *pb.Reference {
appID := k.appID
if appID == "" {
appID = defaultAppID
}
n := 0
for i := k; i != nil; i = i.parent {
n++
}
e := make([]*pb.Path_Element, n)
for i := k; i != nil; i = i.parent {
n--
e[n] = &pb.Path_Element{
Type: &i.kind,
}
// At most one of {Name,Id} should be set.
// Neither will be set for incomplete keys.
if i.stringID != "" {
e[n].Name = &i.stringID
} else if i.intID != 0 {
e[n].Id = &i.intID
}
}
var namespace *string
if k.namespace != "" {
namespace = proto.String(k.namespace)
}
return &pb.Reference{
App: proto.String(appID),
NameSpace: namespace,
Path: &pb.Path{
Element: e,
},
}
}
// multiKeyToProto is a batch version of keyToProto.
func multiKeyToProto(appID string, key []*Key) []*pb.Reference {
ret := make([]*pb.Reference, len(key))
for i, k := range key {
ret[i] = keyToProto(appID, k)
}
return ret
}
// multiValid is a batch version of Key.valid. It returns an error, not a
// []bool.
func multiValid(key []*Key) error {
invalid := false
for _, k := range key {
if !k.valid() {
invalid = true
break
}
}
if !invalid {
return nil
}
err := make(appengine.MultiError, len(key))
for i, k := range key {
if !k.valid() {
err[i] = ErrInvalidKey
}
}
return err
}
// It's unfortunate that the two semantically equivalent concepts pb.Reference
// and pb.PropertyValue_ReferenceValue aren't the same type. For example, the
// two have different protobuf field numbers.
// referenceValueToKey is the same as protoToKey except the input is a
// PropertyValue_ReferenceValue instead of a Reference.
func referenceValueToKey(r *pb.PropertyValue_ReferenceValue) (k *Key, err error) {
appID := r.GetApp()
namespace := r.GetNameSpace()
for _, e := range r.Pathelement {
k = &Key{
kind: e.GetType(),
stringID: e.GetName(),
intID: e.GetId(),
parent: k,
appID: appID,
namespace: namespace,
}
if !k.valid() {
return nil, ErrInvalidKey
}
}
return
}
// keyToReferenceValue is the same as keyToProto except the output is a
// PropertyValue_ReferenceValue instead of a Reference.
func keyToReferenceValue(defaultAppID string, k *Key) *pb.PropertyValue_ReferenceValue {
ref := keyToProto(defaultAppID, k)
pe := make([]*pb.PropertyValue_ReferenceValue_PathElement, len(ref.Path.Element))
for i, e := range ref.Path.Element {
pe[i] = &pb.PropertyValue_ReferenceValue_PathElement{
Type: e.Type,
Id: e.Id,
Name: e.Name,
}
}
return &pb.PropertyValue_ReferenceValue{
App: ref.App,
NameSpace: ref.NameSpace,
Pathelement: pe,
}
}
type multiArgType int
const (
multiArgTypeInvalid multiArgType = iota
multiArgTypePropertyLoadSaver
multiArgTypeStruct
multiArgTypeStructPtr
multiArgTypeInterface
)
// checkMultiArg checks that v has type []S, []*S, []I, or []P, for some struct
// type S, for some interface type I, or some non-interface non-pointer type P
// such that P or *P implements PropertyLoadSaver.
//
// It returns what category the slice's elements are, and the reflect.Type
// that represents S, I or P.
//
// As a special case, PropertyList is an invalid type for v.
func checkMultiArg(v reflect.Value) (m multiArgType, elemType reflect.Type) {
if v.Kind() != reflect.Slice {
return multiArgTypeInvalid, nil
}
if v.Type() == typeOfPropertyList {
return multiArgTypeInvalid, nil
}
elemType = v.Type().Elem()
if reflect.PtrTo(elemType).Implements(typeOfPropertyLoadSaver) {
return multiArgTypePropertyLoadSaver, elemType
}
switch elemType.Kind() {
case reflect.Struct:
return multiArgTypeStruct, elemType
case reflect.Interface:
return multiArgTypeInterface, elemType
case reflect.Ptr:
elemType = elemType.Elem()
if elemType.Kind() == reflect.Struct {
return multiArgTypeStructPtr, elemType
}
}
return multiArgTypeInvalid, nil
}
// Get loads the entity stored for k into dst, which must be a struct pointer
// or implement PropertyLoadSaver. If there is no such entity for the key, Get
// returns ErrNoSuchEntity.
//
// The values of dst's unmatched struct fields are not modified, and matching
// slice-typed fields are not reset before appending to them. In particular, it
// is recommended to pass a pointer to a zero valued struct on each Get call.
//
// ErrFieldMismatch is returned when a field is to be loaded into a different
// type than the one it was stored from, or when a field is missing or
// unexported in the destination struct. ErrFieldMismatch is only returned if
// dst is a struct pointer.
func Get(c context.Context, key *Key, dst interface{}) error {
if dst == nil { // GetMulti catches nil interface; we need to catch nil ptr here
return ErrInvalidEntityType
}
err := GetMulti(c, []*Key{key}, []interface{}{dst})
if me, ok := err.(appengine.MultiError); ok {
return me[0]
}
return err
}
// GetMulti is a batch version of Get.
//
// dst must be a []S, []*S, []I or []P, for some struct type S, some interface
// type I, or some non-interface non-pointer type P such that P or *P
// implements PropertyLoadSaver. If an []I, each element must be a valid dst
// for Get: it must be a struct pointer or implement PropertyLoadSaver.
//
// As a special case, PropertyList is an invalid type for dst, even though a
// PropertyList is a slice of structs. It is treated as invalid to avoid being
// mistakenly passed when []PropertyList was intended.
func GetMulti(c context.Context, key []*Key, dst interface{}) error {
v := reflect.ValueOf(dst)
multiArgType, _ := checkMultiArg(v)
if multiArgType == multiArgTypeInvalid {
return errors.New("datastore: dst has invalid type")
}
if len(key) != v.Len() {
return errors.New("datastore: key and dst slices have different length")
}
if len(key) == 0 {
return nil
}
if err := multiValid(key); err != nil {
return err
}
req := &pb.GetRequest{
Key: multiKeyToProto(internal.FullyQualifiedAppID(c), key),
}
res := &pb.GetResponse{}
if err := internal.Call(c, "datastore_v3", "Get", req, res); err != nil {
return err
}
if len(key) != len(res.Entity) {
return errors.New("datastore: internal error: server returned the wrong number of entities")
}
multiErr, any := make(appengine.MultiError, len(key)), false
for i, e := range res.Entity {
if e.Entity == nil {
multiErr[i] = ErrNoSuchEntity
} else {
elem := v.Index(i)
if multiArgType == multiArgTypePropertyLoadSaver || multiArgType == multiArgTypeStruct {
elem = elem.Addr()
}
if multiArgType == multiArgTypeStructPtr && elem.IsNil() {
elem.Set(reflect.New(elem.Type().Elem()))
}
multiErr[i] = loadEntity(elem.Interface(), e.Entity)
}
if multiErr[i] != nil {
any = true
}
}
if any {
return multiErr
}
return nil
}
// Put saves the entity src into the datastore with key k. src must be a struct
// pointer or implement PropertyLoadSaver; if a struct pointer then any
// unexported fields of that struct will be skipped. If k is an incomplete key,
// the returned key will be a unique key generated by the datastore.
func Put(c context.Context, key *Key, src interface{}) (*Key, error) {
k, err := PutMulti(c, []*Key{key}, []interface{}{src})
if err != nil {
if me, ok := err.(appengine.MultiError); ok {
return nil, me[0]
}
return nil, err
}
return k[0], nil
}
// PutMulti is a batch version of Put.
//
// src must satisfy the same conditions as the dst argument to GetMulti.
func PutMulti(c context.Context, key []*Key, src interface{}) ([]*Key, error) {
v := reflect.ValueOf(src)
multiArgType, _ := checkMultiArg(v)
if multiArgType == multiArgTypeInvalid {
return nil, errors.New("datastore: src has invalid type")
}
if len(key) != v.Len() {
return nil, errors.New("datastore: key and src slices have different length")
}
if len(key) == 0 {
return nil, nil
}
appID := internal.FullyQualifiedAppID(c)
if err := multiValid(key); err != nil {
return nil, err
}
req := &pb.PutRequest{}
for i := range key {
elem := v.Index(i)
if multiArgType == multiArgTypePropertyLoadSaver || multiArgType == multiArgTypeStruct {
elem = elem.Addr()
}
sProto, err := saveEntity(appID, key[i], elem.Interface())
if err != nil {
return nil, err
}
req.Entity = append(req.Entity, sProto)
}
res := &pb.PutResponse{}
if err := internal.Call(c, "datastore_v3", "Put", req, res); err != nil {
return nil, err
}
if len(key) != len(res.Key) {
return nil, errors.New("datastore: internal error: server returned the wrong number of keys")
}
ret := make([]*Key, len(key))
for i := range ret {
var err error
ret[i], err = protoToKey(res.Key[i])
if err != nil || ret[i].Incomplete() {
return nil, errors.New("datastore: internal error: server returned an invalid key")
}
}
return ret, nil
}
// Delete deletes the entity for the given key.
func Delete(c context.Context, key *Key) error {
err := DeleteMulti(c, []*Key{key})
if me, ok := err.(appengine.MultiError); ok {
return me[0]
}
return err
}
// DeleteMulti is a batch version of Delete.
func DeleteMulti(c context.Context, key []*Key) error {
if len(key) == 0 {
return nil
}
if err := multiValid(key); err != nil {
return err
}
req := &pb.DeleteRequest{
Key: multiKeyToProto(internal.FullyQualifiedAppID(c), key),
}
res := &pb.DeleteResponse{}
return internal.Call(c, "datastore_v3", "Delete", req, res)
}
func namespaceMod(m proto.Message, namespace string) {
// pb.Query is the only type that has a name_space field.
// All other namespace support in datastore is in the keys.
switch m := m.(type) {
case *pb.Query:
if m.NameSpace == nil {
m.NameSpace = &namespace
}
}
}
func init() {
internal.NamespaceMods["datastore_v3"] = namespaceMod
internal.RegisterErrorCodeMap("datastore_v3", pb.Error_ErrorCode_name)
internal.RegisterTimeoutErrorCode("datastore_v3", int32(pb.Error_TIMEOUT))
}
================================================
FILE: vendor/google.golang.org/appengine/datastore/doc.go
================================================
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
/*
Package datastore provides a client for App Engine's datastore service.
Basic Operations
Entities are the unit of storage and are associated with a key. A key
consists of an optional parent key, a string application ID, a string kind
(also known as an entity type), and either a StringID or an IntID. A
StringID is also known as an entity name or key name.
It is valid to create a key with a zero StringID and a zero IntID; this is
called an incomplete key, and does not refer to any saved entity. Putting an
entity into the datastore under an incomplete key will cause a unique key
to be generated for that entity, with a non-zero IntID.
An entity's contents are a mapping from case-sensitive field names to values.
Valid value types are:
- signed integers (int, int8, int16, int32 and int64),
- bool,
- string,
- float32 and float64,
- []byte (up to 1 megabyte in length),
- any type whose underlying type is one of the above predeclared types,
- ByteString,
- *Key,
- time.Time (stored with microsecond precision),
- appengine.BlobKey,
- appengine.GeoPoint,
- structs whose fields are all valid value types,
- slices of any of the above.
Slices of structs are valid, as are structs that contain slices. However, if
one struct contains another, then at most one of those can be repeated. This
disqualifies recursively defined struct types: any struct T that (directly or
indirectly) contains a []T.
The Get and Put functions load and save an entity's contents. An entity's
contents are typically represented by a struct pointer.
Example code:
type Entity struct {
Value string
}
func handle(w http.ResponseWriter, r *http.Request) {
ctx := appengine.NewContext(r)
k := datastore.NewKey(ctx, "Entity", "stringID", 0, nil)
e := new(Entity)
if err := datastore.Get(ctx, k, e); err != nil {
http.Error(w, err.Error(), 500)
return
}
old := e.Value
e.Value = r.URL.Path
if _, err := datastore.Put(ctx, k, e); err != nil {
http.Error(w, err.Error(), 500)
return
}
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
fmt.Fprintf(w, "old=%q\nnew=%q\n", old, e.Value)
}
GetMulti, PutMulti and DeleteMulti are batch versions of the Get, Put and
Delete functions. They take a []*Key instead of a *Key, and may return an
appengine.MultiError when encountering partial failure.
Properties
An entity's contents can be represented by a variety of types. These are
typically struct pointers, but can also be any type that implements the
PropertyLoadSaver interface. If using a struct pointer, you do not have to
explicitly implement the PropertyLoadSaver interface; the datastore will
automatically convert via reflection. If a struct pointer does implement that
interface then those methods will be used in preference to the default
behavior for struct pointers. Struct pointers are more strongly typed and are
easier to use; PropertyLoadSavers are more flexible.
The actual types passed do not have to match between Get and Put calls or even
across different App Engine requests. It is valid to put a *PropertyList and
get that same entity as a *myStruct, or put a *myStruct0 and get a *myStruct1.
Conceptually, any entity is saved as a sequence of properties, and is loaded
into the destination value on a property-by-property basis. When loading into
a struct pointer, an entity that cannot be completely represented (such as a
missing field) will result in an ErrFieldMismatch error but it is up to the
caller whether this error is fatal, recoverable or ignorable.
By default, for struct pointers, all properties are potentially indexed, and
the property name is the same as the field name (and hence must start with an
upper case letter). Fields may have a `datastore:"name,options"` tag. The tag
name is the property name, which must be one or more valid Go identifiers
joined by ".", but may start with a lower case letter. An empty tag name means
to just use the field name. A "-" tag name means that the datastore will
ignore that field. If options is "noindex" then the field will not be indexed.
If the options is "" then the comma may be omitted. There are no other
recognized options.
Fields (except for []byte) are indexed by default. Strings longer than 1500
bytes cannot be indexed; fields used to store long strings should be
tagged with "noindex". Similarly, ByteStrings longer than 1500 bytes cannot be
indexed.
Example code:
// A and B are renamed to a and b.
// A, C and J are not indexed.
// D's tag is equivalent to having no tag at all (E).
// I is ignored entirely by the datastore.
// J has tag information for both the datastore and json packages.
type TaggedStruct struct {
A int `datastore:"a,noindex"`
B int `datastore:"b"`
C int `datastore:",noindex"`
D int `datastore:""`
E int
I int `datastore:"-"`
J int `datastore:",noindex" json:"j"`
}
Structured Properties
If the struct pointed to contains other structs, then the nested or embedded
structs are flattened. For example, given these definitions:
type Inner1 struct {
W int32
X string
}
type Inner2 struct {
Y float64
}
type Inner3 struct {
Z bool
}
type Outer struct {
A int16
I []Inner1
J Inner2
Inner3
}
then an Outer's properties would be equivalent to those of:
type OuterEquivalent struct {
A int16
IDotW []int32 `datastore:"I.W"`
IDotX []string `datastore:"I.X"`
JDotY float64 `datastore:"J.Y"`
Z bool
}
If Outer's embedded Inner3 field was tagged as `datastore:"Foo"` then the
equivalent field would instead be: FooDotZ bool `datastore:"Foo.Z"`.
If an outer struct is tagged "noindex" then all of its implicit flattened
fields are effectively "noindex".
The PropertyLoadSaver Interface
An entity's contents can also be represented by any type that implements the
PropertyLoadSaver interface. This type may be a struct pointer, but it does
not have to be. The datastore package will call Load when getting the entity's
contents, and Save when putting the entity's contents.
Possible uses include deriving non-stored fields, verifying fields, or indexing
a field only if its value is positive.
Example code:
type CustomPropsExample struct {
I, J int
// Sum is not stored, but should always be equal to I + J.
Sum int `datastore:"-"`
}
func (x *CustomPropsExample) Load(ps []datastore.Property) error {
// Load I and J as usual.
if err := datastore.LoadStruct(x, ps); err != nil {
return err
}
// Derive the Sum field.
x.Sum = x.I + x.J
return nil
}
func (x *CustomPropsExample) Save() ([]datastore.Property, error) {
// Validate the Sum field.
if x.Sum != x.I + x.J {
return errors.New("CustomPropsExample has inconsistent sum")
}
// Save I and J as usual. The code below is equivalent to calling
// "return datastore.SaveStruct(x)", but is done manually for
// demonstration purposes.
return []datastore.Property{
{
Name: "I",
Value: int64(x.I),
},
{
Name: "J",
Value: int64(x.J),
},
}
}
The *PropertyList type implements PropertyLoadSaver, and can therefore hold an
arbitrary entity's contents.
Queries
Queries retrieve entities based on their properties or key's ancestry. Running
a query yields an iterator of results: either keys or (key, entity) pairs.
Queries are re-usable and it is safe to call Query.Run from concurrent
goroutines. Iterators are not safe for concurrent use.
Queries are immutable, and are either created by calling NewQuery, or derived
from an existing query by calling a method like Filter or Order that returns a
new query value. A query is typically constructed by calling NewQuery followed
by a chain of zero or more such methods. These methods are:
- Ancestor and Filter constrain the entities returned by running a query.
- Order affects the order in which they are returned.
- Project constrains the fields returned.
- Distinct de-duplicates projected entities.
- KeysOnly makes the iterator return only keys, not (key, entity) pairs.
- Start, End, Offset and Limit define which sub-sequence of matching entities
to return. Start and End take cursors, Offset and Limit take integers. Start
and Offset affect the first result, End and Limit affect the last result.
If both Start and Offset are set, then the offset is relative to Start.
If both End and Limit are set, then the earliest constraint wins. Limit is
relative to Start+Offset, not relative to End. As a special case, a
negative limit means unlimited.
Example code:
type Widget struct {
Description string
Price int
}
func handle(w http.ResponseWriter, r *http.Request) {
ctx := appengine.NewContext(r)
q := datastore.NewQuery("Widget").
Filter("Price <", 1000).
Order("-Price")
b := new(bytes.Buffer)
for t := q.Run(ctx); ; {
var x Widget
key, err := t.Next(&x)
if err == datastore.Done {
break
}
if err != nil {
serveError(ctx, w, err)
return
}
fmt.Fprintf(b, "Key=%v\nWidget=%#v\n\n", key, x)
}
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
io.Copy(w, b)
}
Transactions
RunInTransaction runs a function in a transaction.
Example code:
type Counter struct {
Count int
}
func inc(ctx context.Context, key *datastore.Key) (int, error) {
var x Counter
if err := datastore.Get(ctx, key, &x); err != nil && err != datastore.ErrNoSuchEntity {
return 0, err
}
x.Count++
if _, err := datastore.Put(ctx, key, &x); err != nil {
return 0, err
}
return x.Count, nil
}
func handle(w http.ResponseWriter, r *http.Request) {
ctx := appengine.NewContext(r)
var count int
err := datastore.RunInTransaction(ctx, func(ctx context.Context) error {
var err1 error
count, err1 = inc(ctx, datastore.NewKey(ctx, "Counter", "singleton", 0, nil))
return err1
}, nil)
if err != nil {
serveError(ctx, w, err)
return
}
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
fmt.Fprintf(w, "Count=%d", count)
}
Metadata
The datastore package provides access to some of App Engine's datastore
metadata. This metadata includes information about the entity groups,
namespaces, entity kinds, and properties in the datastore, as well as the
property representations for each property.
Example code:
func handle(w http.ResponseWriter, r *http.Request) {
// Print all the kinds in the datastore, with all the indexed
// properties (and their representations) for each.
ctx := appengine.NewContext(r)
kinds, err := datastore.Kinds(ctx)
if err != nil {
serveError(ctx, w, err)
return
}
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
for _, kind := range kinds {
fmt.Fprintf(w, "%s:\n", kind)
props, err := datastore.KindProperties(ctx, kind)
if err != nil {
fmt.Fprintln(w, "\t(unable to retrieve properties)")
continue
}
for p, rep := range props {
fmt.Fprintf(w, "\t-%s (%s)\n", p, strings.Join(", ", rep))
}
}
}
*/
package datastore
================================================
FILE: vendor/google.golang.org/appengine/datastore/key.go
================================================
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
package datastore
import (
"bytes"
"encoding/base64"
"encoding/gob"
"errors"
"fmt"
"strconv"
"strings"
"github.com/golang/protobuf/proto"
"golang.org/x/net/context"
"google.golang.org/appengine/internal"
pb "google.golang.org/appengine/internal/datastore"
)
// Key represents the datastore key for a stored entity, and is immutable.
type Key struct {
kind string
stringID string
intID int64
parent *Key
appID string
namespace string
}
// Kind returns the key's kind (also known as entity type).
func (k *Key) Kind() string {
return k.kind
}
// StringID returns the key's string ID (also known as an entity name or key
// name), which may be "".
func (k *Key) StringID() string {
return k.stringID
}
// IntID returns the key's integer ID, which may be 0.
func (k *Key) IntID() int64 {
return k.intID
}
// Parent returns the key's parent key, which may be nil.
func (k *Key) Parent() *Key {
return k.parent
}
// AppID returns the key's application ID.
func (k *Key) AppID() string {
return k.appID
}
// Namespace returns the key's namespace.
func (k *Key) Namespace() string {
return k.namespace
}
// Incomplete returns whether the key does not refer to a stored entity.
// In particular, whether the key has a zero StringID and a zero IntID.
func (k *Key) Incomplete() bool {
return k.stringID == "" && k.intID == 0
}
// valid returns whether the key is valid.
func (k *Key) valid() bool {
if k == nil {
return false
}
for ; k != nil; k = k.parent {
if k.kind == "" || k.appID == "" {
return false
}
if k.stringID != "" && k.intID != 0 {
return false
}
if k.parent != nil {
if k.parent.Incomplete() {
return false
}
if k.parent.appID != k.appID || k.parent.namespace != k.namespace {
return false
}
}
}
return true
}
// Equal returns whether two keys are equal.
func (k *Key) Equal(o *Key) bool {
for k != nil && o != nil {
if k.kind != o.kind || k.stringID != o.stringID || k.intID != o.intID || k.appID != o.appID || k.namespace != o.namespace {
return false
}
k, o = k.parent, o.parent
}
return k == o
}
// root returns the furthest ancestor of a key, which may be itself.
func (k *Key) root() *Key {
for k.parent != nil {
k = k.parent
}
return k
}
// marshal marshals the key's string representation to the buffer.
func (k *Key) marshal(b *bytes.Buffer) {
if k.parent != nil {
k.parent.marshal(b)
}
b.WriteByte('/')
b.WriteString(k.kind)
b.WriteByte(',')
if k.stringID != "" {
b.WriteString(k.stringID)
} else {
b.WriteString(strconv.FormatInt(k.intID, 10))
}
}
// String returns a string representation of the key.
func (k *Key) String() string {
if k == nil {
return ""
}
b := bytes.NewBuffer(make([]byte, 0, 512))
k.marshal(b)
return b.String()
}
type gobKey struct {
Kind string
StringID string
IntID int64
Parent *gobKey
AppID string
Namespace string
}
func keyToGobKey(k *Key) *gobKey {
if k == nil {
return nil
}
return &gobKey{
Kind: k.kind,
StringID: k.stringID,
IntID: k.intID,
Parent: keyToGobKey(k.parent),
AppID: k.appID,
Namespace: k.namespace,
}
}
func gobKeyToKey(gk *gobKey) *Key {
if gk == nil {
return nil
}
return &Key{
kind: gk.Kind,
stringID: gk.StringID,
intID: gk.IntID,
parent: gobKeyToKey(gk.Parent),
appID: gk.AppID,
namespace: gk.Namespace,
}
}
func (k *Key) GobEncode() ([]byte, error) {
buf := new(bytes.Buffer)
if err := gob.NewEncoder(buf).Encode(keyToGobKey(k)); err != nil {
return nil, err
}
return buf.Bytes(), nil
}
func (k *Key) GobDecode(buf []byte) error {
gk := new(gobKey)
if err := gob.NewDecoder(bytes.NewBuffer(buf)).Decode(gk); err != nil {
return err
}
*k = *gobKeyToKey(gk)
return nil
}
func (k *Key) MarshalJSON() ([]byte, error) {
return []byte(`"` + k.Encode() + `"`), nil
}
func (k *Key) UnmarshalJSON(buf []byte) error {
if len(buf) < 2 || buf[0] != '"' || buf[len(buf)-1] != '"' {
return errors.New("datastore: bad JSON key")
}
k2, err := DecodeKey(string(buf[1 : len(buf)-1]))
if err != nil {
return err
}
*k = *k2
return nil
}
// Encode returns an opaque representation of the key
// suitable for use in HTML and URLs.
// This is compatible with the Python and Java runtimes.
func (k *Key) Encode() string {
ref := keyToProto("", k)
b, err := proto.Marshal(ref)
if err != nil {
panic(err)
}
// Trailing padding is stripped.
return strings.TrimRight(base64.URLEncoding.EncodeToString(b), "=")
}
// DecodeKey decodes a key from the opaque representation returned by Encode.
func DecodeKey(encoded string) (*Key, error) {
// Re-add padding.
if m := len(encoded) % 4; m != 0 {
encoded += strings.Repeat("=", 4-m)
}
b, err := base64.URLEncoding.DecodeString(encoded)
if err != nil {
return nil, err
}
ref := new(pb.Reference)
if err := proto.Unmarshal(b, ref); err != nil {
return nil, err
}
return protoToKey(ref)
}
// NewIncompleteKey creates a new incomplete key.
// kind cannot be empty.
func NewIncompleteKey(c context.Context, kind string, parent *Key) *Key {
return NewKey(c, kind, "", 0, parent)
}
// NewKey creates a new key.
// kind cannot be empty.
// Either one or both of stringID and intID must be zero. If both are zero,
// the key returned is incomplete.
// parent must either be a complete key or nil.
func NewKey(c context.Context, kind, stringID string, intID int64, parent *Key) *Key {
// If there's a parent key, use its namespace.
// Otherwise, use any namespace attached to the context.
var namespace string
if parent != nil {
namespace = parent.namespace
} else {
namespace = internal.NamespaceFromContext(c)
}
return &Key{
kind: kind,
stringID: stringID,
intID: intID,
parent: parent,
appID: internal.FullyQualifiedAppID(c),
namespace: namespace,
}
}
// AllocateIDs returns a range of n integer IDs with the given kind and parent
// combination. kind cannot be empty; parent may be nil. The IDs in the range
// returned will not be used by the datastore's automatic ID sequence generator
// and may be used with NewKey without conflict.
//
// The range is inclusive at the low end and exclusive at the high end. In
// other words, valid intIDs x satisfy low <= x && x < high.
//
// If no error is returned, low + n == high.
func AllocateIDs(c context.Context, kind string, parent *Key, n int) (low, high int64, err error) {
if kind == "" {
return 0, 0, errors.New("datastore: AllocateIDs given an empty kind")
}
if n < 0 {
return 0, 0, fmt.Errorf("datastore: AllocateIDs given a negative count: %d", n)
}
if n == 0 {
return 0, 0, nil
}
req := &pb.AllocateIdsRequest{
ModelKey: keyToProto("", NewIncompleteKey(c, kind, parent)),
Size: proto.Int64(int64(n)),
}
res := &pb.AllocateIdsResponse{}
if err := internal.Call(c, "datastore_v3", "AllocateIds", req, res); err != nil {
return 0, 0, err
}
// The protobuf is inclusive at both ends. Idiomatic Go (e.g. slices, for loops)
// is inclusive at the low end and exclusive at the high end, so we add 1.
low = res.GetStart()
high = res.GetEnd() + 1
if low+int64(n) != high {
return 0, 0, fmt.Errorf("datastore: internal error: could not allocate %d IDs", n)
}
return low, high, nil
}
================================================
FILE: vendor/google.golang.org/appengine/datastore/load.go
================================================
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
package datastore
import (
"fmt"
"reflect"
"time"
"google.golang.org/appengine"
pb "google.golang.org/appengine/internal/datastore"
)
var (
typeOfBlobKey = reflect.TypeOf(appengine.BlobKey(""))
typeOfByteSlice = reflect.TypeOf([]byte(nil))
typeOfByteString = reflect.TypeOf(ByteString(nil))
typeOfGeoPoint = reflect.TypeOf(appengine.GeoPoint{})
typeOfTime = reflect.TypeOf(time.Time{})
)
// typeMismatchReason returns a string explaining why the property p could not
// be stored in an entity field of type v.Type().
func typeMismatchReason(p Property, v reflect.Value) string {
entityType := "empty"
switch p.Value.(type) {
case int64:
entityType = "int"
case bool:
entityType = "bool"
case string:
entityType = "string"
case float64:
entityType = "float"
case *Key:
entityType = "*datastore.Key"
case time.Time:
entityType = "time.Time"
case appengine.BlobKey:
entityType = "appengine.BlobKey"
case appengine.GeoPoint:
entityType = "appengine.GeoPoint"
case ByteString:
entityType = "datastore.ByteString"
case []byte:
entityType = "[]byte"
}
return fmt.Sprintf("type mismatch: %s versus %v", entityType, v.Type())
}
type propertyLoader struct {
// m holds the number of times a substruct field like "Foo.Bar.Baz" has
// been seen so far. The map is constructed lazily.
m map[string]int
}
func (l *propertyLoader) load(codec *structCodec, structValue reflect.Value, p Property, requireSlice bool) string {
var v reflect.Value
// Traverse a struct's struct-typed fields.
for name := p.Name; ; {
decoder, ok := codec.byName[name]
if !ok {
return "no such struct field"
}
v = structValue.Field(decoder.index)
if !v.IsValid() {
return "no such struct field"
}
if !v.CanSet() {
return "cannot set struct field"
}
if decoder.substructCodec == nil {
break
}
if v.Kind() == reflect.Slice {
if l.m == nil {
l.m = make(map[string]int)
}
index := l.m[p.Name]
l.m[p.Name] = index + 1
for v.Len() <= index {
v.Set(reflect.Append(v, reflect.New(v.Type().Elem()).Elem()))
}
structValue = v.Index(index)
requireSlice = false
} else {
structValue = v
}
// Strip the "I." from "I.X".
name = name[len(codec.byIndex[decoder.index].name):]
codec = decoder.substructCodec
}
var slice reflect.Value
if v.Kind() == reflect.Slice && v.Type().Elem().Kind() != reflect.Uint8 {
slice = v
v = reflect.New(v.Type().Elem()).Elem()
} else if requireSlice {
return "multiple-valued property requires a slice field type"
}
// Convert indexValues to a Go value with a meaning derived from the
// destination type.
pValue := p.Value
if iv, ok := pValue.(indexValue); ok {
meaning := pb.Property_NO_MEANING
switch v.Type() {
case typeOfBlobKey:
meaning = pb.Property_BLOBKEY
case typeOfByteSlice:
meaning = pb.Property_BLOB
case typeOfByteString:
meaning = pb.Property_BYTESTRING
case typeOfGeoPoint:
meaning = pb.Property_GEORSS_POINT
case typeOfTime:
meaning = pb.Property_GD_WHEN
}
var err error
pValue, err = propValue(iv.value, meaning)
if err != nil {
return err.Error()
}
}
switch v.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
x, ok := pValue.(int64)
if !ok && pValue != nil {
return typeMismatchReason(p, v)
}
if v.OverflowInt(x) {
return fmt.Sprintf("value %v overflows struct field of type %v", x, v.Type())
}
v.SetInt(x)
case reflect.Bool:
x, ok := pValue.(bool)
if !ok && pValue != nil {
return typeMismatchReason(p, v)
}
v.SetBool(x)
case reflect.String:
switch x := pValue.(type) {
case appengine.BlobKey:
v.SetString(string(x))
case ByteString:
v.SetString(string(x))
case string:
v.SetString(x)
default:
if pValue != nil {
return typeMismatchReason(p, v)
}
}
case reflect.Float32, reflect.Float64:
x, ok := pValue.(float64)
if !ok && pValue != nil {
return typeMismatchReason(p, v)
}
if v.OverflowFloat(x) {
return fmt.Sprintf("value %v overflows struct field of type %v", x, v.Type())
}
v.SetFloat(x)
case reflect.Ptr:
x, ok := pValue.(*Key)
if !ok && pValue != nil {
return typeMismatchReason(p, v)
}
if _, ok := v.Interface().(*Key); !ok {
return typeMismatchReason(p, v)
}
v.Set(reflect.ValueOf(x))
case reflect.Struct:
switch v.Type() {
case typeOfTime:
x, ok := pValue.(time.Time)
if !ok && pValue != nil {
return typeMismatchReason(p, v)
}
v.Set(reflect.ValueOf(x))
case typeOfGeoPoint:
x, ok := pValue.(appengine.GeoPoint)
if !ok && pValue != nil {
return typeMismatchReason(p, v)
}
v.Set(reflect.ValueOf(x))
default:
return typeMismatchReason(p, v)
}
case reflect.Slice:
x, ok := pValue.([]byte)
if !ok {
if y, yok := pValue.(ByteString); yok {
x, ok = []byte(y), true
}
}
if !ok && pValue != nil {
return typeMismatchReason(p, v)
}
if v.Type().Elem().Kind() != reflect.Uint8 {
return typeMismatchReason(p, v)
}
v.SetBytes(x)
default:
return typeMismatchReason(p, v)
}
if slice.IsValid() {
slice.Set(reflect.Append(slice, v))
}
return ""
}
// loadEntity loads an EntityProto into PropertyLoadSaver or struct pointer.
func loadEntity(dst interface{}, src *pb.EntityProto) (err error) {
props, err := protoToProperties(src)
if err != nil {
return err
}
if e, ok := dst.(PropertyLoadSaver); ok {
return e.Load(props)
}
return LoadStruct(dst, props)
}
func (s structPLS) Load(props []Property) error {
var fieldName, reason string
var l propertyLoader
for _, p := range props {
if errStr := l.load(s.codec, s.v, p, p.Multiple); errStr != "" {
// We don't return early, as we try to load as many properties as possible.
// It is valid to load an entity into a struct that cannot fully represent it.
// That case returns an error, but the caller is free to ignore it.
fieldName, reason = p.Name, errStr
}
}
if reason != "" {
return &ErrFieldMismatch{
StructType: s.v.Type(),
FieldName: fieldName,
Reason: reason,
}
}
return nil
}
func protoToProperties(src *pb.EntityProto) ([]Property, error) {
props, rawProps := src.Property, src.RawProperty
out := make([]Property, 0, len(props)+len(rawProps))
for {
var (
x *pb.Property
noIndex bool
)
if len(props) > 0 {
x, props = props[0], props[1:]
} else if len(rawProps) > 0 {
x, rawProps = rawProps[0], rawProps[1:]
noIndex = true
} else {
break
}
var value interface{}
if x.Meaning != nil && *x.Meaning == pb.Property_INDEX_VALUE {
value = indexValue{x.Value}
} else {
var err error
value, err = propValue(x.Value, x.GetMeaning())
if err != nil {
return nil, err
}
}
out = append(out, Property{
Name: x.GetName(),
Value: value,
NoIndex: noIndex,
Multiple: x.GetMultiple(),
})
}
return out, nil
}
// propValue returns a Go value that combines the raw PropertyValue with a
// meaning. For example, an Int64Value with GD_WHEN becomes a time.Time.
func propValue(v *pb.PropertyValue, m pb.Property_Meaning) (interface{}, error) {
switch {
case v.Int64Value != nil:
if m == pb.Property_GD_WHEN {
return fromUnixMicro(*v.Int64Value), nil
} else {
return *v.Int64Value, nil
}
case v.BooleanValue != nil:
return *v.BooleanValue, nil
case v.StringValue != nil:
if m == pb.Property_BLOB {
return []byte(*v.StringValue), nil
} else if m == pb.Property_BLOBKEY {
return appengine.BlobKey(*v.StringValue), nil
} else if m == pb.Property_BYTESTRING {
return ByteString(*v.StringValue), nil
} else {
return *v.StringValue, nil
}
case v.DoubleValue != nil:
return *v.DoubleValue, nil
case v.Referencevalue != nil:
key, err := referenceValueToKey(v.Referencevalue)
if err != nil {
return nil, err
}
return key, nil
case v.Pointvalue != nil:
// NOTE: Strangely, latitude maps to X, longitude to Y.
return appengine.GeoPoint{Lat: v.Pointvalue.GetX(), Lng: v.Pointvalue.GetY()}, nil
}
return nil, nil
}
// indexValue is a Property value that is created when entities are loaded from
// an index, such as from a projection query.
//
// Such Property values do not contain all of the metadata required to be
// faithfully represented as a Go value, and are instead represented as an
// opaque indexValue. Load the properties into a concrete struct type (e.g. by
// passing a struct pointer to Iterator.Next) to reconstruct actual Go values
// of type int, string, time.Time, etc.
type indexValue struct {
value *pb.PropertyValue
}
================================================
FILE: vendor/google.golang.org/appengine/datastore/metadata.go
================================================
// Copyright 2016 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
package datastore
import "golang.org/x/net/context"
// Datastore kinds for the metadata entities.
const (
namespaceKind = "__namespace__"
kindKind = "__kind__"
propertyKind = "__property__"
entityGroupKind = "__entitygroup__"
)
// Namespaces returns all the datastore namespaces.
func Namespaces(ctx context.Context) ([]string, error) {
// TODO(djd): Support range queries.
q := NewQuery(namespaceKind).KeysOnly()
keys, err := q.GetAll(ctx, nil)
if err != nil {
return nil, err
}
// The empty namespace key uses a numeric ID (==1), but luckily
// the string ID defaults to "" for numeric IDs anyway.
return keyNames(keys), nil
}
// Kinds returns the names of all the kinds in the current namespace.
func Kinds(ctx context.Context) ([]string, error) {
// TODO(djd): Support range queries.
q := NewQuery(kindKind).KeysOnly()
keys, err := q.GetAll(ctx, nil)
if err != nil {
return nil, err
}
return keyNames(keys), nil
}
// keyNames returns a slice of the provided keys' names (string IDs).
func keyNames(keys []*Key) []string {
n := make([]string, 0, len(keys))
for _, k := range keys {
n = append(n, k.StringID())
}
return n
}
// KindProperties returns all the indexed properties for the given kind.
// The properties are returned as a map of property names to a slice of the
// representation types. The representation types for the supported Go property
// types are:
// "INT64": signed integers and time.Time
// "DOUBLE": float32 and float64
// "BOOLEAN": bool
// "STRING": string, []byte and ByteString
// "POINT": appengine.GeoPoint
// "REFERENCE": *Key
// "USER": (not used in the Go runtime)
func KindProperties(ctx context.Context, kind string) (map[string][]string, error) {
// TODO(djd): Support range queries.
kindKey := NewKey(ctx, kindKind, kind, 0, nil)
q := NewQuery(propertyKind).Ancestor(kindKey)
propMap := map[string][]string{}
props := []struct {
Repr []string `datastore:property_representation`
}{}
keys, err := q.GetAll(ctx, &props)
if err != nil {
return nil, err
}
for i, p := range props {
propMap[keys[i].StringID()] = p.Repr
}
return propMap, nil
}
================================================
FILE: vendor/google.golang.org/appengine/datastore/prop.go
================================================
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
package datastore
import (
"fmt"
"reflect"
"strings"
"sync"
"unicode"
)
// Entities with more than this many indexed properties will not be saved.
const maxIndexedProperties = 20000
// []byte fields more than 1 megabyte long will not be loaded or saved.
const maxBlobLen = 1 << 20
// Property is a name/value pair plus some metadata. A datastore entity's
// contents are loaded and saved as a sequence of Properties. An entity can
// have multiple Properties with the same name, provided that p.Multiple is
// true on all of that entity's Properties with that name.
type Property struct {
// Name is the property name.
Name string
// Value is the property value. The valid types are:
// - int64
// - bool
// - string
// - float64
// - ByteString
// - *Key
// - time.Time
// - appengine.BlobKey
// - appengine.GeoPoint
// - []byte (up to 1 megabyte in length)
// This set is smaller than the set of valid struct field types that the
// datastore can load and save. A Property Value cannot be a slice (apart
// from []byte); use multiple Properties instead. Also, a Value's type
// must be explicitly on the list above; it is not sufficient for the
// underlying type to be on that list. For example, a Value of "type
// myInt64 int64" is invalid. Smaller-width integers and floats are also
// invalid. Again, this is more restrictive than the set of valid struct
// field types.
//
// A Value will have an opaque type when loading entities from an index,
// such as via a projection query. Load entities into a struct instead
// of a PropertyLoadSaver when using a projection query.
//
// A Value may also be the nil interface value; this is equivalent to
// Python's None but not directly representable by a Go struct. Loading
// a nil-valued property into a struct will set that field to the zero
// value.
Value interface{}
// NoIndex is whether the datastore cannot index this property.
NoIndex bool
// Multiple is whether the entity can have multiple properties with
// the same name. Even if a particular instance only has one property with
// a certain name, Multiple should be true if a struct would best represent
// it as a field of type []T instead of type T.
Multiple bool
}
// ByteString is a short byte slice (up to 1500 bytes) that can be indexed.
type ByteString []byte
// PropertyLoadSaver can be converted from and to a slice of Properties.
type PropertyLoadSaver interface {
Load([]Property) error
Save() ([]Property, error)
}
// PropertyList converts a []Property to implement PropertyLoadSaver.
type PropertyList []Property
var (
typeOfPropertyLoadSaver = reflect.TypeOf((*PropertyLoadSaver)(nil)).Elem()
typeOfPropertyList = reflect.TypeOf(PropertyList(nil))
)
// Load loads all of the provided properties into l.
// It does not first reset *l to an empty slice.
func (l *PropertyList) Load(p []Property) error {
*l = append(*l, p...)
return nil
}
// Save saves all of l's properties as a slice or Properties.
func (l *PropertyList) Save() ([]Property, error) {
return *l, nil
}
// validPropertyName returns whether name consists of one or more valid Go
// identifiers joined by ".".
func validPropertyName(name string) bool {
if name == "" {
return false
}
for _, s := range strings.Split(name, ".") {
if s == "" {
return false
}
first := true
for _, c := range s {
if first {
first = false
if c != '_' && !unicode.IsLetter(c) {
return false
}
} else {
if c != '_' && !unicode.IsLetter(c) && !unicode.IsDigit(c) {
return false
}
}
}
}
return true
}
// structTag is the parsed `datastore:"name,options"` tag of a struct field.
// If a field has no tag, or the tag has an empty name, then the structTag's
// name is just the field name. A "-" name means that the datastore ignores
// that field.
type structTag struct {
name string
noIndex bool
}
// structCodec describes how to convert a struct to and from a sequence of
// properties.
type structCodec struct {
// byIndex gives the structTag for the i'th field.
byIndex []structTag
// byName gives the field codec for the structTag with the given name.
byName map[string]fieldCodec
// hasSlice is whether a struct or any of its nested or embedded structs
// has a slice-typed field (other than []byte).
hasSlice bool
// complete is whether the structCodec is complete. An incomplete
// structCodec may be encountered when walking a recursive struct.
complete bool
}
// fieldCodec is a struct field's index and, if that struct field's type is
// itself a struct, that substruct's structCodec.
type fieldCodec struct {
index int
substructCodec *structCodec
}
// structCodecs collects the structCodecs that have already been calculated.
var (
structCodecsMutex sync.Mutex
structCodecs = make(map[reflect.Type]*structCodec)
)
// getStructCodec returns the structCodec for the given struct type.
func getStructCodec(t reflect.Type) (*structCodec, error) {
structCodecsMutex.Lock()
defer structCodecsMutex.Unlock()
return getStructCodecLocked(t)
}
// getStructCodecLocked implements getStructCodec. The structCodecsMutex must
// be held when calling this function.
func getStructCodecLocked(t reflect.Type) (ret *structCodec, retErr error) {
c, ok := structCodecs[t]
if ok {
return c, nil
}
c = &structCodec{
byIndex: make([]structTag, t.NumField()),
byName: make(map[string]fieldCodec),
}
// Add c to the structCodecs map before we are sure it is good. If t is
// a recursive type, it needs to find the incomplete entry for itself in
// the map.
structCodecs[t] = c
defer func() {
if retErr != nil {
delete(structCodecs, t)
}
}()
for i := range c.byIndex {
f := t.Field(i)
name, opts := f.Tag.Get("datastore"), ""
if i := strings.Index(name, ","); i != -1 {
name, opts = name[:i], name[i+1:]
}
if name == "" {
if !f.Anonymous {
name = f.Name
}
} else if name == "-" {
c.byIndex[i] = structTag{name: name}
continue
} else if !validPropertyName(name) {
return nil, fmt.Errorf("datastore: struct tag has invalid property name: %q", name)
}
substructType, fIsSlice := reflect.Type(nil), false
switch f.Type.Kind() {
case reflect.Struct:
substructType = f.Type
case reflect.Slice:
if f.Type.Elem().Kind() == reflect.Struct {
substructType = f.Type.Elem()
}
fIsSlice = f.Type != typeOfByteSlice
c.hasSlice = c.hasSlice || fIsSlice
}
if substructType != nil && substructType != typeOfTime && substructType != typeOfGeoPoint {
if name != "" {
name = name + "."
}
sub, err := getStructCodecLocked(substructType)
if err != nil {
return nil, err
}
if !sub.complete {
return nil, fmt.Errorf("datastore: recursive struct: field %q", f.Name)
}
if fIsSlice && sub.hasSlice {
return nil, fmt.Errorf(
"datastore: flattening nested structs leads to a slice of slices: field %q", f.Name)
}
c.hasSlice = c.hasSlice || sub.hasSlice
for relName := range sub.byName {
absName := name + relName
if _, ok := c.byName[absName]; ok {
return nil, fmt.Errorf("datastore: struct tag has repeated property name: %q", absName)
}
c.byName[absName] = fieldCodec{index: i, substructCodec: sub}
}
} else {
if _, ok := c.byName[name]; ok {
return nil, fmt.Errorf("datastore: struct tag has repeated property name: %q", name)
}
c.byName[name] = fieldCodec{index: i}
}
c.byIndex[i] = structTag{
name: name,
noIndex: opts == "noindex",
}
}
c.complete = true
return c, nil
}
// structPLS adapts a struct to be a PropertyLoadSaver.
type structPLS struct {
v reflect.Value
codec *structCodec
}
// newStructPLS returns a PropertyLoadSaver for the struct pointer p.
func newStructPLS(p interface{}) (PropertyLoadSaver, error) {
v := reflect.ValueOf(p)
if v.Kind() != reflect.Ptr || v.Elem().Kind() != reflect.Struct {
return nil, ErrInvalidEntityType
}
v = v.Elem()
codec, err := getStructCodec(v.Type())
if err != nil {
return nil, err
}
return structPLS{v, codec}, nil
}
// LoadStruct loads the properties from p to dst.
// dst must be a struct pointer.
func LoadStruct(dst interface{}, p []Property) error {
x, err := newStructPLS(dst)
if err != nil {
return err
}
return x.Load(p)
}
// SaveStruct returns the properties from src as a slice of Properties.
// src must be a struct pointer.
func SaveStruct(src interface{}) ([]Property, error) {
x, err := newStructPLS(src)
if err != nil {
return nil, err
}
return x.Save()
}
================================================
FILE: vendor/google.golang.org/appengine/datastore/query.go
================================================
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
package datastore
import (
"encoding/base64"
"errors"
"fmt"
"math"
"reflect"
"strings"
"github.com/golang/protobuf/proto"
"golang.org/x/net/context"
"google.golang.org/appengine/internal"
pb "google.golang.org/appengine/internal/datastore"
)
type operator int
const (
lessThan operator = iota
lessEq
equal
greaterEq
greaterThan
)
var operatorToProto = map[operator]*pb.Query_Filter_Operator{
lessThan: pb.Query_Filter_LESS_THAN.Enum(),
lessEq: pb.Query_Filter_LESS_THAN_OR_EQUAL.Enum(),
equal: pb.Query_Filter_EQUAL.Enum(),
greaterEq: pb.Query_Filter_GREATER_THAN_OR_EQUAL.Enum(),
greaterThan: pb.Query_Filter_GREATER_THAN.Enum(),
}
// filter is a conditional filter on query results.
type filter struct {
FieldName string
Op operator
Value interface{}
}
type sortDirection int
const (
ascending sortDirection = iota
descending
)
var sortDirectionToProto = map[sortDirection]*pb.Query_Order_Direction{
ascending: pb.Query_Order_ASCENDING.Enum(),
descending: pb.Query_Order_DESCENDING.Enum(),
}
// order is a sort order on query results.
type order struct {
FieldName string
Direction sortDirection
}
// NewQuery creates a new Query for a specific entity kind.
//
// An empty kind means to return all entities, including entities created and
// managed by other App Engine features, and is called a kindless query.
// Kindless queries cannot include filters or sort orders on property values.
func NewQuery(kind string) *Query {
return &Query{
kind: kind,
limit: -1,
}
}
// Query represents a datastore query.
type Query struct {
kind string
ancestor *Key
filter []filter
order []order
projection []string
distinct bool
keysOnly bool
eventual bool
limit int32
offset int32
start *pb.CompiledCursor
end *pb.CompiledCursor
err error
}
func (q *Query) clone() *Query {
x := *q
// Copy the contents of the slice-typed fields to a new backing store.
if len(q.filter) > 0 {
x.filter = make([]filter, len(q.filter))
copy(x.filter, q.filter)
}
if len(q.order) > 0 {
x.order = make([]order, len(q.order))
copy(x.order, q.order)
}
return &x
}
// Ancestor returns a derivative query with an ancestor filter.
// The ancestor should not be nil.
func (q *Query) Ancestor(ancestor *Key) *Query {
q = q.clone()
if ancestor == nil {
q.err = errors.New("datastore: nil query ancestor")
return q
}
q.ancestor = ancestor
return q
}
// EventualConsistency returns a derivative query that returns eventually
// consistent results.
// It only has an effect on ancestor queries.
func (q *Query) EventualConsistency() *Query {
q = q.clone()
q.eventual = true
return q
}
// Filter returns a derivative query with a field-based filter.
// The filterStr argument must be a field name followed by optional space,
// followed by an operator, one of ">", "<", ">=", "<=", or "=".
// Fields are compared against the provided value using the operator.
// Multiple filters are AND'ed together.
func (q *Query) Filter(filterStr string, value interface{}) *Query {
q = q.clone()
filterStr = strings.TrimSpace(filterStr)
if len(filterStr) < 1 {
q.err = errors.New("datastore: invalid filter: " + filterStr)
return q
}
f := filter{
FieldName: strings.TrimRight(filterStr, " ><=!"),
Value: value,
}
switch op := strings.TrimSpace(filterStr[len(f.FieldName):]); op {
case "<=":
f.Op = lessEq
case ">=":
f.Op = greaterEq
case "<":
f.Op = lessThan
case ">":
f.Op = greaterThan
case "=":
f.Op = equal
default:
q.err = fmt.Errorf("datastore: invalid operator %q in filter %q", op, filterStr)
return q
}
q.filter = append(q.filter, f)
return q
}
// Order returns a derivative query with a field-based sort order. Orders are
// applied in the order they are added. The default order is ascending; to sort
// in descending order prefix the fieldName with a minus sign (-).
func (q *Query) Order(fieldName string) *Query {
q = q.clone()
fieldName = strings.TrimSpace(fieldName)
o := order{
Direction: ascending,
FieldName: fieldName,
}
if strings.HasPrefix(fieldName, "-") {
o.Direction = descending
o.FieldName = strings.TrimSpace(fieldName[1:])
} else if strings.HasPrefix(fieldName, "+") {
q.err = fmt.Errorf("datastore: invalid order: %q", fieldName)
return q
}
if len(o.FieldName) == 0 {
q.err = errors.New("datastore: empty order")
return q
}
q.order = append(q.order, o)
return q
}
// Project returns a derivative query that yields only the given fields. It
// cannot be used with KeysOnly.
func (q *Query) Project(fieldNames ...string) *Query {
q = q.clone()
q.projection = append([]string(nil), fieldNames...)
return q
}
// Distinct returns a derivative query that yields de-duplicated entities with
// respect to the set of projected fields. It is only used for projection
// queries.
func (q *Query) Distinct() *Query {
q = q.clone()
q.distinct = true
return q
}
// KeysOnly returns a derivative query that yields only keys, not keys and
// entities. It cannot be used with projection queries.
func (q *Query) KeysOnly() *Query {
q = q.clone()
q.keysOnly = true
return q
}
// Limit returns a derivative query that has a limit on the number of results
// returned. A negative value means unlimited.
func (q *Query) Limit(limit int) *Query {
q = q.clone()
if limit < math.MinInt32 || limit > math.MaxInt32 {
q.err = errors.New("datastore: query limit overflow")
return q
}
q.limit = int32(limit)
return q
}
// Offset returns a derivative query that has an offset of how many keys to
// skip over before returning results. A negative value is invalid.
func (q *Query) Offset(offset int) *Query {
q = q.clone()
if offset < 0 {
q.err = errors.New("datastore: negative query offset")
return q
}
if offset > math.MaxInt32 {
q.err = errors.New("datastore: query offset overflow")
return q
}
q.offset = int32(offset)
return q
}
// Start returns a derivative query with the given start point.
func (q *Query) Start(c Cursor) *Query {
q = q.clone()
if c.cc == nil {
q.err = errors.New("datastore: invalid cursor")
return q
}
q.start = c.cc
return q
}
// End returns a derivative query with the given end point.
func (q *Query) End(c Cursor) *Query {
q = q.clone()
if c.cc == nil {
q.err = errors.New("datastore: invalid cursor")
return q
}
q.end = c.cc
return q
}
// toProto converts the query to a protocol buffer.
func (q *Query) toProto(dst *pb.Query, appID string) error {
if len(q.projection) != 0 && q.keysOnly {
return errors.New("datastore: query cannot both project and be keys-only")
}
dst.Reset()
dst.App = proto.String(appID)
if q.kind != "" {
dst.Kind = proto.String(q.kind)
}
if q.ancestor != nil {
dst.Ancestor = keyToProto(appID, q.ancestor)
if q.eventual {
dst.Strong = proto.Bool(false)
}
}
if q.projection != nil {
dst.PropertyName = q.projection
if q.distinct {
dst.GroupByPropertyName = q.projection
}
}
if q.keysOnly {
dst.KeysOnly = proto.Bool(true)
dst.RequirePerfectPlan = proto.Bool(true)
}
for _, qf := range q.filter {
if qf.FieldName == "" {
return errors.New("datastore: empty query filter field name")
}
p, errStr := valueToProto(appID, qf.FieldName, reflect.ValueOf(qf.Value), false)
if errStr != "" {
return errors.New("datastore: bad query filter value type: " + errStr)
}
xf := &pb.Query_Filter{
Op: operatorToProto[qf.Op],
Property: []*pb.Property{p},
}
if xf.Op == nil {
return errors.New("datastore: unknown query filter operator")
}
dst.Filter = append(dst.Filter, xf)
}
for _, qo := range q.order {
if qo.FieldName == "" {
return errors.New("datastore: empty query order field name")
}
xo := &pb.Query_Order{
Property: proto.String(qo.FieldName),
Direction: sortDirectionToProto[qo.Direction],
}
if xo.Direction == nil {
return errors.New("datastore: unknown query order direction")
}
dst.Order = append(dst.Order, xo)
}
if q.limit >= 0 {
dst.Limit = proto.Int32(q.limit)
}
if q.offset != 0 {
dst.Offset = proto.Int32(q.offset)
}
dst.CompiledCursor = q.start
dst.EndCompiledCursor = q.end
dst.Compile = proto.Bool(true)
return nil
}
// Count returns the number of results for the query.
func (q *Query) Count(c context.Context) (int, error) {
// Check that the query is well-formed.
if q.err != nil {
return 0, q.err
}
// Run a copy of the query, with keysOnly true (if we're not a projection,
// since the two are incompatible), and an adjusted offset. We also set the
// limit to zero, as we don't want any actual entity data, just the number
// of skipped results.
newQ := q.clone()
newQ.keysOnly = len(newQ.projection) == 0
newQ.limit = 0
if q.limit < 0 {
// If the original query was unlimited, set the new query's offset to maximum.
newQ.offset = math.MaxInt32
} else {
newQ.offset = q.offset + q.limit
if newQ.offset < 0 {
// Do the best we can, in the presence of overflow.
newQ.offset = math.MaxInt32
}
}
req := &pb.Query{}
if err := newQ.toProto(req, internal.FullyQualifiedAppID(c)); err != nil {
return 0, err
}
res := &pb.QueryResult{}
if err := internal.Call(c, "datastore_v3", "RunQuery", req, res); err != nil {
return 0, err
}
// n is the count we will return. For example, suppose that our original
// query had an offset of 4 and a limit of 2008: the count will be 2008,
// provided that there are at least 2012 matching entities. However, the
// RPCs will only skip 1000 results at a time. The RPC sequence is:
// call RunQuery with (offset, limit) = (2012, 0) // 2012 == newQ.offset
// response has (skippedResults, moreResults) = (1000, true)
// n += 1000 // n == 1000
// call Next with (offset, limit) = (1012, 0) // 1012 == newQ.offset - n
// response has (skippedResults, moreResults) = (1000, true)
// n += 1000 // n == 2000
// call Next with (offset, limit) = (12, 0) // 12 == newQ.offset - n
// response has (skippedResults, moreResults) = (12, false)
// n += 12 // n == 2012
// // exit the loop
// n -= 4 // n == 2008
var n int32
for {
// The QueryResult should have no actual entity data, just skipped results.
if len(res.Result) != 0 {
return 0, errors.New("datastore: internal error: Count request returned too much data")
}
n += res.GetSkippedResults()
if !res.GetMoreResults() {
break
}
if err := callNext(c, res, newQ.offset-n, 0); err != nil {
return 0, err
}
}
n -= q.offset
if n < 0 {
// If the offset was greater than the number of matching entities,
// return 0 instead of negative.
n = 0
}
return int(n), nil
}
// callNext issues a datastore_v3/Next RPC to advance a cursor, such as that
// returned by a query with more results.
func callNext(c context.Context, res *pb.QueryResult, offset, limit int32) error {
if res.Cursor == nil {
return errors.New("datastore: internal error: server did not return a cursor")
}
req := &pb.NextRequest{
Cursor: res.Cursor,
}
if limit >= 0 {
req.Count = proto.Int32(limit)
}
if offset != 0 {
req.Offset = proto.Int32(offset)
}
if res.CompiledCursor != nil {
req.Compile = proto.Bool(true)
}
res.Reset()
return internal.Call(c, "datastore_v3", "Next", req, res)
}
// GetAll runs the query in the given context and returns all keys that match
// that query, as well as appending the values to dst.
//
// dst must have type *[]S or *[]*S or *[]P, for some struct type S or some non-
// interface, non-pointer type P such that P or *P implements PropertyLoadSaver.
//
// As a special case, *PropertyList is an invalid type for dst, even though a
// PropertyList is a slice of structs. It is treated as invalid to avoid being
// mistakenly passed when *[]PropertyList was intended.
//
// The keys returned by GetAll will be in a 1-1 correspondence with the entities
// added to dst.
//
// If q is a ``keys-only'' query, GetAll ignores dst and only returns the keys.
func (q *Query) GetAll(c context.Context, dst interface{}) ([]*Key, error) {
var (
dv reflect.Value
mat multiArgType
elemType reflect.Type
errFieldMismatch error
)
if !q.keysOnly {
dv = reflect.ValueOf(dst)
if dv.Kind() != reflect.Ptr || dv.IsNil() {
return nil, ErrInvalidEntityType
}
dv = dv.Elem()
mat, elemType = checkMultiArg(dv)
if mat == multiArgTypeInvalid || mat == multiArgTypeInterface {
return nil, ErrInvalidEntityType
}
}
var keys []*Key
for t := q.Run(c); ; {
k, e, err := t.next()
if err == Done {
break
}
if err != nil {
return keys, err
}
if !q.keysOnly {
ev := reflect.New(elemType)
if elemType.Kind() == reflect.Map {
// This is a special case. The zero values of a map type are
// not immediately useful; they have to be make'd.
//
// Funcs and channels are similar, in that a zero value is not useful,
// but even a freshly make'd channel isn't useful: there's no fixed
// channel buffer size that is always going to be large enough, and
// there's no goroutine to drain the other end. Theoretically, these
// types could be supported, for example by sniffing for a constructor
// method or requiring prior registration, but for now it's not a
// frequent enough concern to be worth it. Programmers can work around
// it by explicitly using Iterator.Next instead of the Query.GetAll
// convenience method.
x := reflect.MakeMap(elemType)
ev.Elem().Set(x)
}
if err = loadEntity(ev.Interface(), e); err != nil {
if _, ok := err.(*ErrFieldMismatch); ok {
// We continue loading entities even in the face of field mismatch errors.
// If we encounter any other error, that other error is returned. Otherwise,
// an ErrFieldMismatch is returned.
errFieldMismatch = err
} else {
return keys, err
}
}
if mat != multiArgTypeStructPtr {
ev = ev.Elem()
}
dv.Set(reflect.Append(dv, ev))
}
keys = append(keys, k)
}
return keys, errFieldMismatch
}
// Run runs the query in the given context.
func (q *Query) Run(c context.Context) *Iterator {
if q.err != nil {
return &Iterator{err: q.err}
}
t := &Iterator{
c: c,
limit: q.limit,
q: q,
prevCC: q.start,
}
var req pb.Query
if err := q.toProto(&req, internal.FullyQualifiedAppID(c)); err != nil {
t.err = err
return t
}
if err := internal.Call(c, "datastore_v3", "RunQuery", &req, &t.res); err != nil {
t.err = err
return t
}
offset := q.offset - t.res.GetSkippedResults()
for offset > 0 && t.res.GetMoreResults() {
t.prevCC = t.res.CompiledCursor
if err := callNext(t.c, &t.res, offset, t.limit); err != nil {
t.err = err
break
}
skip := t.res.GetSkippedResults()
if skip < 0 {
t.err = errors.New("datastore: internal error: negative number of skipped_results")
break
}
offset -= skip
}
if offset < 0 {
t.err = errors.New("datastore: internal error: query offset was overshot")
}
return t
}
// Iterator is the result of running a query.
type Iterator struct {
c context.Context
err error
// res is the result of the most recent RunQuery or Next API call.
res pb.QueryResult
// i is how many elements of res.Result we have iterated over.
i int
// limit is the limit on the number of results this iterator should return.
// A negative value means unlimited.
limit int32
// q is the original query which yielded this iterator.
q *Query
// prevCC is the compiled cursor that marks the end of the previous batch
// of results.
prevCC *pb.CompiledCursor
}
// Done is returned when a query iteration has completed.
var Done = errors.New("datastore: query has no more results")
// Next returns the key of the next result. When there are no more results,
// Done is returned as the error.
//
// If the query is not keys only and dst is non-nil, it also loads the entity
// stored for that key into the struct pointer or PropertyLoadSaver dst, with
// the same semantics and possible errors as for the Get function.
func (t *Iterator) Next(dst interface{}) (*Key, error) {
k, e, err := t.next()
if err != nil {
return nil, err
}
if dst != nil && !t.q.keysOnly {
err = loadEntity(dst, e)
}
return k, err
}
func (t *Iterator) next() (*Key, *pb.EntityProto, error) {
if t.err != nil {
return nil, nil, t.err
}
// Issue datastore_v3/Next RPCs as necessary.
for t.i == len(t.res.Result) {
if !t.res.GetMoreResults() {
t.err = Done
return nil, nil, t.err
}
t.prevCC = t.res.CompiledCursor
if err := callNext(t.c, &t.res, 0, t.limit); err != nil {
t.err = err
return nil, nil, t.err
}
if t.res.GetSkippedResults() != 0 {
t.err = errors.New("datastore: internal error: iterator has skipped results")
return nil, nil, t.err
}
t.i = 0
if t.limit >= 0 {
t.limit -= int32(len(t.res.Result))
if t.limit < 0 {
t.err = errors.New("datastore: internal error: query returned more results than the limit")
return nil, nil, t.err
}
}
}
// Extract the key from the t.i'th element of t.res.Result.
e := t.res.Result[t.i]
t.i++
if e.Key == nil {
return nil, nil, errors.New("datastore: internal error: server did not return a key")
}
k, err := protoToKey(e.Key)
if err != nil || k.Incomplete() {
return nil, nil, errors.New("datastore: internal error: server returned an invalid key")
}
return k, e, nil
}
// Cursor returns a cursor for the iterator's current location.
func (t *Iterator) Cursor() (Cursor, error) {
if t.err != nil && t.err != Done {
return Cursor{}, t.err
}
// If we are at either end of the current batch of results,
// return the compiled cursor at that end.
skipped := t.res.GetSkippedResults()
if t.i == 0 && skipped == 0 {
if t.prevCC == nil {
// A nil pointer (of type *pb.CompiledCursor) means no constraint:
// passing it as the end cursor of a new query means unlimited results
// (glossing over the integer limit parameter for now).
// A non-nil pointer to an empty pb.CompiledCursor means the start:
// passing it as the end cursor of a new query means 0 results.
// If prevCC was nil, then the original query had no start cursor, but
// Iterator.Cursor should return "the start" instead of unlimited.
return Cursor{&zeroCC}, nil
}
return Cursor{t.prevCC}, nil
}
if t.i == len(t.res.Result) {
return Cursor{t.res.CompiledCursor}, nil
}
// Otherwise, re-run the query offset to this iterator's position, starting from
// the most recent compiled cursor. This is done on a best-effort basis, as it
// is racy; if a concurrent process has added or removed entities, then the
// cursor returned may be inconsistent.
q := t.q.clone()
q.start = t.prevCC
q.offset = skipped + int32(t.i)
q.limit = 0
q.keysOnly = len(q.projection) == 0
t1 := q.Run(t.c)
_, _, err := t1.next()
if err != Done {
if err == nil {
err = fmt.Errorf("datastore: internal error: zero-limit query did not have zero results")
}
return Cursor{}, err
}
return Cursor{t1.res.CompiledCursor}, nil
}
var zeroCC pb.CompiledCursor
// Cursor is an iterator's position. It can be converted to and from an opaque
// string. A cursor can be used from different HTTP requests, but only with a
// query with the same kind, ancestor, filter and order constraints.
type Cursor struct {
cc *pb.CompiledCursor
}
// String returns a base-64 string representation of a cursor.
func (c Cursor) String() string {
if c.cc == nil {
return ""
}
b, err := proto.Marshal(c.cc)
if err != nil {
// The only way to construct a Cursor with a non-nil cc field is to
// unmarshal from the byte representation. We panic if the unmarshal
// succeeds but the marshaling of the unchanged protobuf value fails.
panic(fmt.Sprintf("datastore: internal error: malformed cursor: %v", err))
}
return strings.TrimRight(base64.URLEncoding.EncodeToString(b), "=")
}
// Decode decodes a cursor from its base-64 string representation.
func DecodeCursor(s string) (Cursor, error) {
if s == "" {
return Cursor{&zeroCC}, nil
}
if n := len(s) % 4; n != 0 {
s += strings.Repeat("=", 4-n)
}
b, err := base64.URLEncoding.DecodeString(s)
if err != nil {
return Cursor{}, err
}
cc := &pb.CompiledCursor{}
if err := proto.Unmarshal(b, cc); err != nil {
return Cursor{}, err
}
return Cursor{cc}, nil
}
================================================
FILE: vendor/google.golang.org/appengine/datastore/save.go
================================================
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
package datastore
import (
"errors"
"fmt"
"math"
"reflect"
"time"
"github.com/golang/protobuf/proto"
"google.golang.org/appengine"
pb "google.golang.org/appengine/internal/datastore"
)
func toUnixMicro(t time.Time) int64 {
// We cannot use t.UnixNano() / 1e3 because we want to handle times more than
// 2^63 nanoseconds (which is about 292 years) away from 1970, and those cannot
// be represented in the numerator of a single int64 divide.
return t.Unix()*1e6 + int64(t.Nanosecond()/1e3)
}
func fromUnixMicro(t int64) time.Time {
return time.Unix(t/1e6, (t%1e6)*1e3)
}
var (
minTime = time.Unix(int64(math.MinInt64)/1e6, (int64(math.MinInt64)%1e6)*1e3)
maxTime = time.Unix(int64(math.MaxInt64)/1e6, (int64(math.MaxInt64)%1e6)*1e3)
)
// valueToProto converts a named value to a newly allocated Property.
// The returned error string is empty on success.
func valueToProto(defaultAppID, name string, v reflect.Value, multiple bool) (p *pb.Property, errStr string) {
var (
pv pb.PropertyValue
unsupported bool
)
switch v.Kind() {
case reflect.Invalid:
// No-op.
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
pv.Int64Value = proto.Int64(v.Int())
case reflect.Bool:
pv.BooleanValue = proto.Bool(v.Bool())
case reflect.String:
pv.StringValue = proto.String(v.String())
case reflect.Float32, reflect.Float64:
pv.DoubleValue = proto.Float64(v.Float())
case reflect.Ptr:
if k, ok := v.Interface().(*Key); ok {
if k != nil {
pv.Referencevalue = keyToReferenceValue(defaultAppID, k)
}
} else {
unsupported = true
}
case reflect.Struct:
switch t := v.Interface().(type) {
case time.Time:
if t.Before(minTime) || t.After(maxTime) {
return nil, "time value out of range"
}
pv.Int64Value = proto.Int64(toUnixMicro(t))
case appengine.GeoPoint:
if !t.Valid() {
return nil, "invalid GeoPoint value"
}
// NOTE: Strangely, latitude maps to X, longitude to Y.
pv.Pointvalue = &pb.PropertyValue_PointValue{X: &t.Lat, Y: &t.Lng}
default:
unsupported = true
}
case reflect.Slice:
if b, ok := v.Interface().([]byte); ok {
pv.StringValue = proto.String(string(b))
} else {
// nvToProto should already catch slice values.
// If we get here, we have a slice of slice values.
unsupported = true
}
default:
unsupported = true
}
if unsupported {
return nil, "unsupported datastore value type: " + v.Type().String()
}
p = &pb.Property{
Name: proto.String(name),
Value: &pv,
Multiple: proto.Bool(multiple),
}
if v.IsValid() {
switch v.Interface().(type) {
case []byte:
p.Meaning = pb.Property_BLOB.Enum()
case ByteString:
p.Meaning = pb.Property_BYTESTRING.Enum()
case appengine.BlobKey:
p.Meaning = pb.Property_BLOBKEY.Enum()
case time.Time:
p.Meaning = pb.Property_GD_WHEN.Enum()
case appengine.GeoPoint:
p.Meaning = pb.Property_GEORSS_POINT.Enum()
}
}
return p, ""
}
// saveEntity saves an EntityProto into a PropertyLoadSaver or struct pointer.
func saveEntity(defaultAppID string, key *Key, src interface{}) (*pb.EntityProto, error) {
var err error
var props []Property
if e, ok := src.(PropertyLoadSaver); ok {
props, err = e.Save()
} else {
props, err = SaveStruct(src)
}
if err != nil {
return nil, err
}
return propertiesToProto(defaultAppID, key, props)
}
func saveStructProperty(props *[]Property, name string, noIndex, multiple bool, v reflect.Value) error {
p := Property{
Name: name,
NoIndex: noIndex,
Multiple: multiple,
}
switch x := v.Interface().(type) {
case *Key:
p.Value = x
case time.Time:
p.Value = x
case appengine.BlobKey:
p.Value = x
case appengine.GeoPoint:
p.Value = x
case ByteString:
p.Value = x
default:
switch v.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
p.Value = v.Int()
case reflect.Bool:
p.Value = v.Bool()
case reflect.String:
p.Value = v.String()
case reflect.Float32, reflect.Float64:
p.Value = v.Float()
case reflect.Slice:
if v.Type().Elem().Kind() == reflect.Uint8 {
p.NoIndex = true
p.Value = v.Bytes()
}
case reflect.Struct:
if !v.CanAddr() {
return fmt.Errorf("datastore: unsupported struct field: value is unaddressable")
}
sub, err := newStructPLS(v.Addr().Interface())
if err != nil {
return fmt.Errorf("datastore: unsupported struct field: %v", err)
}
return sub.(structPLS).save(props, name, noIndex, multiple)
}
}
if p.Value == nil {
return fmt.Errorf("datastore: unsupported struct field type: %v", v.Type())
}
*props = append(*props, p)
return nil
}
func (s structPLS) Save() ([]Property, error) {
var props []Property
if err := s.save(&props, "", false, false); err != nil {
return nil, err
}
return props, nil
}
func (s structPLS) save(props *[]Property, prefix string, noIndex, multiple bool) error {
for i, t := range s.codec.byIndex {
if t.name == "-" {
continue
}
name := t.name
if prefix != "" {
name = prefix + name
}
v := s.v.Field(i)
if !v.IsValid() || !v.CanSet() {
continue
}
noIndex1 := noIndex || t.noIndex
// For slice fields that aren't []byte, save each element.
if v.Kind() == reflect.Slice && v.Type().Elem().Kind() != reflect.Uint8 {
for j := 0; j < v.Len(); j++ {
if err := saveStructProperty(props, name, noIndex1, true, v.Index(j)); err != nil {
return err
}
}
continue
}
// Otherwise, save the field itself.
if err := saveStructProperty(props, name, noIndex1, multiple, v); err != nil {
return err
}
}
return nil
}
func propertiesToProto(defaultAppID string, key *Key, props []Property) (*pb.EntityProto, error) {
e := &pb.EntityProto{
Key: keyToProto(defaultAppID, key),
}
if key.parent == nil {
e.EntityGroup = &pb.Path{}
} else {
e.EntityGroup = keyToProto(defaultAppID, key.root()).Path
}
prevMultiple := make(map[string]bool)
for _, p := range props {
if pm, ok := prevMultiple[p.Name]; ok {
if !pm || !p.Multiple {
return nil, fmt.Errorf("datastore: multiple Properties with Name %q, but Multiple is false", p.Name)
}
} else {
prevMultiple[p.Name] = p.Multiple
}
x := &pb.Property{
Name: proto.String(p.Name),
Value: new(pb.PropertyValue),
Multiple: proto.Bool(p.Multiple),
}
switch v := p.Value.(type) {
case int64:
x.Value.Int64Value = proto.Int64(v)
case bool:
x.Value.BooleanValue = proto.Bool(v)
case string:
x.Value.StringValue = proto.String(v)
if p.NoIndex {
x.Meaning = pb.Property_TEXT.Enum()
}
case float64:
x.Value.DoubleValue = proto.Float64(v)
case *Key:
if v != nil {
x.Value.Referencevalue = keyToReferenceValue(defaultAppID, v)
}
case time.Time:
if v.Before(minTime) || v.After(maxTime) {
return nil, fmt.Errorf("datastore: time value out of range")
}
x.Value.Int64Value = proto.Int64(toUnixMicro(v))
x.Meaning = pb.Property_GD_WHEN.Enum()
case appengine.BlobKey:
x.Value.StringValue = proto.String(string(v))
x.Meaning = pb.Property_BLOBKEY.Enum()
case appengine.GeoPoint:
if !v.Valid() {
return nil, fmt.Errorf("datastore: invalid GeoPoint value")
}
// NOTE: Strangely, latitude maps to X, longitude to Y.
x.Value.Pointvalue = &pb.PropertyValue_PointValue{X: &v.Lat, Y: &v.Lng}
x.Meaning = pb.Property_GEORSS_POINT.Enum()
case []byte:
x.Value.StringValue = proto.String(string(v))
x.Meaning = pb.Property_BLOB.Enum()
if !p.NoIndex {
return nil, fmt.Errorf("datastore: cannot index a []byte valued Property with Name %q", p.Name)
}
case ByteString:
x.Value.StringValue = proto.String(string(v))
x.Meaning = pb.Property_BYTESTRING.Enum()
default:
if p.Value != nil {
return nil, fmt.Errorf("datastore: invalid Value type for a Property with Name %q", p.Name)
}
}
if p.NoIndex {
e.RawProperty = append(e.RawProperty, x)
} else {
e.Property = append(e.Property, x)
if len(e.Property) > maxIndexedProperties {
return nil, errors.New("datastore: too many indexed properties")
}
}
}
return e, nil
}
================================================
FILE: vendor/google.golang.org/appengine/datastore/transaction.go
================================================
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
package datastore
import (
"errors"
"golang.org/x/net/context"
"google.golang.org/appengine/internal"
pb "google.golang.org/appengine/internal/datastore"
)
func init() {
internal.RegisterTransactionSetter(func(x *pb.Query, t *pb.Transaction) {
x.Transaction = t
})
internal.RegisterTransactionSetter(func(x *pb.GetRequest, t *pb.Transaction) {
x.Transaction = t
})
internal.RegisterTransactionSetter(func(x *pb.PutRequest, t *pb.Transaction) {
x.Transaction = t
})
internal.RegisterTransactionSetter(func(x *pb.DeleteRequest, t *pb.Transaction) {
x.Transaction = t
})
}
// ErrConcurrentTransaction is returned when a transaction is rolled back due
// to a conflict with a concurrent transaction.
var ErrConcurrentTransaction = errors.New("datastore: concurrent transaction")
// RunInTransaction runs f in a transaction. It calls f with a transaction
// context tc that f should use for all App Engine operations.
//
// If f returns nil, RunInTransaction attempts to commit the transaction,
// returning nil if it succeeds. If the commit fails due to a conflicting
// transaction, RunInTransaction retries f, each time with a new transaction
// context. It gives up and returns ErrConcurrentTransaction after three
// failed attempts. The number of attempts can be configured by specifying
// TransactionOptions.Attempts.
//
// If f returns non-nil, then any datastore changes will not be applied and
// RunInTransaction returns that same error. The function f is not retried.
//
// Note that when f returns, the transaction is not yet committed. Calling code
// must be careful not to assume that any of f's changes have been committed
// until RunInTransaction returns nil.
//
// Since f may be called multiple times, f should usually be idempotent.
// datastore.Get is not idempotent when unmarshaling slice fields.
//
// Nested transactions are not supported; c may not be a transaction context.
func RunInTransaction(c context.Context, f func(tc context.Context) error, opts *TransactionOptions) error {
xg := false
if opts != nil {
xg = opts.XG
}
attempts := 3
if opts != nil && opts.Attempts > 0 {
attempts = opts.Attempts
}
for i := 0; i < attempts; i++ {
if err := internal.RunTransactionOnce(c, f, xg); err != internal.ErrConcurrentTransaction {
return err
}
}
return ErrConcurrentTransaction
}
// TransactionOptions are the options for running a transaction.
type TransactionOptions struct {
// XG is whether the transaction can cross multiple entity groups. In
// comparison, a single group transaction is one where all datastore keys
// used have the same root key. Note that cross group transactions do not
// have the same behavior as single group transactions. In particular, it
// is much more likely to see partially applied transactions in different
// entity groups, in global queries.
// It is valid to set XG to true even if the transaction is within a
// single entity group.
XG bool
// Attempts controls the number of retries to perform when commits fail
// due to a conflicting transaction. If omitted, it defaults to 3.
Attempts int
}
================================================
FILE: vendor/google.golang.org/appengine/delay/delay.go
================================================
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
/*
Package delay provides a way to execute code outside the scope of a
user request by using the taskqueue API.
To declare a function that may be executed later, call Func
in a top-level assignment context, passing it an arbitrary string key
and a function whose first argument is of type context.Context.
var laterFunc = delay.Func("key", myFunc)
It is also possible to use a function literal.
var laterFunc = delay.Func("key", func(c context.Context, x string) {
// ...
})
To call a function, invoke its Call method.
laterFunc.Call(c, "something")
A function may be called any number of times. If the function has any
return arguments, and the last one is of type error, the function may
return a non-nil error to signal that the function should be retried.
The arguments to functions may be of any type that is encodable by the gob
package. If an argument is of interface type, it is the client's responsibility
to register with the gob package whatever concrete type may be passed for that
argument; see http://golang.org/pkg/gob/#Register for details.
Any errors during initialization or execution of a function will be
logged to the application logs. Error logs that occur during initialization will
be associated with the request that invoked the Call method.
The state of a function invocation that has not yet successfully
executed is preserved by combining the file name in which it is declared
with the string key that was passed to the Func function. Updating an app
with pending function invocations is safe as long as the relevant
functions have the (filename, key) combination preserved.
The delay package uses the Task Queue API to create tasks that call the
reserved application path "/_ah/queue/go/delay".
This path must not be marked as "login: required" in app.yaml;
it must be marked as "login: admin" or have no access restriction.
*/
package delay
import (
"bytes"
"encoding/gob"
"errors"
"fmt"
"net/http"
"reflect"
"runtime"
"golang.org/x/net/context"
"google.golang.org/appengine"
"google.golang.org/appengine/log"
"google.golang.org/appengine/taskqueue"
)
// Function represents a function that may have a delayed invocation.
type Function struct {
fv reflect.Value // Kind() == reflect.Func
key string
err error // any error during initialization
}
const (
// The HTTP path for invocations.
path = "/_ah/queue/go/delay"
// Use the default queue.
queue = ""
)
var (
// registry of all delayed functions
funcs = make(map[string]*Function)
// precomputed types
contextType = reflect.TypeOf((*context.Context)(nil)).Elem()
errorType = reflect.TypeOf((*error)(nil)).Elem()
// errors
errFirstArg = errors.New("first argument must be context.Context")
)
// Func declares a new Function. The second argument must be a function with a
// first argument of type context.Context.
// This function must be called at program initialization time. That means it
// must be called in a global variable declaration or from an init function.
// This restriction is necessary because the instance that delays a function
// call may not be the one that executes it. Only the code executed at program
// initialization time is guaranteed to have been run by an instance before it
// receives a request.
func Func(key string, i interface{}) *Function {
f := &Function{fv: reflect.ValueOf(i)}
// Derive unique, somewhat stable key for this func.
_, file, _, _ := runtime.Caller(1)
f.key = file + ":" + key
t := f.fv.Type()
if t.Kind() != reflect.Func {
f.err = errors.New("not a function")
return f
}
if t.NumIn() == 0 || t.In(0) != contextType {
f.err = errFirstArg
return f
}
// Register the function's arguments with the gob package.
// This is required because they are marshaled inside a []interface{}.
// gob.Register only expects to be called during initialization;
// that's fine because this function expects the same.
for i := 0; i < t.NumIn(); i++ {
// Only concrete types may be registered. If the argument has
// interface type, the client is resposible for registering the
// concrete types it will hold.
if t.In(i).Kind() == reflect.Interface {
continue
}
gob.Register(reflect.Zero(t.In(i)).Interface())
}
funcs[f.key] = f
return f
}
type invocation struct {
Key string
Args []interface{}
}
// Call invokes a delayed function.
// err := f.Call(c, ...)
// is equivalent to
// t, _ := f.Task(...)
// err := taskqueue.Add(c, t, "")
func (f *Function) Call(c context.Context, args ...interface{}) error {
t, err := f.Task(args...)
if err != nil {
return err
}
_, err = taskqueueAdder(c, t, queue)
return err
}
// Task creates a Task that will invoke the function.
// Its parameters may be tweaked before adding it to a queue.
// Users should not modify the Path or Payload fields of the returned Task.
func (f *Function) Task(args ...interface{}) (*taskqueue.Task, error) {
if f.err != nil {
return nil, fmt.Errorf("delay: func is invalid: %v", f.err)
}
nArgs := len(args) + 1 // +1 for the context.Context
ft := f.fv.Type()
minArgs := ft.NumIn()
if ft.IsVariadic() {
minArgs--
}
if nArgs < minArgs {
return nil, fmt.Errorf("delay: too few arguments to func: %d < %d", nArgs, minArgs)
}
if !ft.IsVariadic() && nArgs > minArgs {
return nil, fmt.Errorf("delay: too many arguments to func: %d > %d", nArgs, minArgs)
}
// Check arg types.
for i := 1; i < nArgs; i++ {
at := reflect.TypeOf(args[i-1])
var dt reflect.Type
if i < minArgs {
// not a variadic arg
dt = ft.In(i)
} else {
// a variadic arg
dt = ft.In(minArgs).Elem()
}
// nil arguments won't have a type, so they need special handling.
if at == nil {
// nil interface
switch dt.Kind() {
case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
continue // may be nil
}
return nil, fmt.Errorf("delay: argument %d has wrong type: %v is not nilable", i, dt)
}
switch at.Kind() {
case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice:
av := reflect.ValueOf(args[i-1])
if av.IsNil() {
// nil value in interface; not supported by gob, so we replace it
// with a nil interface value
args[i-1] = nil
}
}
if !at.AssignableTo(dt) {
return nil, fmt.Errorf("delay: argument %d has wrong type: %v is not assignable to %v", i, at, dt)
}
}
inv := invocation{
Key: f.key,
Args: args,
}
buf := new(bytes.Buffer)
if err := gob.NewEncoder(buf).Encode(inv); err != nil {
return nil, fmt.Errorf("delay: gob encoding failed: %v", err)
}
return &taskqueue.Task{
Path: path,
Payload: buf.Bytes(),
}, nil
}
var taskqueueAdder = taskqueue.Add // for testing
func init() {
http.HandleFunc(path, func(w http.ResponseWriter, req *http.Request) {
runFunc(appengine.NewContext(req), w, req)
})
}
func runFunc(c context.Context, w http.ResponseWriter, req *http.Request) {
defer req.Body.Close()
var inv invocation
if err := gob.NewDecoder(req.Body).Decode(&inv); err != nil {
log.Errorf(c, "delay: failed decoding task payload: %v", err)
log.Warningf(c, "delay: dropping task")
return
}
f := funcs[inv.Key]
if f == nil {
log.Errorf(c, "delay: no func with key %q found", inv.Key)
log.Warningf(c, "delay: dropping task")
return
}
ft := f.fv.Type()
in := []reflect.Value{reflect.ValueOf(c)}
for _, arg := range inv.Args {
var v reflect.Value
if arg != nil {
v = reflect.ValueOf(arg)
} else {
// Task was passed a nil argument, so we must construct
// the zero value for the argument here.
n := len(in) // we're constructing the nth argument
var at reflect.Type
if !ft.IsVariadic() || n < ft.NumIn()-1 {
at = ft.In(n)
} else {
at = ft.In(ft.NumIn() - 1).Elem()
}
v = reflect.Zero(at)
}
in = append(in, v)
}
out := f.fv.Call(in)
if n := ft.NumOut(); n > 0 && ft.Out(n-1) == errorType {
if errv := out[n-1]; !errv.IsNil() {
log.Errorf(c, "delay: func failed (will retry): %v", errv.Interface())
w.WriteHeader(http.StatusInternalServerError)
return
}
}
}
================================================
FILE: vendor/google.golang.org/appengine/demos/guestbook/app.yaml
================================================
# Demo application for Managed VMs.
runtime: go
vm: true
api_version: go1
manual_scaling:
instances: 1
handlers:
# Favicon. Without this, the browser hits this once per page view.
- url: /favicon.ico
static_files: favicon.ico
upload: favicon.ico
# Main app. All the real work is here.
- url: /.*
script: _go_app
================================================
FILE: vendor/google.golang.org/appengine/demos/guestbook/guestbook.go
================================================
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
// This example only works on Managed VMs.
// +build !appengine
package main
import (
"html/template"
"net/http"
"time"
"golang.org/x/net/context"
"google.golang.org/appengine"
"google.golang.org/appengine/datastore"
"google.golang.org/appengine/log"
"google.golang.org/appengine/user"
)
var initTime time.Time
type Greeting struct {
Author string
Content string
Date time.Time
}
func main() {
http.HandleFunc("/", handleMainPage)
http.HandleFunc("/sign", handleSign)
appengine.Main()
}
// guestbookKey returns the key used for all guestbook entries.
func guestbookKey(ctx context.Context) *datastore.Key {
// The string "default_guestbook" here could be varied to have multiple guestbooks.
return datastore.NewKey(ctx, "Guestbook", "default_guestbook", 0, nil)
}
var tpl = template.Must(template.ParseGlob("templates/*.html"))
func handleMainPage(w http.ResponseWriter, r *http.Request) {
if r.Method != "GET" {
http.Error(w, "GET requests only", http.StatusMethodNotAllowed)
return
}
if r.URL.Path != "/" {
http.NotFound(w, r)
return
}
ctx := appengine.NewContext(r)
tic := time.Now()
q := datastore.NewQuery("Greeting").Ancestor(guestbookKey(ctx)).Order("-Date").Limit(10)
var gg []*Greeting
if _, err := q.GetAll(ctx, &gg); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
log.Errorf(ctx, "GetAll: %v", err)
return
}
log.Infof(ctx, "Datastore lookup took %s", time.Since(tic).String())
log.Infof(ctx, "Rendering %d greetings", len(gg))
var email, logout, login string
if u := user.Current(ctx); u != nil {
logout, _ = user.LogoutURL(ctx, "/")
email = u.Email
} else {
login, _ = user.LoginURL(ctx, "/")
}
data := struct {
Greetings []*Greeting
Login, Logout, Email string
}{
Greetings: gg,
Login: login,
Logout: logout,
Email: email,
}
w.Header().Set("Content-Type", "text/html; charset=utf-8")
if err := tpl.ExecuteTemplate(w, "guestbook.html", data); err != nil {
log.Errorf(ctx, "%v", err)
}
}
func handleSign(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
http.Error(w, "POST requests only", http.StatusMethodNotAllowed)
return
}
ctx := appengine.NewContext(r)
g := &Greeting{
Content: r.FormValue("content"),
Date: time.Now(),
}
if u := user.Current(ctx); u != nil {
g.Author = u.String()
}
key := datastore.NewIncompleteKey(ctx, "Greeting", guestbookKey(ctx))
if _, err := datastore.Put(ctx, key, g); err != nil {
http.Error(w, err.Error(), http.StatusInternalServerError)
return
}
// Redirect with 303 which causes the subsequent request to use GET.
http.Redirect(w, r, "/", http.StatusSeeOther)
}
================================================
FILE: vendor/google.golang.org/appengine/demos/guestbook/index.yaml
================================================
indexes:
- kind: Greeting
ancestor: yes
properties:
- name: Date
direction: desc
================================================
FILE: vendor/google.golang.org/appengine/demos/guestbook/templates/guestbook.html
================================================
Guestbook Demo
{{with .Email}}You are currently logged in as {{.}}.{{end}}
{{with .Login}}Sign in{{end}}
{{with .Logout}}Sign out{{end}}
{{range .Greetings }}
{{with .Author}}{{.}}{{else}}An anonymous person{{end}}
on {{.Date.Format "3:04pm, Mon 2 Jan"}}
wrote
{{.Content}}
{{end}}
================================================
FILE: vendor/google.golang.org/appengine/demos/helloworld/app.yaml
================================================
runtime: go
api_version: go1
vm: true
manual_scaling:
instances: 1
handlers:
- url: /favicon.ico
static_files: favicon.ico
upload: favicon.ico
- url: /.*
script: _go_app
================================================
FILE: vendor/google.golang.org/appengine/demos/helloworld/helloworld.go
================================================
// Copyright 2014 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
// This example only works on Managed VMs.
// +build !appengine
package main
import (
"html/template"
"net/http"
"time"
"google.golang.org/appengine"
"google.golang.org/appengine/log"
)
var initTime = time.Now()
func main() {
http.HandleFunc("/", handle)
appengine.Main()
}
func handle(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/" {
http.NotFound(w, r)
return
}
ctx := appengine.NewContext(r)
log.Infof(ctx, "Serving the front page.")
tmpl.Execute(w, time.Since(initTime))
}
var tmpl = template.Must(template.New("front").Parse(`
Hello, World! 세상아 안녕!
This instance has been running for {{.}}.
`))
================================================
FILE: vendor/google.golang.org/appengine/errors.go
================================================
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
// This file provides error functions for common API failure modes.
package appengine
import (
"fmt"
"google.golang.org/appengine/internal"
)
// IsOverQuota reports whether err represents an API call failure
// due to insufficient available quota.
func IsOverQuota(err error) bool {
callErr, ok := err.(*internal.CallError)
return ok && callErr.Code == 4
}
// MultiError is returned by batch operations when there are errors with
// particular elements. Errors will be in a one-to-one correspondence with
// the input elements; successful elements will have a nil entry.
type MultiError []error
func (m MultiError) Error() string {
s, n := "", 0
for _, e := range m {
if e != nil {
if n == 0 {
s = e.Error()
}
n++
}
}
switch n {
case 0:
return "(0 errors)"
case 1:
return s
case 2:
return s + " (and 1 other error)"
}
return fmt.Sprintf("%s (and %d other errors)", s, n-1)
}
================================================
FILE: vendor/google.golang.org/appengine/file/file.go
================================================
// Copyright 2014 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
// Package file provides helper functions for using Google Cloud Storage.
package file
import (
"fmt"
"golang.org/x/net/context"
"google.golang.org/appengine/internal"
aipb "google.golang.org/appengine/internal/app_identity"
)
// DefaultBucketName returns the name of this application's
// default Google Cloud Storage bucket.
func DefaultBucketName(c context.Context) (string, error) {
req := &aipb.GetDefaultGcsBucketNameRequest{}
res := &aipb.GetDefaultGcsBucketNameResponse{}
err := internal.Call(c, "app_identity_service", "GetDefaultGcsBucketName", req, res)
if err != nil {
return "", fmt.Errorf("file: no default bucket name returned in RPC response: %v", res)
}
return res.GetDefaultGcsBucketName(), nil
}
================================================
FILE: vendor/google.golang.org/appengine/identity.go
================================================
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
package appengine
import (
"time"
"golang.org/x/net/context"
"google.golang.org/appengine/internal"
pb "google.golang.org/appengine/internal/app_identity"
modpb "google.golang.org/appengine/internal/modules"
)
// AppID returns the application ID for the current application.
// The string will be a plain application ID (e.g. "appid"), with a
// domain prefix for custom domain deployments (e.g. "example.com:appid").
func AppID(c context.Context) string { return internal.AppID(c) }
// DefaultVersionHostname returns the standard hostname of the default version
// of the current application (e.g. "my-app.appspot.com"). This is suitable for
// use in constructing URLs.
func DefaultVersionHostname(c context.Context) string {
return internal.DefaultVersionHostname(c)
}
// ModuleName returns the module name of the current instance.
func ModuleName(c context.Context) string {
return internal.ModuleName(c)
}
// ModuleHostname returns a hostname of a module instance.
// If module is the empty string, it refers to the module of the current instance.
// If version is empty, it refers to the version of the current instance if valid,
// or the default version of the module of the current instance.
// If instance is empty, ModuleHostname returns the load-balancing hostname.
func ModuleHostname(c context.Context, module, version, instance string) (string, error) {
req := &modpb.GetHostnameRequest{}
if module != "" {
req.Module = &module
}
if version != "" {
req.Version = &version
}
if instance != "" {
req.Instance = &instance
}
res := &modpb.GetHostnameResponse{}
if err := internal.Call(c, "modules", "GetHostname", req, res); err != nil {
return "", err
}
return *res.Hostname, nil
}
// VersionID returns the version ID for the current application.
// It will be of the form "X.Y", where X is specified in app.yaml,
// and Y is a number generated when each version of the app is uploaded.
// It does not include a module name.
func VersionID(c context.Context) string { return internal.VersionID(c) }
// InstanceID returns a mostly-unique identifier for this instance.
func InstanceID() string { return internal.InstanceID() }
// Datacenter returns an identifier for the datacenter that the instance is running in.
func Datacenter(c context.Context) string { return internal.Datacenter(c) }
// ServerSoftware returns the App Engine release version.
// In production, it looks like "Google App Engine/X.Y.Z".
// In the development appserver, it looks like "Development/X.Y".
func ServerSoftware() string { return internal.ServerSoftware() }
// RequestID returns a string that uniquely identifies the request.
func RequestID(c context.Context) string { return internal.RequestID(c) }
// AccessToken generates an OAuth2 access token for the specified scopes on
// behalf of service account of this application. This token will expire after
// the returned time.
func AccessToken(c context.Context, scopes ...string) (token string, expiry time.Time, err error) {
req := &pb.GetAccessTokenRequest{Scope: scopes}
res := &pb.GetAccessTokenResponse{}
err = internal.Call(c, "app_identity_service", "GetAccessToken", req, res)
if err != nil {
return "", time.Time{}, err
}
return res.GetAccessToken(), time.Unix(res.GetExpirationTime(), 0), nil
}
// Certificate represents a public certificate for the app.
type Certificate struct {
KeyName string
Data []byte // PEM-encoded X.509 certificate
}
// PublicCertificates retrieves the public certificates for the app.
// They can be used to verify a signature returned by SignBytes.
func PublicCertificates(c context.Context) ([]Certificate, error) {
req := &pb.GetPublicCertificateForAppRequest{}
res := &pb.GetPublicCertificateForAppResponse{}
if err := internal.Call(c, "app_identity_service", "GetPublicCertificatesForApp", req, res); err != nil {
return nil, err
}
var cs []Certificate
for _, pc := range res.PublicCertificateList {
cs = append(cs, Certificate{
KeyName: pc.GetKeyName(),
Data: []byte(pc.GetX509CertificatePem()),
})
}
return cs, nil
}
// ServiceAccount returns a string representing the service account name, in
// the form of an email address (typically app_id@appspot.gserviceaccount.com).
func ServiceAccount(c context.Context) (string, error) {
req := &pb.GetServiceAccountNameRequest{}
res := &pb.GetServiceAccountNameResponse{}
err := internal.Call(c, "app_identity_service", "GetServiceAccountName", req, res)
if err != nil {
return "", err
}
return res.GetServiceAccountName(), err
}
// SignBytes signs bytes using a private key unique to your application.
func SignBytes(c context.Context, bytes []byte) (keyName string, signature []byte, err error) {
req := &pb.SignForAppRequest{BytesToSign: bytes}
res := &pb.SignForAppResponse{}
if err := internal.Call(c, "app_identity_service", "SignForApp", req, res); err != nil {
return "", nil, err
}
return res.GetKeyName(), res.GetSignatureBytes(), nil
}
func init() {
internal.RegisterErrorCodeMap("app_identity_service", pb.AppIdentityServiceError_ErrorCode_name)
internal.RegisterErrorCodeMap("modules", modpb.ModulesServiceError_ErrorCode_name)
}
================================================
FILE: vendor/google.golang.org/appengine/image/image.go
================================================
// Copyright 2012 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
// Package image provides image services.
package image
import (
"fmt"
"net/url"
"golang.org/x/net/context"
"google.golang.org/appengine"
"google.golang.org/appengine/internal"
pb "google.golang.org/appengine/internal/image"
)
type ServingURLOptions struct {
Secure bool // whether the URL should use HTTPS
// Size must be between zero and 1600.
// If Size is non-zero, a resized version of the image is served,
// and Size is the served image's longest dimension. The aspect ratio is preserved.
// If Crop is true the image is cropped from the center instead of being resized.
Size int
Crop bool
}
// ServingURL returns a URL that will serve an image from Blobstore.
func ServingURL(c context.Context, key appengine.BlobKey, opts *ServingURLOptions) (*url.URL, error) {
req := &pb.ImagesGetUrlBaseRequest{
BlobKey: (*string)(&key),
}
if opts != nil && opts.Secure {
req.CreateSecureUrl = &opts.Secure
}
res := &pb.ImagesGetUrlBaseResponse{}
if err := internal.Call(c, "images", "GetUrlBase", req, res); err != nil {
return nil, err
}
// The URL may have suffixes added to dynamically resize or crop:
// - adding "=s32" will serve the image resized to 32 pixels, preserving the aspect ratio.
// - adding "=s32-c" is the same as "=s32" except it will be cropped.
u := *res.Url
if opts != nil && opts.Size > 0 {
u += fmt.Sprintf("=s%d", opts.Size)
if opts.Crop {
u += "-c"
}
}
return url.Parse(u)
}
// DeleteServingURL deletes the serving URL for an image.
func DeleteServingURL(c context.Context, key appengine.BlobKey) error {
req := &pb.ImagesDeleteUrlBaseRequest{
BlobKey: (*string)(&key),
}
res := &pb.ImagesDeleteUrlBaseResponse{}
return internal.Call(c, "images", "DeleteUrlBase", req, res)
}
func init() {
internal.RegisterErrorCodeMap("images", pb.ImagesServiceError_ErrorCode_name)
}
================================================
FILE: vendor/google.golang.org/appengine/internal/aetesting/fake.go
================================================
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
// Package aetesting provides utilities for testing App Engine packages.
// This is not for testing user applications.
package aetesting
import (
"fmt"
"reflect"
"testing"
"github.com/golang/protobuf/proto"
"golang.org/x/net/context"
"google.golang.org/appengine/internal"
)
// FakeSingleContext returns a context whose Call invocations will be serviced
// by f, which should be a function that has two arguments of the input and output
// protocol buffer type, and one error return.
func FakeSingleContext(t *testing.T, service, method string, f interface{}) context.Context {
fv := reflect.ValueOf(f)
if fv.Kind() != reflect.Func {
t.Fatal("not a function")
}
ft := fv.Type()
if ft.NumIn() != 2 || ft.NumOut() != 1 {
t.Fatalf("f has %d in and %d out, want 2 in and 1 out", ft.NumIn(), ft.NumOut())
}
for i := 0; i < 2; i++ {
at := ft.In(i)
if !at.Implements(protoMessageType) {
t.Fatalf("arg %d does not implement proto.Message", i)
}
}
if ft.Out(0) != errorType {
t.Fatalf("f's return is %v, want error", ft.Out(0))
}
s := &single{
t: t,
service: service,
method: method,
f: fv,
}
return internal.WithCallOverride(context.Background(), s.call)
}
var (
protoMessageType = reflect.TypeOf((*proto.Message)(nil)).Elem()
errorType = reflect.TypeOf((*error)(nil)).Elem()
)
type single struct {
t *testing.T
service, method string
f reflect.Value
}
func (s *single) call(ctx context.Context, service, method string, in, out proto.Message) error {
if service == "__go__" {
if method == "GetNamespace" {
return nil // always yield an empty namespace
}
return fmt.Errorf("Unknown API call /%s.%s", service, method)
}
if service != s.service || method != s.method {
s.t.Fatalf("Unexpected call to /%s.%s", service, method)
}
ins := []reflect.Value{
reflect.ValueOf(in),
reflect.ValueOf(out),
}
outs := s.f.Call(ins)
if outs[0].IsNil() {
return nil
}
return outs[0].Interface().(error)
}
================================================
FILE: vendor/google.golang.org/appengine/internal/api.go
================================================
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
// +build !appengine
package internal
import (
"bytes"
"errors"
"fmt"
"io/ioutil"
"log"
"net"
"net/http"
"net/url"
"os"
"runtime"
"strconv"
"strings"
"sync"
"sync/atomic"
"time"
"github.com/golang/protobuf/proto"
netcontext "golang.org/x/net/context"
basepb "google.golang.org/appengine/internal/base"
logpb "google.golang.org/appengine/internal/log"
remotepb "google.golang.org/appengine/internal/remote_api"
)
const (
apiPath = "/rpc_http"
)
var (
// Incoming headers.
ticketHeader = http.CanonicalHeaderKey("X-AppEngine-API-Ticket")
dapperHeader = http.CanonicalHeaderKey("X-Google-DapperTraceInfo")
traceHeader = http.CanonicalHeaderKey("X-Cloud-Trace-Context")
curNamespaceHeader = http.CanonicalHeaderKey("X-AppEngine-Current-Namespace")
userIPHeader = http.CanonicalHeaderKey("X-AppEngine-User-IP")
remoteAddrHeader = http.CanonicalHeaderKey("X-AppEngine-Remote-Addr")
// Outgoing headers.
apiEndpointHeader = http.CanonicalHeaderKey("X-Google-RPC-Service-Endpoint")
apiEndpointHeaderValue = []string{"app-engine-apis"}
apiMethodHeader = http.CanonicalHeaderKey("X-Google-RPC-Service-Method")
apiMethodHeaderValue = []string{"/VMRemoteAPI.CallRemoteAPI"}
apiDeadlineHeader = http.CanonicalHeaderKey("X-Google-RPC-Service-Deadline")
apiContentType = http.CanonicalHeaderKey("Content-Type")
apiContentTypeValue = []string{"application/octet-stream"}
logFlushHeader = http.CanonicalHeaderKey("X-AppEngine-Log-Flush-Count")
apiHTTPClient = &http.Client{
Transport: &http.Transport{
Proxy: http.ProxyFromEnvironment,
Dial: limitDial,
},
}
)
func apiURL() *url.URL {
host, port := "appengine.googleapis.internal", "10001"
if h := os.Getenv("API_HOST"); h != "" {
host = h
}
if p := os.Getenv("API_PORT"); p != "" {
port = p
}
return &url.URL{
Scheme: "http",
Host: host + ":" + port,
Path: apiPath,
}
}
func handleHTTP(w http.ResponseWriter, r *http.Request) {
c := &context{
req: r,
outHeader: w.Header(),
apiURL: apiURL(),
}
stopFlushing := make(chan int)
ctxs.Lock()
ctxs.m[r] = c
ctxs.Unlock()
defer func() {
ctxs.Lock()
delete(ctxs.m, r)
ctxs.Unlock()
}()
// Patch up RemoteAddr so it looks reasonable.
if addr := r.Header.Get(userIPHeader); addr != "" {
r.RemoteAddr = addr
} else if addr = r.Header.Get(remoteAddrHeader); addr != "" {
r.RemoteAddr = addr
} else {
// Should not normally reach here, but pick a sensible default anyway.
r.RemoteAddr = "127.0.0.1"
}
// The address in the headers will most likely be of these forms:
// 123.123.123.123
// 2001:db8::1
// net/http.Request.RemoteAddr is specified to be in "IP:port" form.
if _, _, err := net.SplitHostPort(r.RemoteAddr); err != nil {
// Assume the remote address is only a host; add a default port.
r.RemoteAddr = net.JoinHostPort(r.RemoteAddr, "80")
}
// Start goroutine responsible for flushing app logs.
// This is done after adding c to ctx.m (and stopped before removing it)
// because flushing logs requires making an API call.
go c.logFlusher(stopFlushing)
executeRequestSafely(c, r)
c.outHeader = nil // make sure header changes aren't respected any more
stopFlushing <- 1 // any logging beyond this point will be dropped
// Flush any pending logs asynchronously.
c.pendingLogs.Lock()
flushes := c.pendingLogs.flushes
if len(c.pendingLogs.lines) > 0 {
flushes++
}
c.pendingLogs.Unlock()
go c.flushLog(false)
w.Header().Set(logFlushHeader, strconv.Itoa(flushes))
// Avoid nil Write call if c.Write is never called.
if c.outCode != 0 {
w.WriteHeader(c.outCode)
}
if c.outBody != nil {
w.Write(c.outBody)
}
}
func executeRequestSafely(c *context, r *http.Request) {
defer func() {
if x := recover(); x != nil {
logf(c, 4, "%s", renderPanic(x)) // 4 == critical
c.outCode = 500
}
}()
http.DefaultServeMux.ServeHTTP(c, r)
}
func renderPanic(x interface{}) string {
buf := make([]byte, 16<<10) // 16 KB should be plenty
buf = buf[:runtime.Stack(buf, false)]
// Remove the first few stack frames:
// this func
// the recover closure in the caller
// That will root the stack trace at the site of the panic.
const (
skipStart = "internal.renderPanic"
skipFrames = 2
)
start := bytes.Index(buf, []byte(skipStart))
p := start
for i := 0; i < skipFrames*2 && p+1 < len(buf); i++ {
p = bytes.IndexByte(buf[p+1:], '\n') + p + 1
if p < 0 {
break
}
}
if p >= 0 {
// buf[start:p+1] is the block to remove.
// Copy buf[p+1:] over buf[start:] and shrink buf.
copy(buf[start:], buf[p+1:])
buf = buf[:len(buf)-(p+1-start)]
}
// Add panic heading.
head := fmt.Sprintf("panic: %v\n\n", x)
if len(head) > len(buf) {
// Extremely unlikely to happen.
return head
}
copy(buf[len(head):], buf)
copy(buf, head)
return string(buf)
}
var ctxs = struct {
sync.Mutex
m map[*http.Request]*context
bg *context // background context, lazily initialized
// dec is used by tests to decorate the netcontext.Context returned
// for a given request. This allows tests to add overrides (such as
// WithAppIDOverride) to the context. The map is nil outside tests.
dec map[*http.Request]func(netcontext.Context) netcontext.Context
}{
m: make(map[*http.Request]*context),
}
// context represents the context of an in-flight HTTP request.
// It implements the appengine.Context and http.ResponseWriter interfaces.
type context struct {
req *http.Request
outCode int
outHeader http.Header
outBody []byte
pendingLogs struct {
sync.Mutex
lines []*logpb.UserAppLogLine
flushes int
}
apiURL *url.URL
}
var contextKey = "holds a *context"
func fromContext(ctx netcontext.Context) *context {
c, _ := ctx.Value(&contextKey).(*context)
return c
}
func withContext(parent netcontext.Context, c *context) netcontext.Context {
ctx := netcontext.WithValue(parent, &contextKey, c)
if ns := c.req.Header.Get(curNamespaceHeader); ns != "" {
ctx = withNamespace(ctx, ns)
}
return ctx
}
func toContext(c *context) netcontext.Context {
return withContext(netcontext.Background(), c)
}
func IncomingHeaders(ctx netcontext.Context) http.Header {
if c := fromContext(ctx); c != nil {
return c.req.Header
}
return nil
}
func WithContext(parent netcontext.Context, req *http.Request) netcontext.Context {
ctxs.Lock()
c := ctxs.m[req]
d := ctxs.dec[req]
ctxs.Unlock()
if d != nil {
parent = d(parent)
}
if c == nil {
// Someone passed in an http.Request that is not in-flight.
// We panic here rather than panicking at a later point
// so that stack traces will be more sensible.
log.Panic("appengine: NewContext passed an unknown http.Request")
}
return withContext(parent, c)
}
func BackgroundContext() netcontext.Context {
ctxs.Lock()
defer ctxs.Unlock()
if ctxs.bg != nil {
return toContext(ctxs.bg)
}
// Compute background security ticket.
appID := partitionlessAppID()
escAppID := strings.Replace(strings.Replace(appID, ":", "_", -1), ".", "_", -1)
majVersion := VersionID(nil)
if i := strings.Index(majVersion, "."); i > 0 {
majVersion = majVersion[:i]
}
ticket := fmt.Sprintf("%s/%s.%s.%s", escAppID, ModuleName(nil), majVersion, InstanceID())
ctxs.bg = &context{
req: &http.Request{
Header: http.Header{
ticketHeader: []string{ticket},
},
},
apiURL: apiURL(),
}
// TODO(dsymonds): Wire up the shutdown handler to do a final flush.
go ctxs.bg.logFlusher(make(chan int))
return toContext(ctxs.bg)
}
// RegisterTestRequest registers the HTTP request req for testing, such that
// any API calls are sent to the provided URL. It returns a closure to delete
// the registration.
// It should only be used by aetest package.
func RegisterTestRequest(req *http.Request, apiURL *url.URL, decorate func(netcontext.Context) netcontext.Context) func() {
c := &context{
req: req,
apiURL: apiURL,
}
ctxs.Lock()
defer ctxs.Unlock()
if _, ok := ctxs.m[req]; ok {
log.Panic("req already associated with context")
}
if _, ok := ctxs.dec[req]; ok {
log.Panic("req already associated with context")
}
if ctxs.dec == nil {
ctxs.dec = make(map[*http.Request]func(netcontext.Context) netcontext.Context)
}
ctxs.m[req] = c
ctxs.dec[req] = decorate
return func() {
ctxs.Lock()
delete(ctxs.m, req)
delete(ctxs.dec, req)
ctxs.Unlock()
}
}
var errTimeout = &CallError{
Detail: "Deadline exceeded",
Code: int32(remotepb.RpcError_CANCELLED),
Timeout: true,
}
func (c *context) Header() http.Header { return c.outHeader }
// Copied from $GOROOT/src/pkg/net/http/transfer.go. Some response status
// codes do not permit a response body (nor response entity headers such as
// Content-Length, Content-Type, etc).
func bodyAllowedForStatus(status int) bool {
switch {
case status >= 100 && status <= 199:
return false
case status == 204:
return false
case status == 304:
return false
}
return true
}
func (c *context) Write(b []byte) (int, error) {
if c.outCode == 0 {
c.WriteHeader(http.StatusOK)
}
if len(b) > 0 && !bodyAllowedForStatus(c.outCode) {
return 0, http.ErrBodyNotAllowed
}
c.outBody = append(c.outBody, b...)
return len(b), nil
}
func (c *context) WriteHeader(code int) {
if c.outCode != 0 {
logf(c, 3, "WriteHeader called multiple times on request.") // error level
return
}
c.outCode = code
}
func (c *context) post(body []byte, timeout time.Duration) (b []byte, err error) {
hreq := &http.Request{
Method: "POST",
URL: c.apiURL,
Header: http.Header{
apiEndpointHeader: apiEndpointHeaderValue,
apiMethodHeader: apiMethodHeaderValue,
apiContentType: apiContentTypeValue,
apiDeadlineHeader: []string{strconv.FormatFloat(timeout.Seconds(), 'f', -1, 64)},
},
Body: ioutil.NopCloser(bytes.NewReader(body)),
ContentLength: int64(len(body)),
Host: c.apiURL.Host,
}
if info := c.req.Header.Get(dapperHeader); info != "" {
hreq.Header.Set(dapperHeader, info)
}
if info := c.req.Header.Get(traceHeader); info != "" {
hreq.Header.Set(traceHeader, info)
}
tr := apiHTTPClient.Transport.(*http.Transport)
var timedOut int32 // atomic; set to 1 if timed out
t := time.AfterFunc(timeout, func() {
atomic.StoreInt32(&timedOut, 1)
tr.CancelRequest(hreq)
})
defer t.Stop()
defer func() {
// Check if timeout was exceeded.
if atomic.LoadInt32(&timedOut) != 0 {
err = errTimeout
}
}()
hresp, err := apiHTTPClient.Do(hreq)
if err != nil {
return nil, &CallError{
Detail: fmt.Sprintf("service bridge HTTP failed: %v", err),
Code: int32(remotepb.RpcError_UNKNOWN),
}
}
defer hresp.Body.Close()
hrespBody, err := ioutil.ReadAll(hresp.Body)
if hresp.StatusCode != 200 {
return nil, &CallError{
Detail: fmt.Sprintf("service bridge returned HTTP %d (%q)", hresp.StatusCode, hrespBody),
Code: int32(remotepb.RpcError_UNKNOWN),
}
}
if err != nil {
return nil, &CallError{
Detail: fmt.Sprintf("service bridge response bad: %v", err),
Code: int32(remotepb.RpcError_UNKNOWN),
}
}
return hrespBody, nil
}
func Call(ctx netcontext.Context, service, method string, in, out proto.Message) error {
if f, ctx, ok := callOverrideFromContext(ctx); ok {
return f(ctx, service, method, in, out)
}
// Handle already-done contexts quickly.
select {
case <-ctx.Done():
return ctx.Err()
default:
}
c := fromContext(ctx)
if c == nil {
// Give a good error message rather than a panic lower down.
return errors.New("not an App Engine context")
}
// Apply transaction modifications if we're in a transaction.
if t := transactionFromContext(ctx); t != nil {
if t.finished {
return errors.New("transaction context has expired")
}
applyTransaction(in, &t.transaction)
}
// Default RPC timeout is 60s.
timeout := 60 * time.Second
if deadline, ok := ctx.Deadline(); ok {
timeout = deadline.Sub(time.Now())
}
data, err := proto.Marshal(in)
if err != nil {
return err
}
ticket := c.req.Header.Get(ticketHeader)
req := &remotepb.Request{
ServiceName: &service,
Method: &method,
Request: data,
RequestId: &ticket,
}
hreqBody, err := proto.Marshal(req)
if err != nil {
return err
}
hrespBody, err := c.post(hreqBody, timeout)
if err != nil {
return err
}
res := &remotepb.Response{}
if err := proto.Unmarshal(hrespBody, res); err != nil {
return err
}
if res.RpcError != nil {
ce := &CallError{
Detail: res.RpcError.GetDetail(),
Code: *res.RpcError.Code,
}
switch remotepb.RpcError_ErrorCode(ce.Code) {
case remotepb.RpcError_CANCELLED, remotepb.RpcError_DEADLINE_EXCEEDED:
ce.Timeout = true
}
return ce
}
if res.ApplicationError != nil {
return &APIError{
Service: *req.ServiceName,
Detail: res.ApplicationError.GetDetail(),
Code: *res.ApplicationError.Code,
}
}
if res.Exception != nil || res.JavaException != nil {
// This shouldn't happen, but let's be defensive.
return &CallError{
Detail: "service bridge returned exception",
Code: int32(remotepb.RpcError_UNKNOWN),
}
}
return proto.Unmarshal(res.Response, out)
}
func (c *context) Request() *http.Request {
return c.req
}
func (c *context) addLogLine(ll *logpb.UserAppLogLine) {
// Truncate long log lines.
// TODO(dsymonds): Check if this is still necessary.
const lim = 8 << 10
if len(*ll.Message) > lim {
suffix := fmt.Sprintf("...(length %d)", len(*ll.Message))
ll.Message = proto.String((*ll.Message)[:lim-len(suffix)] + suffix)
}
c.pendingLogs.Lock()
c.pendingLogs.lines = append(c.pendingLogs.lines, ll)
c.pendingLogs.Unlock()
}
var logLevelName = map[int64]string{
0: "DEBUG",
1: "INFO",
2: "WARNING",
3: "ERROR",
4: "CRITICAL",
}
func logf(c *context, level int64, format string, args ...interface{}) {
s := fmt.Sprintf(format, args...)
s = strings.TrimRight(s, "\n") // Remove any trailing newline characters.
c.addLogLine(&logpb.UserAppLogLine{
TimestampUsec: proto.Int64(time.Now().UnixNano() / 1e3),
Level: &level,
Message: &s,
})
log.Print(logLevelName[level] + ": " + s)
}
// flushLog attempts to flush any pending logs to the appserver.
// It should not be called concurrently.
func (c *context) flushLog(force bool) (flushed bool) {
c.pendingLogs.Lock()
// Grab up to 30 MB. We can get away with up to 32 MB, but let's be cautious.
n, rem := 0, 30<<20
for ; n < len(c.pendingLogs.lines); n++ {
ll := c.pendingLogs.lines[n]
// Each log line will require about 3 bytes of overhead.
nb := proto.Size(ll) + 3
if nb > rem {
break
}
rem -= nb
}
lines := c.pendingLogs.lines[:n]
c.pendingLogs.lines = c.pendingLogs.lines[n:]
c.pendingLogs.Unlock()
if len(lines) == 0 && !force {
// Nothing to flush.
return false
}
rescueLogs := false
defer func() {
if rescueLogs {
c.pendingLogs.Lock()
c.pendingLogs.lines = append(lines, c.pendingLogs.lines...)
c.pendingLogs.Unlock()
}
}()
buf, err := proto.Marshal(&logpb.UserAppLogGroup{
LogLine: lines,
})
if err != nil {
log.Printf("internal.flushLog: marshaling UserAppLogGroup: %v", err)
rescueLogs = true
return false
}
req := &logpb.FlushRequest{
Logs: buf,
}
res := &basepb.VoidProto{}
c.pendingLogs.Lock()
c.pendingLogs.flushes++
c.pendingLogs.Unlock()
if err := Call(toContext(c), "logservice", "Flush", req, res); err != nil {
log.Printf("internal.flushLog: Flush RPC: %v", err)
rescueLogs = true
return false
}
return true
}
const (
// Log flushing parameters.
flushInterval = 1 * time.Second
forceFlushInterval = 60 * time.Second
)
func (c *context) logFlusher(stop <-chan int) {
lastFlush := time.Now()
tick := time.NewTicker(flushInterval)
for {
select {
case <-stop:
// Request finished.
tick.Stop()
return
case <-tick.C:
force := time.Now().Sub(lastFlush) > forceFlushInterval
if c.flushLog(force) {
lastFlush = time.Now()
}
}
}
}
func ContextForTesting(req *http.Request) netcontext.Context {
return toContext(&context{req: req})
}
================================================
FILE: vendor/google.golang.org/appengine/internal/api_classic.go
================================================
// Copyright 2015 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
// +build appengine
package internal
import (
"errors"
"net/http"
"time"
"appengine"
"appengine_internal"
basepb "appengine_internal/base"
"github.com/golang/protobuf/proto"
netcontext "golang.org/x/net/context"
)
var contextKey = "holds an appengine.Context"
func fromContext(ctx netcontext.Context) appengine.Context {
c, _ := ctx.Value(&contextKey).(appengine.Context)
return c
}
// This is only for classic App Engine adapters.
func ClassicContextFromContext(ctx netcontext.Context) appengine.Context {
return fromContext(ctx)
}
func withContext(parent netcontext.Context, c appengine.Context) netcontext.Context {
ctx := netcontext.WithValue(parent, &contextKey, c)
s := &basepb.StringProto{}
c.Call("__go__", "GetNamespace", &basepb.VoidProto{}, s, nil)
if ns := s.GetValue(); ns != "" {
ctx = NamespacedContext(ctx, ns)
}
return ctx
}
func IncomingHeaders(ctx netcontext.Context) http.Header {
if c := fromContext(ctx); c != nil {
if req, ok := c.Request().(*http.Request); ok {
return req.Header
}
}
return nil
}
func WithContext(parent netcontext.Context, req *http.Request) netcontext.Context {
c := appengine.NewContext(req)
return withContext(parent, c)
}
func Call(ctx netcontext.Context, service, method string, in, out proto.Message) error {
if f, ctx, ok := callOverrideFromContext(ctx); ok {
return f(ctx, service, method, in, out)
}
// Handle already-done contexts quickly.
select {
case <-ctx.Done():
return ctx.Err()
default:
}
c := fromContext(ctx)
if c == nil {
// Give a good error message rather than a panic lower down.
return errors.New("not an App Engine context")
}
// Apply transaction modifications if we're in a transaction.
if t := transactionFromContext(ctx); t != nil {
if t.finished {
return errors.New("transaction context has expired")
}
applyTransaction(in, &t.transaction)
}
var opts *appengine_internal.CallOptions
if d, ok := ctx.Deadline(); ok {
opts = &appengine_internal.CallOptions{
Timeout: d.Sub(time.Now()),
}
}
err := c.Call(service, method, in, out, opts)
switch v := err.(type) {
case *appengine_internal.APIError:
return &APIError{
Service: v.Service,
Detail: v.Detail,
Code: v.Code,
}
case *appengine_internal.CallError:
return &CallError{
Detail: v.Detail,
Code: v.Code,
Timeout: v.Timeout,
}
}
return err
}
func handleHTTP(w http.ResponseWriter, r *http.Request) {
panic("handleHTTP called; this should be impossible")
}
func logf(c appengine.Context, level int64, format string, args ...interface{}) {
var fn func(format string, args ...interface{})
switch level {
case 0:
fn = c.Debugf
case 1:
fn = c.Infof
case 2:
fn = c.Warningf
case 3:
fn = c.Errorf
case 4:
fn = c.Criticalf
default:
// This shouldn't happen.
fn = c.Criticalf
}
fn(format, args...)
}
================================================
FILE: vendor/google.golang.org/appengine/internal/api_common.go
================================================
// Copyright 2015 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
package internal
import (
"github.com/golang/protobuf/proto"
netcontext "golang.org/x/net/context"
)
type CallOverrideFunc func(ctx netcontext.Context, service, method string, in, out proto.Message) error
var callOverrideKey = "holds []CallOverrideFunc"
func WithCallOverride(ctx netcontext.Context, f CallOverrideFunc) netcontext.Context {
// We avoid appending to any existing call override
// so we don't risk overwriting a popped stack below.
var cofs []CallOverrideFunc
if uf, ok := ctx.Value(&callOverrideKey).([]CallOverrideFunc); ok {
cofs = append(cofs, uf...)
}
cofs = append(cofs, f)
return netcontext.WithValue(ctx, &callOverrideKey, cofs)
}
func callOverrideFromContext(ctx netcontext.Context) (CallOverrideFunc, netcontext.Context, bool) {
cofs, _ := ctx.Value(&callOverrideKey).([]CallOverrideFunc)
if len(cofs) == 0 {
return nil, nil, false
}
// We found a list of overrides; grab the last, and reconstitute a
// context that will hide it.
f := cofs[len(cofs)-1]
ctx = netcontext.WithValue(ctx, &callOverrideKey, cofs[:len(cofs)-1])
return f, ctx, true
}
type logOverrideFunc func(level int64, format string, args ...interface{})
var logOverrideKey = "holds a logOverrideFunc"
func WithLogOverride(ctx netcontext.Context, f logOverrideFunc) netcontext.Context {
return netcontext.WithValue(ctx, &logOverrideKey, f)
}
var appIDOverrideKey = "holds a string, being the full app ID"
func WithAppIDOverride(ctx netcontext.Context, appID string) netcontext.Context {
return netcontext.WithValue(ctx, &appIDOverrideKey, appID)
}
var namespaceKey = "holds the namespace string"
func withNamespace(ctx netcontext.Context, ns string) netcontext.Context {
return netcontext.WithValue(ctx, &namespaceKey, ns)
}
func NamespaceFromContext(ctx netcontext.Context) string {
// If there's no namespace, return the empty string.
ns, _ := ctx.Value(&namespaceKey).(string)
return ns
}
// FullyQualifiedAppID returns the fully-qualified application ID.
// This may contain a partition prefix (e.g. "s~" for High Replication apps),
// or a domain prefix (e.g. "example.com:").
func FullyQualifiedAppID(ctx netcontext.Context) string {
if id, ok := ctx.Value(&appIDOverrideKey).(string); ok {
return id
}
return fullyQualifiedAppID(ctx)
}
func Logf(ctx netcontext.Context, level int64, format string, args ...interface{}) {
if f, ok := ctx.Value(&logOverrideKey).(logOverrideFunc); ok {
f(level, format, args...)
return
}
logf(fromContext(ctx), level, format, args...)
}
// NamespacedContext wraps a Context to support namespaces.
func NamespacedContext(ctx netcontext.Context, namespace string) netcontext.Context {
n := &namespacedContext{
namespace: namespace,
}
return withNamespace(WithCallOverride(ctx, n.call), namespace)
}
type namespacedContext struct {
namespace string
}
func (n *namespacedContext) call(ctx netcontext.Context, service, method string, in, out proto.Message) error {
// Apply any namespace mods.
if mod, ok := NamespaceMods[service]; ok {
mod(in, n.namespace)
}
return Call(ctx, service, method, in, out)
}
================================================
FILE: vendor/google.golang.org/appengine/internal/app_id.go
================================================
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
package internal
import (
"strings"
)
func parseFullAppID(appid string) (partition, domain, displayID string) {
if i := strings.Index(appid, "~"); i != -1 {
partition, appid = appid[:i], appid[i+1:]
}
if i := strings.Index(appid, ":"); i != -1 {
domain, appid = appid[:i], appid[i+1:]
}
return partition, domain, appid
}
// appID returns "appid" or "domain.com:appid".
func appID(fullAppID string) string {
_, dom, dis := parseFullAppID(fullAppID)
if dom != "" {
return dom + ":" + dis
}
return dis
}
================================================
FILE: vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.pb.go
================================================
// Code generated by protoc-gen-go.
// source: google.golang.org/appengine/internal/app_identity/app_identity_service.proto
// DO NOT EDIT!
/*
Package app_identity is a generated protocol buffer package.
It is generated from these files:
google.golang.org/appengine/internal/app_identity/app_identity_service.proto
It has these top-level messages:
AppIdentityServiceError
SignForAppRequest
SignForAppResponse
GetPublicCertificateForAppRequest
PublicCertificate
GetPublicCertificateForAppResponse
GetServiceAccountNameRequest
GetServiceAccountNameResponse
GetAccessTokenRequest
GetAccessTokenResponse
GetDefaultGcsBucketNameRequest
GetDefaultGcsBucketNameResponse
*/
package app_identity
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type AppIdentityServiceError_ErrorCode int32
const (
AppIdentityServiceError_SUCCESS AppIdentityServiceError_ErrorCode = 0
AppIdentityServiceError_UNKNOWN_SCOPE AppIdentityServiceError_ErrorCode = 9
AppIdentityServiceError_BLOB_TOO_LARGE AppIdentityServiceError_ErrorCode = 1000
AppIdentityServiceError_DEADLINE_EXCEEDED AppIdentityServiceError_ErrorCode = 1001
AppIdentityServiceError_NOT_A_VALID_APP AppIdentityServiceError_ErrorCode = 1002
AppIdentityServiceError_UNKNOWN_ERROR AppIdentityServiceError_ErrorCode = 1003
AppIdentityServiceError_NOT_ALLOWED AppIdentityServiceError_ErrorCode = 1005
AppIdentityServiceError_NOT_IMPLEMENTED AppIdentityServiceError_ErrorCode = 1006
)
var AppIdentityServiceError_ErrorCode_name = map[int32]string{
0: "SUCCESS",
9: "UNKNOWN_SCOPE",
1000: "BLOB_TOO_LARGE",
1001: "DEADLINE_EXCEEDED",
1002: "NOT_A_VALID_APP",
1003: "UNKNOWN_ERROR",
1005: "NOT_ALLOWED",
1006: "NOT_IMPLEMENTED",
}
var AppIdentityServiceError_ErrorCode_value = map[string]int32{
"SUCCESS": 0,
"UNKNOWN_SCOPE": 9,
"BLOB_TOO_LARGE": 1000,
"DEADLINE_EXCEEDED": 1001,
"NOT_A_VALID_APP": 1002,
"UNKNOWN_ERROR": 1003,
"NOT_ALLOWED": 1005,
"NOT_IMPLEMENTED": 1006,
}
func (x AppIdentityServiceError_ErrorCode) Enum() *AppIdentityServiceError_ErrorCode {
p := new(AppIdentityServiceError_ErrorCode)
*p = x
return p
}
func (x AppIdentityServiceError_ErrorCode) String() string {
return proto.EnumName(AppIdentityServiceError_ErrorCode_name, int32(x))
}
func (x *AppIdentityServiceError_ErrorCode) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(AppIdentityServiceError_ErrorCode_value, data, "AppIdentityServiceError_ErrorCode")
if err != nil {
return err
}
*x = AppIdentityServiceError_ErrorCode(value)
return nil
}
type AppIdentityServiceError struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *AppIdentityServiceError) Reset() { *m = AppIdentityServiceError{} }
func (m *AppIdentityServiceError) String() string { return proto.CompactTextString(m) }
func (*AppIdentityServiceError) ProtoMessage() {}
type SignForAppRequest struct {
BytesToSign []byte `protobuf:"bytes,1,opt,name=bytes_to_sign" json:"bytes_to_sign,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *SignForAppRequest) Reset() { *m = SignForAppRequest{} }
func (m *SignForAppRequest) String() string { return proto.CompactTextString(m) }
func (*SignForAppRequest) ProtoMessage() {}
func (m *SignForAppRequest) GetBytesToSign() []byte {
if m != nil {
return m.BytesToSign
}
return nil
}
type SignForAppResponse struct {
KeyName *string `protobuf:"bytes,1,opt,name=key_name" json:"key_name,omitempty"`
SignatureBytes []byte `protobuf:"bytes,2,opt,name=signature_bytes" json:"signature_bytes,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *SignForAppResponse) Reset() { *m = SignForAppResponse{} }
func (m *SignForAppResponse) String() string { return proto.CompactTextString(m) }
func (*SignForAppResponse) ProtoMessage() {}
func (m *SignForAppResponse) GetKeyName() string {
if m != nil && m.KeyName != nil {
return *m.KeyName
}
return ""
}
func (m *SignForAppResponse) GetSignatureBytes() []byte {
if m != nil {
return m.SignatureBytes
}
return nil
}
type GetPublicCertificateForAppRequest struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *GetPublicCertificateForAppRequest) Reset() { *m = GetPublicCertificateForAppRequest{} }
func (m *GetPublicCertificateForAppRequest) String() string { return proto.CompactTextString(m) }
func (*GetPublicCertificateForAppRequest) ProtoMessage() {}
type PublicCertificate struct {
KeyName *string `protobuf:"bytes,1,opt,name=key_name" json:"key_name,omitempty"`
X509CertificatePem *string `protobuf:"bytes,2,opt,name=x509_certificate_pem" json:"x509_certificate_pem,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *PublicCertificate) Reset() { *m = PublicCertificate{} }
func (m *PublicCertificate) String() string { return proto.CompactTextString(m) }
func (*PublicCertificate) ProtoMessage() {}
func (m *PublicCertificate) GetKeyName() string {
if m != nil && m.KeyName != nil {
return *m.KeyName
}
return ""
}
func (m *PublicCertificate) GetX509CertificatePem() string {
if m != nil && m.X509CertificatePem != nil {
return *m.X509CertificatePem
}
return ""
}
type GetPublicCertificateForAppResponse struct {
PublicCertificateList []*PublicCertificate `protobuf:"bytes,1,rep,name=public_certificate_list" json:"public_certificate_list,omitempty"`
MaxClientCacheTimeInSecond *int64 `protobuf:"varint,2,opt,name=max_client_cache_time_in_second" json:"max_client_cache_time_in_second,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetPublicCertificateForAppResponse) Reset() { *m = GetPublicCertificateForAppResponse{} }
func (m *GetPublicCertificateForAppResponse) String() string { return proto.CompactTextString(m) }
func (*GetPublicCertificateForAppResponse) ProtoMessage() {}
func (m *GetPublicCertificateForAppResponse) GetPublicCertificateList() []*PublicCertificate {
if m != nil {
return m.PublicCertificateList
}
return nil
}
func (m *GetPublicCertificateForAppResponse) GetMaxClientCacheTimeInSecond() int64 {
if m != nil && m.MaxClientCacheTimeInSecond != nil {
return *m.MaxClientCacheTimeInSecond
}
return 0
}
type GetServiceAccountNameRequest struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *GetServiceAccountNameRequest) Reset() { *m = GetServiceAccountNameRequest{} }
func (m *GetServiceAccountNameRequest) String() string { return proto.CompactTextString(m) }
func (*GetServiceAccountNameRequest) ProtoMessage() {}
type GetServiceAccountNameResponse struct {
ServiceAccountName *string `protobuf:"bytes,1,opt,name=service_account_name" json:"service_account_name,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetServiceAccountNameResponse) Reset() { *m = GetServiceAccountNameResponse{} }
func (m *GetServiceAccountNameResponse) String() string { return proto.CompactTextString(m) }
func (*GetServiceAccountNameResponse) ProtoMessage() {}
func (m *GetServiceAccountNameResponse) GetServiceAccountName() string {
if m != nil && m.ServiceAccountName != nil {
return *m.ServiceAccountName
}
return ""
}
type GetAccessTokenRequest struct {
Scope []string `protobuf:"bytes,1,rep,name=scope" json:"scope,omitempty"`
ServiceAccountId *int64 `protobuf:"varint,2,opt,name=service_account_id" json:"service_account_id,omitempty"`
ServiceAccountName *string `protobuf:"bytes,3,opt,name=service_account_name" json:"service_account_name,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetAccessTokenRequest) Reset() { *m = GetAccessTokenRequest{} }
func (m *GetAccessTokenRequest) String() string { return proto.CompactTextString(m) }
func (*GetAccessTokenRequest) ProtoMessage() {}
func (m *GetAccessTokenRequest) GetScope() []string {
if m != nil {
return m.Scope
}
return nil
}
func (m *GetAccessTokenRequest) GetServiceAccountId() int64 {
if m != nil && m.ServiceAccountId != nil {
return *m.ServiceAccountId
}
return 0
}
func (m *GetAccessTokenRequest) GetServiceAccountName() string {
if m != nil && m.ServiceAccountName != nil {
return *m.ServiceAccountName
}
return ""
}
type GetAccessTokenResponse struct {
AccessToken *string `protobuf:"bytes,1,opt,name=access_token" json:"access_token,omitempty"`
ExpirationTime *int64 `protobuf:"varint,2,opt,name=expiration_time" json:"expiration_time,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetAccessTokenResponse) Reset() { *m = GetAccessTokenResponse{} }
func (m *GetAccessTokenResponse) String() string { return proto.CompactTextString(m) }
func (*GetAccessTokenResponse) ProtoMessage() {}
func (m *GetAccessTokenResponse) GetAccessToken() string {
if m != nil && m.AccessToken != nil {
return *m.AccessToken
}
return ""
}
func (m *GetAccessTokenResponse) GetExpirationTime() int64 {
if m != nil && m.ExpirationTime != nil {
return *m.ExpirationTime
}
return 0
}
type GetDefaultGcsBucketNameRequest struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *GetDefaultGcsBucketNameRequest) Reset() { *m = GetDefaultGcsBucketNameRequest{} }
func (m *GetDefaultGcsBucketNameRequest) String() string { return proto.CompactTextString(m) }
func (*GetDefaultGcsBucketNameRequest) ProtoMessage() {}
type GetDefaultGcsBucketNameResponse struct {
DefaultGcsBucketName *string `protobuf:"bytes,1,opt,name=default_gcs_bucket_name" json:"default_gcs_bucket_name,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetDefaultGcsBucketNameResponse) Reset() { *m = GetDefaultGcsBucketNameResponse{} }
func (m *GetDefaultGcsBucketNameResponse) String() string { return proto.CompactTextString(m) }
func (*GetDefaultGcsBucketNameResponse) ProtoMessage() {}
func (m *GetDefaultGcsBucketNameResponse) GetDefaultGcsBucketName() string {
if m != nil && m.DefaultGcsBucketName != nil {
return *m.DefaultGcsBucketName
}
return ""
}
func init() {
}
================================================
FILE: vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.proto
================================================
syntax = "proto2";
option go_package = "app_identity";
package appengine;
message AppIdentityServiceError {
enum ErrorCode {
SUCCESS = 0;
UNKNOWN_SCOPE = 9;
BLOB_TOO_LARGE = 1000;
DEADLINE_EXCEEDED = 1001;
NOT_A_VALID_APP = 1002;
UNKNOWN_ERROR = 1003;
NOT_ALLOWED = 1005;
NOT_IMPLEMENTED = 1006;
}
}
message SignForAppRequest {
optional bytes bytes_to_sign = 1;
}
message SignForAppResponse {
optional string key_name = 1;
optional bytes signature_bytes = 2;
}
message GetPublicCertificateForAppRequest {
}
message PublicCertificate {
optional string key_name = 1;
optional string x509_certificate_pem = 2;
}
message GetPublicCertificateForAppResponse {
repeated PublicCertificate public_certificate_list = 1;
optional int64 max_client_cache_time_in_second = 2;
}
message GetServiceAccountNameRequest {
}
message GetServiceAccountNameResponse {
optional string service_account_name = 1;
}
message GetAccessTokenRequest {
repeated string scope = 1;
optional int64 service_account_id = 2;
optional string service_account_name = 3;
}
message GetAccessTokenResponse {
optional string access_token = 1;
optional int64 expiration_time = 2;
}
message GetDefaultGcsBucketNameRequest {
}
message GetDefaultGcsBucketNameResponse {
optional string default_gcs_bucket_name = 1;
}
================================================
FILE: vendor/google.golang.org/appengine/internal/base/api_base.pb.go
================================================
// Code generated by protoc-gen-go.
// source: google.golang.org/appengine/internal/base/api_base.proto
// DO NOT EDIT!
/*
Package base is a generated protocol buffer package.
It is generated from these files:
google.golang.org/appengine/internal/base/api_base.proto
It has these top-level messages:
StringProto
Integer32Proto
Integer64Proto
BoolProto
DoubleProto
BytesProto
VoidProto
*/
package base
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type StringProto struct {
Value *string `protobuf:"bytes,1,req,name=value" json:"value,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *StringProto) Reset() { *m = StringProto{} }
func (m *StringProto) String() string { return proto.CompactTextString(m) }
func (*StringProto) ProtoMessage() {}
func (m *StringProto) GetValue() string {
if m != nil && m.Value != nil {
return *m.Value
}
return ""
}
type Integer32Proto struct {
Value *int32 `protobuf:"varint,1,req,name=value" json:"value,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Integer32Proto) Reset() { *m = Integer32Proto{} }
func (m *Integer32Proto) String() string { return proto.CompactTextString(m) }
func (*Integer32Proto) ProtoMessage() {}
func (m *Integer32Proto) GetValue() int32 {
if m != nil && m.Value != nil {
return *m.Value
}
return 0
}
type Integer64Proto struct {
Value *int64 `protobuf:"varint,1,req,name=value" json:"value,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Integer64Proto) Reset() { *m = Integer64Proto{} }
func (m *Integer64Proto) String() string { return proto.CompactTextString(m) }
func (*Integer64Proto) ProtoMessage() {}
func (m *Integer64Proto) GetValue() int64 {
if m != nil && m.Value != nil {
return *m.Value
}
return 0
}
type BoolProto struct {
Value *bool `protobuf:"varint,1,req,name=value" json:"value,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *BoolProto) Reset() { *m = BoolProto{} }
func (m *BoolProto) String() string { return proto.CompactTextString(m) }
func (*BoolProto) ProtoMessage() {}
func (m *BoolProto) GetValue() bool {
if m != nil && m.Value != nil {
return *m.Value
}
return false
}
type DoubleProto struct {
Value *float64 `protobuf:"fixed64,1,req,name=value" json:"value,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *DoubleProto) Reset() { *m = DoubleProto{} }
func (m *DoubleProto) String() string { return proto.CompactTextString(m) }
func (*DoubleProto) ProtoMessage() {}
func (m *DoubleProto) GetValue() float64 {
if m != nil && m.Value != nil {
return *m.Value
}
return 0
}
type BytesProto struct {
Value []byte `protobuf:"bytes,1,req,name=value" json:"value,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *BytesProto) Reset() { *m = BytesProto{} }
func (m *BytesProto) String() string { return proto.CompactTextString(m) }
func (*BytesProto) ProtoMessage() {}
func (m *BytesProto) GetValue() []byte {
if m != nil {
return m.Value
}
return nil
}
type VoidProto struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *VoidProto) Reset() { *m = VoidProto{} }
func (m *VoidProto) String() string { return proto.CompactTextString(m) }
func (*VoidProto) ProtoMessage() {}
================================================
FILE: vendor/google.golang.org/appengine/internal/base/api_base.proto
================================================
// Built-in base types for API calls. Primarily useful as return types.
syntax = "proto2";
option go_package = "base";
package appengine.base;
message StringProto {
required string value = 1;
}
message Integer32Proto {
required int32 value = 1;
}
message Integer64Proto {
required int64 value = 1;
}
message BoolProto {
required bool value = 1;
}
message DoubleProto {
required double value = 1;
}
message BytesProto {
required bytes value = 1 [ctype=CORD];
}
message VoidProto {
}
================================================
FILE: vendor/google.golang.org/appengine/internal/blobstore/blobstore_service.pb.go
================================================
// Code generated by protoc-gen-go.
// source: google.golang.org/appengine/internal/blobstore/blobstore_service.proto
// DO NOT EDIT!
/*
Package blobstore is a generated protocol buffer package.
It is generated from these files:
google.golang.org/appengine/internal/blobstore/blobstore_service.proto
It has these top-level messages:
BlobstoreServiceError
CreateUploadURLRequest
CreateUploadURLResponse
DeleteBlobRequest
FetchDataRequest
FetchDataResponse
CloneBlobRequest
CloneBlobResponse
DecodeBlobKeyRequest
DecodeBlobKeyResponse
CreateEncodedGoogleStorageKeyRequest
CreateEncodedGoogleStorageKeyResponse
*/
package blobstore
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type BlobstoreServiceError_ErrorCode int32
const (
BlobstoreServiceError_OK BlobstoreServiceError_ErrorCode = 0
BlobstoreServiceError_INTERNAL_ERROR BlobstoreServiceError_ErrorCode = 1
BlobstoreServiceError_URL_TOO_LONG BlobstoreServiceError_ErrorCode = 2
BlobstoreServiceError_PERMISSION_DENIED BlobstoreServiceError_ErrorCode = 3
BlobstoreServiceError_BLOB_NOT_FOUND BlobstoreServiceError_ErrorCode = 4
BlobstoreServiceError_DATA_INDEX_OUT_OF_RANGE BlobstoreServiceError_ErrorCode = 5
BlobstoreServiceError_BLOB_FETCH_SIZE_TOO_LARGE BlobstoreServiceError_ErrorCode = 6
BlobstoreServiceError_ARGUMENT_OUT_OF_RANGE BlobstoreServiceError_ErrorCode = 8
BlobstoreServiceError_INVALID_BLOB_KEY BlobstoreServiceError_ErrorCode = 9
)
var BlobstoreServiceError_ErrorCode_name = map[int32]string{
0: "OK",
1: "INTERNAL_ERROR",
2: "URL_TOO_LONG",
3: "PERMISSION_DENIED",
4: "BLOB_NOT_FOUND",
5: "DATA_INDEX_OUT_OF_RANGE",
6: "BLOB_FETCH_SIZE_TOO_LARGE",
8: "ARGUMENT_OUT_OF_RANGE",
9: "INVALID_BLOB_KEY",
}
var BlobstoreServiceError_ErrorCode_value = map[string]int32{
"OK": 0,
"INTERNAL_ERROR": 1,
"URL_TOO_LONG": 2,
"PERMISSION_DENIED": 3,
"BLOB_NOT_FOUND": 4,
"DATA_INDEX_OUT_OF_RANGE": 5,
"BLOB_FETCH_SIZE_TOO_LARGE": 6,
"ARGUMENT_OUT_OF_RANGE": 8,
"INVALID_BLOB_KEY": 9,
}
func (x BlobstoreServiceError_ErrorCode) Enum() *BlobstoreServiceError_ErrorCode {
p := new(BlobstoreServiceError_ErrorCode)
*p = x
return p
}
func (x BlobstoreServiceError_ErrorCode) String() string {
return proto.EnumName(BlobstoreServiceError_ErrorCode_name, int32(x))
}
func (x *BlobstoreServiceError_ErrorCode) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(BlobstoreServiceError_ErrorCode_value, data, "BlobstoreServiceError_ErrorCode")
if err != nil {
return err
}
*x = BlobstoreServiceError_ErrorCode(value)
return nil
}
type BlobstoreServiceError struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *BlobstoreServiceError) Reset() { *m = BlobstoreServiceError{} }
func (m *BlobstoreServiceError) String() string { return proto.CompactTextString(m) }
func (*BlobstoreServiceError) ProtoMessage() {}
type CreateUploadURLRequest struct {
SuccessPath *string `protobuf:"bytes,1,req,name=success_path" json:"success_path,omitempty"`
MaxUploadSizeBytes *int64 `protobuf:"varint,2,opt,name=max_upload_size_bytes" json:"max_upload_size_bytes,omitempty"`
MaxUploadSizePerBlobBytes *int64 `protobuf:"varint,3,opt,name=max_upload_size_per_blob_bytes" json:"max_upload_size_per_blob_bytes,omitempty"`
GsBucketName *string `protobuf:"bytes,4,opt,name=gs_bucket_name" json:"gs_bucket_name,omitempty"`
UrlExpiryTimeSeconds *int32 `protobuf:"varint,5,opt,name=url_expiry_time_seconds" json:"url_expiry_time_seconds,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CreateUploadURLRequest) Reset() { *m = CreateUploadURLRequest{} }
func (m *CreateUploadURLRequest) String() string { return proto.CompactTextString(m) }
func (*CreateUploadURLRequest) ProtoMessage() {}
func (m *CreateUploadURLRequest) GetSuccessPath() string {
if m != nil && m.SuccessPath != nil {
return *m.SuccessPath
}
return ""
}
func (m *CreateUploadURLRequest) GetMaxUploadSizeBytes() int64 {
if m != nil && m.MaxUploadSizeBytes != nil {
return *m.MaxUploadSizeBytes
}
return 0
}
func (m *CreateUploadURLRequest) GetMaxUploadSizePerBlobBytes() int64 {
if m != nil && m.MaxUploadSizePerBlobBytes != nil {
return *m.MaxUploadSizePerBlobBytes
}
return 0
}
func (m *CreateUploadURLRequest) GetGsBucketName() string {
if m != nil && m.GsBucketName != nil {
return *m.GsBucketName
}
return ""
}
func (m *CreateUploadURLRequest) GetUrlExpiryTimeSeconds() int32 {
if m != nil && m.UrlExpiryTimeSeconds != nil {
return *m.UrlExpiryTimeSeconds
}
return 0
}
type CreateUploadURLResponse struct {
Url *string `protobuf:"bytes,1,req,name=url" json:"url,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CreateUploadURLResponse) Reset() { *m = CreateUploadURLResponse{} }
func (m *CreateUploadURLResponse) String() string { return proto.CompactTextString(m) }
func (*CreateUploadURLResponse) ProtoMessage() {}
func (m *CreateUploadURLResponse) GetUrl() string {
if m != nil && m.Url != nil {
return *m.Url
}
return ""
}
type DeleteBlobRequest struct {
BlobKey []string `protobuf:"bytes,1,rep,name=blob_key" json:"blob_key,omitempty"`
Token *string `protobuf:"bytes,2,opt,name=token" json:"token,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *DeleteBlobRequest) Reset() { *m = DeleteBlobRequest{} }
func (m *DeleteBlobRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteBlobRequest) ProtoMessage() {}
func (m *DeleteBlobRequest) GetBlobKey() []string {
if m != nil {
return m.BlobKey
}
return nil
}
func (m *DeleteBlobRequest) GetToken() string {
if m != nil && m.Token != nil {
return *m.Token
}
return ""
}
type FetchDataRequest struct {
BlobKey *string `protobuf:"bytes,1,req,name=blob_key" json:"blob_key,omitempty"`
StartIndex *int64 `protobuf:"varint,2,req,name=start_index" json:"start_index,omitempty"`
EndIndex *int64 `protobuf:"varint,3,req,name=end_index" json:"end_index,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *FetchDataRequest) Reset() { *m = FetchDataRequest{} }
func (m *FetchDataRequest) String() string { return proto.CompactTextString(m) }
func (*FetchDataRequest) ProtoMessage() {}
func (m *FetchDataRequest) GetBlobKey() string {
if m != nil && m.BlobKey != nil {
return *m.BlobKey
}
return ""
}
func (m *FetchDataRequest) GetStartIndex() int64 {
if m != nil && m.StartIndex != nil {
return *m.StartIndex
}
return 0
}
func (m *FetchDataRequest) GetEndIndex() int64 {
if m != nil && m.EndIndex != nil {
return *m.EndIndex
}
return 0
}
type FetchDataResponse struct {
Data []byte `protobuf:"bytes,1000,req,name=data" json:"data,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *FetchDataResponse) Reset() { *m = FetchDataResponse{} }
func (m *FetchDataResponse) String() string { return proto.CompactTextString(m) }
func (*FetchDataResponse) ProtoMessage() {}
func (m *FetchDataResponse) GetData() []byte {
if m != nil {
return m.Data
}
return nil
}
type CloneBlobRequest struct {
BlobKey []byte `protobuf:"bytes,1,req,name=blob_key" json:"blob_key,omitempty"`
MimeType []byte `protobuf:"bytes,2,req,name=mime_type" json:"mime_type,omitempty"`
TargetAppId []byte `protobuf:"bytes,3,req,name=target_app_id" json:"target_app_id,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CloneBlobRequest) Reset() { *m = CloneBlobRequest{} }
func (m *CloneBlobRequest) String() string { return proto.CompactTextString(m) }
func (*CloneBlobRequest) ProtoMessage() {}
func (m *CloneBlobRequest) GetBlobKey() []byte {
if m != nil {
return m.BlobKey
}
return nil
}
func (m *CloneBlobRequest) GetMimeType() []byte {
if m != nil {
return m.MimeType
}
return nil
}
func (m *CloneBlobRequest) GetTargetAppId() []byte {
if m != nil {
return m.TargetAppId
}
return nil
}
type CloneBlobResponse struct {
BlobKey []byte `protobuf:"bytes,1,req,name=blob_key" json:"blob_key,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CloneBlobResponse) Reset() { *m = CloneBlobResponse{} }
func (m *CloneBlobResponse) String() string { return proto.CompactTextString(m) }
func (*CloneBlobResponse) ProtoMessage() {}
func (m *CloneBlobResponse) GetBlobKey() []byte {
if m != nil {
return m.BlobKey
}
return nil
}
type DecodeBlobKeyRequest struct {
BlobKey []string `protobuf:"bytes,1,rep,name=blob_key" json:"blob_key,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *DecodeBlobKeyRequest) Reset() { *m = DecodeBlobKeyRequest{} }
func (m *DecodeBlobKeyRequest) String() string { return proto.CompactTextString(m) }
func (*DecodeBlobKeyRequest) ProtoMessage() {}
func (m *DecodeBlobKeyRequest) GetBlobKey() []string {
if m != nil {
return m.BlobKey
}
return nil
}
type DecodeBlobKeyResponse struct {
Decoded []string `protobuf:"bytes,1,rep,name=decoded" json:"decoded,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *DecodeBlobKeyResponse) Reset() { *m = DecodeBlobKeyResponse{} }
func (m *DecodeBlobKeyResponse) String() string { return proto.CompactTextString(m) }
func (*DecodeBlobKeyResponse) ProtoMessage() {}
func (m *DecodeBlobKeyResponse) GetDecoded() []string {
if m != nil {
return m.Decoded
}
return nil
}
type CreateEncodedGoogleStorageKeyRequest struct {
Filename *string `protobuf:"bytes,1,req,name=filename" json:"filename,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CreateEncodedGoogleStorageKeyRequest) Reset() { *m = CreateEncodedGoogleStorageKeyRequest{} }
func (m *CreateEncodedGoogleStorageKeyRequest) String() string { return proto.CompactTextString(m) }
func (*CreateEncodedGoogleStorageKeyRequest) ProtoMessage() {}
func (m *CreateEncodedGoogleStorageKeyRequest) GetFilename() string {
if m != nil && m.Filename != nil {
return *m.Filename
}
return ""
}
type CreateEncodedGoogleStorageKeyResponse struct {
BlobKey *string `protobuf:"bytes,1,req,name=blob_key" json:"blob_key,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CreateEncodedGoogleStorageKeyResponse) Reset() { *m = CreateEncodedGoogleStorageKeyResponse{} }
func (m *CreateEncodedGoogleStorageKeyResponse) String() string { return proto.CompactTextString(m) }
func (*CreateEncodedGoogleStorageKeyResponse) ProtoMessage() {}
func (m *CreateEncodedGoogleStorageKeyResponse) GetBlobKey() string {
if m != nil && m.BlobKey != nil {
return *m.BlobKey
}
return ""
}
func init() {
}
================================================
FILE: vendor/google.golang.org/appengine/internal/blobstore/blobstore_service.proto
================================================
syntax = "proto2";
option go_package = "blobstore";
package appengine;
message BlobstoreServiceError {
enum ErrorCode {
OK = 0;
INTERNAL_ERROR = 1;
URL_TOO_LONG = 2;
PERMISSION_DENIED = 3;
BLOB_NOT_FOUND = 4;
DATA_INDEX_OUT_OF_RANGE = 5;
BLOB_FETCH_SIZE_TOO_LARGE = 6;
ARGUMENT_OUT_OF_RANGE = 8;
INVALID_BLOB_KEY = 9;
}
}
message CreateUploadURLRequest {
required string success_path = 1;
optional int64 max_upload_size_bytes = 2;
optional int64 max_upload_size_per_blob_bytes = 3;
optional string gs_bucket_name = 4;
optional int32 url_expiry_time_seconds = 5;
}
message CreateUploadURLResponse {
required string url = 1;
}
message DeleteBlobRequest {
repeated string blob_key = 1;
optional string token = 2;
}
message FetchDataRequest {
required string blob_key = 1;
required int64 start_index = 2;
required int64 end_index = 3;
}
message FetchDataResponse {
required bytes data = 1000 [ctype = CORD];
}
message CloneBlobRequest {
required bytes blob_key = 1;
required bytes mime_type = 2;
required bytes target_app_id = 3;
}
message CloneBlobResponse {
required bytes blob_key = 1;
}
message DecodeBlobKeyRequest {
repeated string blob_key = 1;
}
message DecodeBlobKeyResponse {
repeated string decoded = 1;
}
message CreateEncodedGoogleStorageKeyRequest {
required string filename = 1;
}
message CreateEncodedGoogleStorageKeyResponse {
required string blob_key = 1;
}
================================================
FILE: vendor/google.golang.org/appengine/internal/capability/capability_service.pb.go
================================================
// Code generated by protoc-gen-go.
// source: google.golang.org/appengine/internal/capability/capability_service.proto
// DO NOT EDIT!
/*
Package channel is a generated protocol buffer package.
It is generated from these files:
google.golang.org/appengine/internal/capability/capability_service.proto
It has these top-level messages:
IsEnabledRequest
IsEnabledResponse
*/
package channel
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type IsEnabledResponse_SummaryStatus int32
const (
IsEnabledResponse_DEFAULT IsEnabledResponse_SummaryStatus = 0
IsEnabledResponse_ENABLED IsEnabledResponse_SummaryStatus = 1
IsEnabledResponse_SCHEDULED_FUTURE IsEnabledResponse_SummaryStatus = 2
IsEnabledResponse_SCHEDULED_NOW IsEnabledResponse_SummaryStatus = 3
IsEnabledResponse_DISABLED IsEnabledResponse_SummaryStatus = 4
IsEnabledResponse_UNKNOWN IsEnabledResponse_SummaryStatus = 5
)
var IsEnabledResponse_SummaryStatus_name = map[int32]string{
0: "DEFAULT",
1: "ENABLED",
2: "SCHEDULED_FUTURE",
3: "SCHEDULED_NOW",
4: "DISABLED",
5: "UNKNOWN",
}
var IsEnabledResponse_SummaryStatus_value = map[string]int32{
"DEFAULT": 0,
"ENABLED": 1,
"SCHEDULED_FUTURE": 2,
"SCHEDULED_NOW": 3,
"DISABLED": 4,
"UNKNOWN": 5,
}
func (x IsEnabledResponse_SummaryStatus) Enum() *IsEnabledResponse_SummaryStatus {
p := new(IsEnabledResponse_SummaryStatus)
*p = x
return p
}
func (x IsEnabledResponse_SummaryStatus) String() string {
return proto.EnumName(IsEnabledResponse_SummaryStatus_name, int32(x))
}
func (x *IsEnabledResponse_SummaryStatus) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(IsEnabledResponse_SummaryStatus_value, data, "IsEnabledResponse_SummaryStatus")
if err != nil {
return err
}
*x = IsEnabledResponse_SummaryStatus(value)
return nil
}
type IsEnabledRequest struct {
Package *string `protobuf:"bytes,1,req,name=package" json:"package,omitempty"`
Capability []string `protobuf:"bytes,2,rep,name=capability" json:"capability,omitempty"`
Call []string `protobuf:"bytes,3,rep,name=call" json:"call,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *IsEnabledRequest) Reset() { *m = IsEnabledRequest{} }
func (m *IsEnabledRequest) String() string { return proto.CompactTextString(m) }
func (*IsEnabledRequest) ProtoMessage() {}
func (m *IsEnabledRequest) GetPackage() string {
if m != nil && m.Package != nil {
return *m.Package
}
return ""
}
func (m *IsEnabledRequest) GetCapability() []string {
if m != nil {
return m.Capability
}
return nil
}
func (m *IsEnabledRequest) GetCall() []string {
if m != nil {
return m.Call
}
return nil
}
type IsEnabledResponse struct {
SummaryStatus *IsEnabledResponse_SummaryStatus `protobuf:"varint,1,opt,name=summary_status,enum=appengine.IsEnabledResponse_SummaryStatus" json:"summary_status,omitempty"`
TimeUntilScheduled *int64 `protobuf:"varint,2,opt,name=time_until_scheduled" json:"time_until_scheduled,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *IsEnabledResponse) Reset() { *m = IsEnabledResponse{} }
func (m *IsEnabledResponse) String() string { return proto.CompactTextString(m) }
func (*IsEnabledResponse) ProtoMessage() {}
func (m *IsEnabledResponse) GetSummaryStatus() IsEnabledResponse_SummaryStatus {
if m != nil && m.SummaryStatus != nil {
return *m.SummaryStatus
}
return IsEnabledResponse_DEFAULT
}
func (m *IsEnabledResponse) GetTimeUntilScheduled() int64 {
if m != nil && m.TimeUntilScheduled != nil {
return *m.TimeUntilScheduled
}
return 0
}
================================================
FILE: vendor/google.golang.org/appengine/internal/capability/capability_service.proto
================================================
syntax = "proto2";
option go_package = "channel";
package appengine;
message IsEnabledRequest {
required string package = 1;
repeated string capability = 2;
repeated string call = 3;
}
message IsEnabledResponse {
enum SummaryStatus {
DEFAULT = 0;
ENABLED = 1;
SCHEDULED_FUTURE = 2;
SCHEDULED_NOW = 3;
DISABLED = 4;
UNKNOWN = 5;
}
optional SummaryStatus summary_status = 1;
optional int64 time_until_scheduled = 2;
}
service CapabilityService {
rpc IsEnabled(IsEnabledRequest) returns (IsEnabledResponse) {};
}
================================================
FILE: vendor/google.golang.org/appengine/internal/channel/channel_service.pb.go
================================================
// Code generated by protoc-gen-go.
// source: google.golang.org/appengine/internal/channel/channel_service.proto
// DO NOT EDIT!
/*
Package channel is a generated protocol buffer package.
It is generated from these files:
google.golang.org/appengine/internal/channel/channel_service.proto
It has these top-level messages:
ChannelServiceError
CreateChannelRequest
CreateChannelResponse
SendMessageRequest
*/
package channel
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type ChannelServiceError_ErrorCode int32
const (
ChannelServiceError_OK ChannelServiceError_ErrorCode = 0
ChannelServiceError_INTERNAL_ERROR ChannelServiceError_ErrorCode = 1
ChannelServiceError_INVALID_CHANNEL_KEY ChannelServiceError_ErrorCode = 2
ChannelServiceError_BAD_MESSAGE ChannelServiceError_ErrorCode = 3
ChannelServiceError_INVALID_CHANNEL_TOKEN_DURATION ChannelServiceError_ErrorCode = 4
ChannelServiceError_APPID_ALIAS_REQUIRED ChannelServiceError_ErrorCode = 5
)
var ChannelServiceError_ErrorCode_name = map[int32]string{
0: "OK",
1: "INTERNAL_ERROR",
2: "INVALID_CHANNEL_KEY",
3: "BAD_MESSAGE",
4: "INVALID_CHANNEL_TOKEN_DURATION",
5: "APPID_ALIAS_REQUIRED",
}
var ChannelServiceError_ErrorCode_value = map[string]int32{
"OK": 0,
"INTERNAL_ERROR": 1,
"INVALID_CHANNEL_KEY": 2,
"BAD_MESSAGE": 3,
"INVALID_CHANNEL_TOKEN_DURATION": 4,
"APPID_ALIAS_REQUIRED": 5,
}
func (x ChannelServiceError_ErrorCode) Enum() *ChannelServiceError_ErrorCode {
p := new(ChannelServiceError_ErrorCode)
*p = x
return p
}
func (x ChannelServiceError_ErrorCode) String() string {
return proto.EnumName(ChannelServiceError_ErrorCode_name, int32(x))
}
func (x *ChannelServiceError_ErrorCode) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(ChannelServiceError_ErrorCode_value, data, "ChannelServiceError_ErrorCode")
if err != nil {
return err
}
*x = ChannelServiceError_ErrorCode(value)
return nil
}
type ChannelServiceError struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *ChannelServiceError) Reset() { *m = ChannelServiceError{} }
func (m *ChannelServiceError) String() string { return proto.CompactTextString(m) }
func (*ChannelServiceError) ProtoMessage() {}
type CreateChannelRequest struct {
ApplicationKey *string `protobuf:"bytes,1,req,name=application_key" json:"application_key,omitempty"`
DurationMinutes *int32 `protobuf:"varint,2,opt,name=duration_minutes" json:"duration_minutes,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CreateChannelRequest) Reset() { *m = CreateChannelRequest{} }
func (m *CreateChannelRequest) String() string { return proto.CompactTextString(m) }
func (*CreateChannelRequest) ProtoMessage() {}
func (m *CreateChannelRequest) GetApplicationKey() string {
if m != nil && m.ApplicationKey != nil {
return *m.ApplicationKey
}
return ""
}
func (m *CreateChannelRequest) GetDurationMinutes() int32 {
if m != nil && m.DurationMinutes != nil {
return *m.DurationMinutes
}
return 0
}
type CreateChannelResponse struct {
Token *string `protobuf:"bytes,2,opt,name=token" json:"token,omitempty"`
DurationMinutes *int32 `protobuf:"varint,3,opt,name=duration_minutes" json:"duration_minutes,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CreateChannelResponse) Reset() { *m = CreateChannelResponse{} }
func (m *CreateChannelResponse) String() string { return proto.CompactTextString(m) }
func (*CreateChannelResponse) ProtoMessage() {}
func (m *CreateChannelResponse) GetToken() string {
if m != nil && m.Token != nil {
return *m.Token
}
return ""
}
func (m *CreateChannelResponse) GetDurationMinutes() int32 {
if m != nil && m.DurationMinutes != nil {
return *m.DurationMinutes
}
return 0
}
type SendMessageRequest struct {
ApplicationKey *string `protobuf:"bytes,1,req,name=application_key" json:"application_key,omitempty"`
Message *string `protobuf:"bytes,2,req,name=message" json:"message,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *SendMessageRequest) Reset() { *m = SendMessageRequest{} }
func (m *SendMessageRequest) String() string { return proto.CompactTextString(m) }
func (*SendMessageRequest) ProtoMessage() {}
func (m *SendMessageRequest) GetApplicationKey() string {
if m != nil && m.ApplicationKey != nil {
return *m.ApplicationKey
}
return ""
}
func (m *SendMessageRequest) GetMessage() string {
if m != nil && m.Message != nil {
return *m.Message
}
return ""
}
func init() {
}
================================================
FILE: vendor/google.golang.org/appengine/internal/channel/channel_service.proto
================================================
syntax = "proto2";
option go_package = "channel";
package appengine;
message ChannelServiceError {
enum ErrorCode {
OK = 0;
INTERNAL_ERROR = 1;
INVALID_CHANNEL_KEY = 2;
BAD_MESSAGE = 3;
INVALID_CHANNEL_TOKEN_DURATION = 4;
APPID_ALIAS_REQUIRED = 5;
}
}
message CreateChannelRequest {
required string application_key = 1;
optional int32 duration_minutes = 2;
}
message CreateChannelResponse {
optional string token = 2;
optional int32 duration_minutes = 3;
}
message SendMessageRequest {
required string application_key = 1;
required string message = 2;
}
================================================
FILE: vendor/google.golang.org/appengine/internal/datastore/datastore_v3.pb.go
================================================
// Code generated by protoc-gen-go.
// source: google.golang.org/appengine/internal/datastore/datastore_v3.proto
// DO NOT EDIT!
/*
Package datastore is a generated protocol buffer package.
It is generated from these files:
google.golang.org/appengine/internal/datastore/datastore_v3.proto
It has these top-level messages:
Action
PropertyValue
Property
Path
Reference
User
EntityProto
CompositeProperty
Index
CompositeIndex
IndexPostfix
IndexPosition
Snapshot
InternalHeader
Transaction
Query
CompiledQuery
CompiledCursor
Cursor
Error
Cost
GetRequest
GetResponse
PutRequest
PutResponse
TouchRequest
TouchResponse
DeleteRequest
DeleteResponse
NextRequest
QueryResult
AllocateIdsRequest
AllocateIdsResponse
CompositeIndices
AddActionsRequest
AddActionsResponse
BeginTransactionRequest
CommitResponse
*/
package datastore
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type Property_Meaning int32
const (
Property_NO_MEANING Property_Meaning = 0
Property_BLOB Property_Meaning = 14
Property_TEXT Property_Meaning = 15
Property_BYTESTRING Property_Meaning = 16
Property_ATOM_CATEGORY Property_Meaning = 1
Property_ATOM_LINK Property_Meaning = 2
Property_ATOM_TITLE Property_Meaning = 3
Property_ATOM_CONTENT Property_Meaning = 4
Property_ATOM_SUMMARY Property_Meaning = 5
Property_ATOM_AUTHOR Property_Meaning = 6
Property_GD_WHEN Property_Meaning = 7
Property_GD_EMAIL Property_Meaning = 8
Property_GEORSS_POINT Property_Meaning = 9
Property_GD_IM Property_Meaning = 10
Property_GD_PHONENUMBER Property_Meaning = 11
Property_GD_POSTALADDRESS Property_Meaning = 12
Property_GD_RATING Property_Meaning = 13
Property_BLOBKEY Property_Meaning = 17
Property_ENTITY_PROTO Property_Meaning = 19
Property_INDEX_VALUE Property_Meaning = 18
)
var Property_Meaning_name = map[int32]string{
0: "NO_MEANING",
14: "BLOB",
15: "TEXT",
16: "BYTESTRING",
1: "ATOM_CATEGORY",
2: "ATOM_LINK",
3: "ATOM_TITLE",
4: "ATOM_CONTENT",
5: "ATOM_SUMMARY",
6: "ATOM_AUTHOR",
7: "GD_WHEN",
8: "GD_EMAIL",
9: "GEORSS_POINT",
10: "GD_IM",
11: "GD_PHONENUMBER",
12: "GD_POSTALADDRESS",
13: "GD_RATING",
17: "BLOBKEY",
19: "ENTITY_PROTO",
18: "INDEX_VALUE",
}
var Property_Meaning_value = map[string]int32{
"NO_MEANING": 0,
"BLOB": 14,
"TEXT": 15,
"BYTESTRING": 16,
"ATOM_CATEGORY": 1,
"ATOM_LINK": 2,
"ATOM_TITLE": 3,
"ATOM_CONTENT": 4,
"ATOM_SUMMARY": 5,
"ATOM_AUTHOR": 6,
"GD_WHEN": 7,
"GD_EMAIL": 8,
"GEORSS_POINT": 9,
"GD_IM": 10,
"GD_PHONENUMBER": 11,
"GD_POSTALADDRESS": 12,
"GD_RATING": 13,
"BLOBKEY": 17,
"ENTITY_PROTO": 19,
"INDEX_VALUE": 18,
}
func (x Property_Meaning) Enum() *Property_Meaning {
p := new(Property_Meaning)
*p = x
return p
}
func (x Property_Meaning) String() string {
return proto.EnumName(Property_Meaning_name, int32(x))
}
func (x *Property_Meaning) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(Property_Meaning_value, data, "Property_Meaning")
if err != nil {
return err
}
*x = Property_Meaning(value)
return nil
}
type Property_FtsTokenizationOption int32
const (
Property_HTML Property_FtsTokenizationOption = 1
Property_ATOM Property_FtsTokenizationOption = 2
)
var Property_FtsTokenizationOption_name = map[int32]string{
1: "HTML",
2: "ATOM",
}
var Property_FtsTokenizationOption_value = map[string]int32{
"HTML": 1,
"ATOM": 2,
}
func (x Property_FtsTokenizationOption) Enum() *Property_FtsTokenizationOption {
p := new(Property_FtsTokenizationOption)
*p = x
return p
}
func (x Property_FtsTokenizationOption) String() string {
return proto.EnumName(Property_FtsTokenizationOption_name, int32(x))
}
func (x *Property_FtsTokenizationOption) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(Property_FtsTokenizationOption_value, data, "Property_FtsTokenizationOption")
if err != nil {
return err
}
*x = Property_FtsTokenizationOption(value)
return nil
}
type EntityProto_Kind int32
const (
EntityProto_GD_CONTACT EntityProto_Kind = 1
EntityProto_GD_EVENT EntityProto_Kind = 2
EntityProto_GD_MESSAGE EntityProto_Kind = 3
)
var EntityProto_Kind_name = map[int32]string{
1: "GD_CONTACT",
2: "GD_EVENT",
3: "GD_MESSAGE",
}
var EntityProto_Kind_value = map[string]int32{
"GD_CONTACT": 1,
"GD_EVENT": 2,
"GD_MESSAGE": 3,
}
func (x EntityProto_Kind) Enum() *EntityProto_Kind {
p := new(EntityProto_Kind)
*p = x
return p
}
func (x EntityProto_Kind) String() string {
return proto.EnumName(EntityProto_Kind_name, int32(x))
}
func (x *EntityProto_Kind) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(EntityProto_Kind_value, data, "EntityProto_Kind")
if err != nil {
return err
}
*x = EntityProto_Kind(value)
return nil
}
type Index_Property_Direction int32
const (
Index_Property_ASCENDING Index_Property_Direction = 1
Index_Property_DESCENDING Index_Property_Direction = 2
)
var Index_Property_Direction_name = map[int32]string{
1: "ASCENDING",
2: "DESCENDING",
}
var Index_Property_Direction_value = map[string]int32{
"ASCENDING": 1,
"DESCENDING": 2,
}
func (x Index_Property_Direction) Enum() *Index_Property_Direction {
p := new(Index_Property_Direction)
*p = x
return p
}
func (x Index_Property_Direction) String() string {
return proto.EnumName(Index_Property_Direction_name, int32(x))
}
func (x *Index_Property_Direction) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(Index_Property_Direction_value, data, "Index_Property_Direction")
if err != nil {
return err
}
*x = Index_Property_Direction(value)
return nil
}
type CompositeIndex_State int32
const (
CompositeIndex_WRITE_ONLY CompositeIndex_State = 1
CompositeIndex_READ_WRITE CompositeIndex_State = 2
CompositeIndex_DELETED CompositeIndex_State = 3
CompositeIndex_ERROR CompositeIndex_State = 4
)
var CompositeIndex_State_name = map[int32]string{
1: "WRITE_ONLY",
2: "READ_WRITE",
3: "DELETED",
4: "ERROR",
}
var CompositeIndex_State_value = map[string]int32{
"WRITE_ONLY": 1,
"READ_WRITE": 2,
"DELETED": 3,
"ERROR": 4,
}
func (x CompositeIndex_State) Enum() *CompositeIndex_State {
p := new(CompositeIndex_State)
*p = x
return p
}
func (x CompositeIndex_State) String() string {
return proto.EnumName(CompositeIndex_State_name, int32(x))
}
func (x *CompositeIndex_State) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(CompositeIndex_State_value, data, "CompositeIndex_State")
if err != nil {
return err
}
*x = CompositeIndex_State(value)
return nil
}
type Snapshot_Status int32
const (
Snapshot_INACTIVE Snapshot_Status = 0
Snapshot_ACTIVE Snapshot_Status = 1
)
var Snapshot_Status_name = map[int32]string{
0: "INACTIVE",
1: "ACTIVE",
}
var Snapshot_Status_value = map[string]int32{
"INACTIVE": 0,
"ACTIVE": 1,
}
func (x Snapshot_Status) Enum() *Snapshot_Status {
p := new(Snapshot_Status)
*p = x
return p
}
func (x Snapshot_Status) String() string {
return proto.EnumName(Snapshot_Status_name, int32(x))
}
func (x *Snapshot_Status) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(Snapshot_Status_value, data, "Snapshot_Status")
if err != nil {
return err
}
*x = Snapshot_Status(value)
return nil
}
type Query_Hint int32
const (
Query_ORDER_FIRST Query_Hint = 1
Query_ANCESTOR_FIRST Query_Hint = 2
Query_FILTER_FIRST Query_Hint = 3
)
var Query_Hint_name = map[int32]string{
1: "ORDER_FIRST",
2: "ANCESTOR_FIRST",
3: "FILTER_FIRST",
}
var Query_Hint_value = map[string]int32{
"ORDER_FIRST": 1,
"ANCESTOR_FIRST": 2,
"FILTER_FIRST": 3,
}
func (x Query_Hint) Enum() *Query_Hint {
p := new(Query_Hint)
*p = x
return p
}
func (x Query_Hint) String() string {
return proto.EnumName(Query_Hint_name, int32(x))
}
func (x *Query_Hint) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(Query_Hint_value, data, "Query_Hint")
if err != nil {
return err
}
*x = Query_Hint(value)
return nil
}
type Query_Filter_Operator int32
const (
Query_Filter_LESS_THAN Query_Filter_Operator = 1
Query_Filter_LESS_THAN_OR_EQUAL Query_Filter_Operator = 2
Query_Filter_GREATER_THAN Query_Filter_Operator = 3
Query_Filter_GREATER_THAN_OR_EQUAL Query_Filter_Operator = 4
Query_Filter_EQUAL Query_Filter_Operator = 5
Query_Filter_IN Query_Filter_Operator = 6
Query_Filter_EXISTS Query_Filter_Operator = 7
)
var Query_Filter_Operator_name = map[int32]string{
1: "LESS_THAN",
2: "LESS_THAN_OR_EQUAL",
3: "GREATER_THAN",
4: "GREATER_THAN_OR_EQUAL",
5: "EQUAL",
6: "IN",
7: "EXISTS",
}
var Query_Filter_Operator_value = map[string]int32{
"LESS_THAN": 1,
"LESS_THAN_OR_EQUAL": 2,
"GREATER_THAN": 3,
"GREATER_THAN_OR_EQUAL": 4,
"EQUAL": 5,
"IN": 6,
"EXISTS": 7,
}
func (x Query_Filter_Operator) Enum() *Query_Filter_Operator {
p := new(Query_Filter_Operator)
*p = x
return p
}
func (x Query_Filter_Operator) String() string {
return proto.EnumName(Query_Filter_Operator_name, int32(x))
}
func (x *Query_Filter_Operator) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(Query_Filter_Operator_value, data, "Query_Filter_Operator")
if err != nil {
return err
}
*x = Query_Filter_Operator(value)
return nil
}
type Query_Order_Direction int32
const (
Query_Order_ASCENDING Query_Order_Direction = 1
Query_Order_DESCENDING Query_Order_Direction = 2
)
var Query_Order_Direction_name = map[int32]string{
1: "ASCENDING",
2: "DESCENDING",
}
var Query_Order_Direction_value = map[string]int32{
"ASCENDING": 1,
"DESCENDING": 2,
}
func (x Query_Order_Direction) Enum() *Query_Order_Direction {
p := new(Query_Order_Direction)
*p = x
return p
}
func (x Query_Order_Direction) String() string {
return proto.EnumName(Query_Order_Direction_name, int32(x))
}
func (x *Query_Order_Direction) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(Query_Order_Direction_value, data, "Query_Order_Direction")
if err != nil {
return err
}
*x = Query_Order_Direction(value)
return nil
}
type Error_ErrorCode int32
const (
Error_BAD_REQUEST Error_ErrorCode = 1
Error_CONCURRENT_TRANSACTION Error_ErrorCode = 2
Error_INTERNAL_ERROR Error_ErrorCode = 3
Error_NEED_INDEX Error_ErrorCode = 4
Error_TIMEOUT Error_ErrorCode = 5
Error_PERMISSION_DENIED Error_ErrorCode = 6
Error_BIGTABLE_ERROR Error_ErrorCode = 7
Error_COMMITTED_BUT_STILL_APPLYING Error_ErrorCode = 8
Error_CAPABILITY_DISABLED Error_ErrorCode = 9
Error_TRY_ALTERNATE_BACKEND Error_ErrorCode = 10
Error_SAFE_TIME_TOO_OLD Error_ErrorCode = 11
)
var Error_ErrorCode_name = map[int32]string{
1: "BAD_REQUEST",
2: "CONCURRENT_TRANSACTION",
3: "INTERNAL_ERROR",
4: "NEED_INDEX",
5: "TIMEOUT",
6: "PERMISSION_DENIED",
7: "BIGTABLE_ERROR",
8: "COMMITTED_BUT_STILL_APPLYING",
9: "CAPABILITY_DISABLED",
10: "TRY_ALTERNATE_BACKEND",
11: "SAFE_TIME_TOO_OLD",
}
var Error_ErrorCode_value = map[string]int32{
"BAD_REQUEST": 1,
"CONCURRENT_TRANSACTION": 2,
"INTERNAL_ERROR": 3,
"NEED_INDEX": 4,
"TIMEOUT": 5,
"PERMISSION_DENIED": 6,
"BIGTABLE_ERROR": 7,
"COMMITTED_BUT_STILL_APPLYING": 8,
"CAPABILITY_DISABLED": 9,
"TRY_ALTERNATE_BACKEND": 10,
"SAFE_TIME_TOO_OLD": 11,
}
func (x Error_ErrorCode) Enum() *Error_ErrorCode {
p := new(Error_ErrorCode)
*p = x
return p
}
func (x Error_ErrorCode) String() string {
return proto.EnumName(Error_ErrorCode_name, int32(x))
}
func (x *Error_ErrorCode) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(Error_ErrorCode_value, data, "Error_ErrorCode")
if err != nil {
return err
}
*x = Error_ErrorCode(value)
return nil
}
type PutRequest_AutoIdPolicy int32
const (
PutRequest_CURRENT PutRequest_AutoIdPolicy = 0
PutRequest_SEQUENTIAL PutRequest_AutoIdPolicy = 1
)
var PutRequest_AutoIdPolicy_name = map[int32]string{
0: "CURRENT",
1: "SEQUENTIAL",
}
var PutRequest_AutoIdPolicy_value = map[string]int32{
"CURRENT": 0,
"SEQUENTIAL": 1,
}
func (x PutRequest_AutoIdPolicy) Enum() *PutRequest_AutoIdPolicy {
p := new(PutRequest_AutoIdPolicy)
*p = x
return p
}
func (x PutRequest_AutoIdPolicy) String() string {
return proto.EnumName(PutRequest_AutoIdPolicy_name, int32(x))
}
func (x *PutRequest_AutoIdPolicy) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(PutRequest_AutoIdPolicy_value, data, "PutRequest_AutoIdPolicy")
if err != nil {
return err
}
*x = PutRequest_AutoIdPolicy(value)
return nil
}
type Action struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *Action) Reset() { *m = Action{} }
func (m *Action) String() string { return proto.CompactTextString(m) }
func (*Action) ProtoMessage() {}
type PropertyValue struct {
Int64Value *int64 `protobuf:"varint,1,opt,name=int64Value" json:"int64Value,omitempty"`
BooleanValue *bool `protobuf:"varint,2,opt,name=booleanValue" json:"booleanValue,omitempty"`
StringValue *string `protobuf:"bytes,3,opt,name=stringValue" json:"stringValue,omitempty"`
DoubleValue *float64 `protobuf:"fixed64,4,opt,name=doubleValue" json:"doubleValue,omitempty"`
Pointvalue *PropertyValue_PointValue `protobuf:"group,5,opt,name=PointValue" json:"pointvalue,omitempty"`
Uservalue *PropertyValue_UserValue `protobuf:"group,8,opt,name=UserValue" json:"uservalue,omitempty"`
Referencevalue *PropertyValue_ReferenceValue `protobuf:"group,12,opt,name=ReferenceValue" json:"referencevalue,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *PropertyValue) Reset() { *m = PropertyValue{} }
func (m *PropertyValue) String() string { return proto.CompactTextString(m) }
func (*PropertyValue) ProtoMessage() {}
func (m *PropertyValue) GetInt64Value() int64 {
if m != nil && m.Int64Value != nil {
return *m.Int64Value
}
return 0
}
func (m *PropertyValue) GetBooleanValue() bool {
if m != nil && m.BooleanValue != nil {
return *m.BooleanValue
}
return false
}
func (m *PropertyValue) GetStringValue() string {
if m != nil && m.StringValue != nil {
return *m.StringValue
}
return ""
}
func (m *PropertyValue) GetDoubleValue() float64 {
if m != nil && m.DoubleValue != nil {
return *m.DoubleValue
}
return 0
}
func (m *PropertyValue) GetPointvalue() *PropertyValue_PointValue {
if m != nil {
return m.Pointvalue
}
return nil
}
func (m *PropertyValue) GetUservalue() *PropertyValue_UserValue {
if m != nil {
return m.Uservalue
}
return nil
}
func (m *PropertyValue) GetReferencevalue() *PropertyValue_ReferenceValue {
if m != nil {
return m.Referencevalue
}
return nil
}
type PropertyValue_PointValue struct {
X *float64 `protobuf:"fixed64,6,req,name=x" json:"x,omitempty"`
Y *float64 `protobuf:"fixed64,7,req,name=y" json:"y,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *PropertyValue_PointValue) Reset() { *m = PropertyValue_PointValue{} }
func (m *PropertyValue_PointValue) String() string { return proto.CompactTextString(m) }
func (*PropertyValue_PointValue) ProtoMessage() {}
func (m *PropertyValue_PointValue) GetX() float64 {
if m != nil && m.X != nil {
return *m.X
}
return 0
}
func (m *PropertyValue_PointValue) GetY() float64 {
if m != nil && m.Y != nil {
return *m.Y
}
return 0
}
type PropertyValue_UserValue struct {
Email *string `protobuf:"bytes,9,req,name=email" json:"email,omitempty"`
AuthDomain *string `protobuf:"bytes,10,req,name=auth_domain" json:"auth_domain,omitempty"`
Nickname *string `protobuf:"bytes,11,opt,name=nickname" json:"nickname,omitempty"`
FederatedIdentity *string `protobuf:"bytes,21,opt,name=federated_identity" json:"federated_identity,omitempty"`
FederatedProvider *string `protobuf:"bytes,22,opt,name=federated_provider" json:"federated_provider,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *PropertyValue_UserValue) Reset() { *m = PropertyValue_UserValue{} }
func (m *PropertyValue_UserValue) String() string { return proto.CompactTextString(m) }
func (*PropertyValue_UserValue) ProtoMessage() {}
func (m *PropertyValue_UserValue) GetEmail() string {
if m != nil && m.Email != nil {
return *m.Email
}
return ""
}
func (m *PropertyValue_UserValue) GetAuthDomain() string {
if m != nil && m.AuthDomain != nil {
return *m.AuthDomain
}
return ""
}
func (m *PropertyValue_UserValue) GetNickname() string {
if m != nil && m.Nickname != nil {
return *m.Nickname
}
return ""
}
func (m *PropertyValue_UserValue) GetFederatedIdentity() string {
if m != nil && m.FederatedIdentity != nil {
return *m.FederatedIdentity
}
return ""
}
func (m *PropertyValue_UserValue) GetFederatedProvider() string {
if m != nil && m.FederatedProvider != nil {
return *m.FederatedProvider
}
return ""
}
type PropertyValue_ReferenceValue struct {
App *string `protobuf:"bytes,13,req,name=app" json:"app,omitempty"`
NameSpace *string `protobuf:"bytes,20,opt,name=name_space" json:"name_space,omitempty"`
Pathelement []*PropertyValue_ReferenceValue_PathElement `protobuf:"group,14,rep,name=PathElement" json:"pathelement,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *PropertyValue_ReferenceValue) Reset() { *m = PropertyValue_ReferenceValue{} }
func (m *PropertyValue_ReferenceValue) String() string { return proto.CompactTextString(m) }
func (*PropertyValue_ReferenceValue) ProtoMessage() {}
func (m *PropertyValue_ReferenceValue) GetApp() string {
if m != nil && m.App != nil {
return *m.App
}
return ""
}
func (m *PropertyValue_ReferenceValue) GetNameSpace() string {
if m != nil && m.NameSpace != nil {
return *m.NameSpace
}
return ""
}
func (m *PropertyValue_ReferenceValue) GetPathelement() []*PropertyValue_ReferenceValue_PathElement {
if m != nil {
return m.Pathelement
}
return nil
}
type PropertyValue_ReferenceValue_PathElement struct {
Type *string `protobuf:"bytes,15,req,name=type" json:"type,omitempty"`
Id *int64 `protobuf:"varint,16,opt,name=id" json:"id,omitempty"`
Name *string `protobuf:"bytes,17,opt,name=name" json:"name,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *PropertyValue_ReferenceValue_PathElement) Reset() {
*m = PropertyValue_ReferenceValue_PathElement{}
}
func (m *PropertyValue_ReferenceValue_PathElement) String() string { return proto.CompactTextString(m) }
func (*PropertyValue_ReferenceValue_PathElement) ProtoMessage() {}
func (m *PropertyValue_ReferenceValue_PathElement) GetType() string {
if m != nil && m.Type != nil {
return *m.Type
}
return ""
}
func (m *PropertyValue_ReferenceValue_PathElement) GetId() int64 {
if m != nil && m.Id != nil {
return *m.Id
}
return 0
}
func (m *PropertyValue_ReferenceValue_PathElement) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
type Property struct {
Meaning *Property_Meaning `protobuf:"varint,1,opt,name=meaning,enum=appengine.Property_Meaning,def=0" json:"meaning,omitempty"`
MeaningUri *string `protobuf:"bytes,2,opt,name=meaning_uri" json:"meaning_uri,omitempty"`
Name *string `protobuf:"bytes,3,req,name=name" json:"name,omitempty"`
Value *PropertyValue `protobuf:"bytes,5,req,name=value" json:"value,omitempty"`
Multiple *bool `protobuf:"varint,4,req,name=multiple" json:"multiple,omitempty"`
Searchable *bool `protobuf:"varint,6,opt,name=searchable,def=0" json:"searchable,omitempty"`
FtsTokenizationOption *Property_FtsTokenizationOption `protobuf:"varint,8,opt,name=fts_tokenization_option,enum=appengine.Property_FtsTokenizationOption" json:"fts_tokenization_option,omitempty"`
Locale *string `protobuf:"bytes,9,opt,name=locale,def=en" json:"locale,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Property) Reset() { *m = Property{} }
func (m *Property) String() string { return proto.CompactTextString(m) }
func (*Property) ProtoMessage() {}
const Default_Property_Meaning Property_Meaning = Property_NO_MEANING
const Default_Property_Searchable bool = false
const Default_Property_Locale string = "en"
func (m *Property) GetMeaning() Property_Meaning {
if m != nil && m.Meaning != nil {
return *m.Meaning
}
return Default_Property_Meaning
}
func (m *Property) GetMeaningUri() string {
if m != nil && m.MeaningUri != nil {
return *m.MeaningUri
}
return ""
}
func (m *Property) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *Property) GetValue() *PropertyValue {
if m != nil {
return m.Value
}
return nil
}
func (m *Property) GetMultiple() bool {
if m != nil && m.Multiple != nil {
return *m.Multiple
}
return false
}
func (m *Property) GetSearchable() bool {
if m != nil && m.Searchable != nil {
return *m.Searchable
}
return Default_Property_Searchable
}
func (m *Property) GetFtsTokenizationOption() Property_FtsTokenizationOption {
if m != nil && m.FtsTokenizationOption != nil {
return *m.FtsTokenizationOption
}
return Property_HTML
}
func (m *Property) GetLocale() string {
if m != nil && m.Locale != nil {
return *m.Locale
}
return Default_Property_Locale
}
type Path struct {
Element []*Path_Element `protobuf:"group,1,rep,name=Element" json:"element,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Path) Reset() { *m = Path{} }
func (m *Path) String() string { return proto.CompactTextString(m) }
func (*Path) ProtoMessage() {}
func (m *Path) GetElement() []*Path_Element {
if m != nil {
return m.Element
}
return nil
}
type Path_Element struct {
Type *string `protobuf:"bytes,2,req,name=type" json:"type,omitempty"`
Id *int64 `protobuf:"varint,3,opt,name=id" json:"id,omitempty"`
Name *string `protobuf:"bytes,4,opt,name=name" json:"name,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Path_Element) Reset() { *m = Path_Element{} }
func (m *Path_Element) String() string { return proto.CompactTextString(m) }
func (*Path_Element) ProtoMessage() {}
func (m *Path_Element) GetType() string {
if m != nil && m.Type != nil {
return *m.Type
}
return ""
}
func (m *Path_Element) GetId() int64 {
if m != nil && m.Id != nil {
return *m.Id
}
return 0
}
func (m *Path_Element) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
type Reference struct {
App *string `protobuf:"bytes,13,req,name=app" json:"app,omitempty"`
NameSpace *string `protobuf:"bytes,20,opt,name=name_space" json:"name_space,omitempty"`
Path *Path `protobuf:"bytes,14,req,name=path" json:"path,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Reference) Reset() { *m = Reference{} }
func (m *Reference) String() string { return proto.CompactTextString(m) }
func (*Reference) ProtoMessage() {}
func (m *Reference) GetApp() string {
if m != nil && m.App != nil {
return *m.App
}
return ""
}
func (m *Reference) GetNameSpace() string {
if m != nil && m.NameSpace != nil {
return *m.NameSpace
}
return ""
}
func (m *Reference) GetPath() *Path {
if m != nil {
return m.Path
}
return nil
}
type User struct {
Email *string `protobuf:"bytes,1,req,name=email" json:"email,omitempty"`
AuthDomain *string `protobuf:"bytes,2,req,name=auth_domain" json:"auth_domain,omitempty"`
Nickname *string `protobuf:"bytes,3,opt,name=nickname" json:"nickname,omitempty"`
FederatedIdentity *string `protobuf:"bytes,6,opt,name=federated_identity" json:"federated_identity,omitempty"`
FederatedProvider *string `protobuf:"bytes,7,opt,name=federated_provider" json:"federated_provider,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *User) Reset() { *m = User{} }
func (m *User) String() string { return proto.CompactTextString(m) }
func (*User) ProtoMessage() {}
func (m *User) GetEmail() string {
if m != nil && m.Email != nil {
return *m.Email
}
return ""
}
func (m *User) GetAuthDomain() string {
if m != nil && m.AuthDomain != nil {
return *m.AuthDomain
}
return ""
}
func (m *User) GetNickname() string {
if m != nil && m.Nickname != nil {
return *m.Nickname
}
return ""
}
func (m *User) GetFederatedIdentity() string {
if m != nil && m.FederatedIdentity != nil {
return *m.FederatedIdentity
}
return ""
}
func (m *User) GetFederatedProvider() string {
if m != nil && m.FederatedProvider != nil {
return *m.FederatedProvider
}
return ""
}
type EntityProto struct {
Key *Reference `protobuf:"bytes,13,req,name=key" json:"key,omitempty"`
EntityGroup *Path `protobuf:"bytes,16,req,name=entity_group" json:"entity_group,omitempty"`
Owner *User `protobuf:"bytes,17,opt,name=owner" json:"owner,omitempty"`
Kind *EntityProto_Kind `protobuf:"varint,4,opt,name=kind,enum=appengine.EntityProto_Kind" json:"kind,omitempty"`
KindUri *string `protobuf:"bytes,5,opt,name=kind_uri" json:"kind_uri,omitempty"`
Property []*Property `protobuf:"bytes,14,rep,name=property" json:"property,omitempty"`
RawProperty []*Property `protobuf:"bytes,15,rep,name=raw_property" json:"raw_property,omitempty"`
Rank *int32 `protobuf:"varint,18,opt,name=rank" json:"rank,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *EntityProto) Reset() { *m = EntityProto{} }
func (m *EntityProto) String() string { return proto.CompactTextString(m) }
func (*EntityProto) ProtoMessage() {}
func (m *EntityProto) GetKey() *Reference {
if m != nil {
return m.Key
}
return nil
}
func (m *EntityProto) GetEntityGroup() *Path {
if m != nil {
return m.EntityGroup
}
return nil
}
func (m *EntityProto) GetOwner() *User {
if m != nil {
return m.Owner
}
return nil
}
func (m *EntityProto) GetKind() EntityProto_Kind {
if m != nil && m.Kind != nil {
return *m.Kind
}
return EntityProto_GD_CONTACT
}
func (m *EntityProto) GetKindUri() string {
if m != nil && m.KindUri != nil {
return *m.KindUri
}
return ""
}
func (m *EntityProto) GetProperty() []*Property {
if m != nil {
return m.Property
}
return nil
}
func (m *EntityProto) GetRawProperty() []*Property {
if m != nil {
return m.RawProperty
}
return nil
}
func (m *EntityProto) GetRank() int32 {
if m != nil && m.Rank != nil {
return *m.Rank
}
return 0
}
type CompositeProperty struct {
IndexId *int64 `protobuf:"varint,1,req,name=index_id" json:"index_id,omitempty"`
Value []string `protobuf:"bytes,2,rep,name=value" json:"value,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CompositeProperty) Reset() { *m = CompositeProperty{} }
func (m *CompositeProperty) String() string { return proto.CompactTextString(m) }
func (*CompositeProperty) ProtoMessage() {}
func (m *CompositeProperty) GetIndexId() int64 {
if m != nil && m.IndexId != nil {
return *m.IndexId
}
return 0
}
func (m *CompositeProperty) GetValue() []string {
if m != nil {
return m.Value
}
return nil
}
type Index struct {
EntityType *string `protobuf:"bytes,1,req,name=entity_type" json:"entity_type,omitempty"`
Ancestor *bool `protobuf:"varint,5,req,name=ancestor" json:"ancestor,omitempty"`
Property []*Index_Property `protobuf:"group,2,rep,name=Property" json:"property,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Index) Reset() { *m = Index{} }
func (m *Index) String() string { return proto.CompactTextString(m) }
func (*Index) ProtoMessage() {}
func (m *Index) GetEntityType() string {
if m != nil && m.EntityType != nil {
return *m.EntityType
}
return ""
}
func (m *Index) GetAncestor() bool {
if m != nil && m.Ancestor != nil {
return *m.Ancestor
}
return false
}
func (m *Index) GetProperty() []*Index_Property {
if m != nil {
return m.Property
}
return nil
}
type Index_Property struct {
Name *string `protobuf:"bytes,3,req,name=name" json:"name,omitempty"`
Direction *Index_Property_Direction `protobuf:"varint,4,opt,name=direction,enum=appengine.Index_Property_Direction,def=1" json:"direction,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Index_Property) Reset() { *m = Index_Property{} }
func (m *Index_Property) String() string { return proto.CompactTextString(m) }
func (*Index_Property) ProtoMessage() {}
const Default_Index_Property_Direction Index_Property_Direction = Index_Property_ASCENDING
func (m *Index_Property) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *Index_Property) GetDirection() Index_Property_Direction {
if m != nil && m.Direction != nil {
return *m.Direction
}
return Default_Index_Property_Direction
}
type CompositeIndex struct {
AppId *string `protobuf:"bytes,1,req,name=app_id" json:"app_id,omitempty"`
Id *int64 `protobuf:"varint,2,req,name=id" json:"id,omitempty"`
Definition *Index `protobuf:"bytes,3,req,name=definition" json:"definition,omitempty"`
State *CompositeIndex_State `protobuf:"varint,4,req,name=state,enum=appengine.CompositeIndex_State" json:"state,omitempty"`
OnlyUseIfRequired *bool `protobuf:"varint,6,opt,name=only_use_if_required,def=0" json:"only_use_if_required,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CompositeIndex) Reset() { *m = CompositeIndex{} }
func (m *CompositeIndex) String() string { return proto.CompactTextString(m) }
func (*CompositeIndex) ProtoMessage() {}
const Default_CompositeIndex_OnlyUseIfRequired bool = false
func (m *CompositeIndex) GetAppId() string {
if m != nil && m.AppId != nil {
return *m.AppId
}
return ""
}
func (m *CompositeIndex) GetId() int64 {
if m != nil && m.Id != nil {
return *m.Id
}
return 0
}
func (m *CompositeIndex) GetDefinition() *Index {
if m != nil {
return m.Definition
}
return nil
}
func (m *CompositeIndex) GetState() CompositeIndex_State {
if m != nil && m.State != nil {
return *m.State
}
return CompositeIndex_WRITE_ONLY
}
func (m *CompositeIndex) GetOnlyUseIfRequired() bool {
if m != nil && m.OnlyUseIfRequired != nil {
return *m.OnlyUseIfRequired
}
return Default_CompositeIndex_OnlyUseIfRequired
}
type IndexPostfix struct {
IndexValue []*IndexPostfix_IndexValue `protobuf:"bytes,1,rep,name=index_value" json:"index_value,omitempty"`
Key *Reference `protobuf:"bytes,2,opt,name=key" json:"key,omitempty"`
Before *bool `protobuf:"varint,3,opt,name=before,def=1" json:"before,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *IndexPostfix) Reset() { *m = IndexPostfix{} }
func (m *IndexPostfix) String() string { return proto.CompactTextString(m) }
func (*IndexPostfix) ProtoMessage() {}
const Default_IndexPostfix_Before bool = true
func (m *IndexPostfix) GetIndexValue() []*IndexPostfix_IndexValue {
if m != nil {
return m.IndexValue
}
return nil
}
func (m *IndexPostfix) GetKey() *Reference {
if m != nil {
return m.Key
}
return nil
}
func (m *IndexPostfix) GetBefore() bool {
if m != nil && m.Before != nil {
return *m.Before
}
return Default_IndexPostfix_Before
}
type IndexPostfix_IndexValue struct {
PropertyName *string `protobuf:"bytes,1,req,name=property_name" json:"property_name,omitempty"`
Value *PropertyValue `protobuf:"bytes,2,req,name=value" json:"value,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *IndexPostfix_IndexValue) Reset() { *m = IndexPostfix_IndexValue{} }
func (m *IndexPostfix_IndexValue) String() string { return proto.CompactTextString(m) }
func (*IndexPostfix_IndexValue) ProtoMessage() {}
func (m *IndexPostfix_IndexValue) GetPropertyName() string {
if m != nil && m.PropertyName != nil {
return *m.PropertyName
}
return ""
}
func (m *IndexPostfix_IndexValue) GetValue() *PropertyValue {
if m != nil {
return m.Value
}
return nil
}
type IndexPosition struct {
Key *string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
Before *bool `protobuf:"varint,2,opt,name=before,def=1" json:"before,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *IndexPosition) Reset() { *m = IndexPosition{} }
func (m *IndexPosition) String() string { return proto.CompactTextString(m) }
func (*IndexPosition) ProtoMessage() {}
const Default_IndexPosition_Before bool = true
func (m *IndexPosition) GetKey() string {
if m != nil && m.Key != nil {
return *m.Key
}
return ""
}
func (m *IndexPosition) GetBefore() bool {
if m != nil && m.Before != nil {
return *m.Before
}
return Default_IndexPosition_Before
}
type Snapshot struct {
Ts *int64 `protobuf:"varint,1,req,name=ts" json:"ts,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Snapshot) Reset() { *m = Snapshot{} }
func (m *Snapshot) String() string { return proto.CompactTextString(m) }
func (*Snapshot) ProtoMessage() {}
func (m *Snapshot) GetTs() int64 {
if m != nil && m.Ts != nil {
return *m.Ts
}
return 0
}
type InternalHeader struct {
Qos *string `protobuf:"bytes,1,opt,name=qos" json:"qos,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *InternalHeader) Reset() { *m = InternalHeader{} }
func (m *InternalHeader) String() string { return proto.CompactTextString(m) }
func (*InternalHeader) ProtoMessage() {}
func (m *InternalHeader) GetQos() string {
if m != nil && m.Qos != nil {
return *m.Qos
}
return ""
}
type Transaction struct {
Header *InternalHeader `protobuf:"bytes,4,opt,name=header" json:"header,omitempty"`
Handle *uint64 `protobuf:"fixed64,1,req,name=handle" json:"handle,omitempty"`
App *string `protobuf:"bytes,2,req,name=app" json:"app,omitempty"`
MarkChanges *bool `protobuf:"varint,3,opt,name=mark_changes,def=0" json:"mark_changes,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Transaction) Reset() { *m = Transaction{} }
func (m *Transaction) String() string { return proto.CompactTextString(m) }
func (*Transaction) ProtoMessage() {}
const Default_Transaction_MarkChanges bool = false
func (m *Transaction) GetHeader() *InternalHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *Transaction) GetHandle() uint64 {
if m != nil && m.Handle != nil {
return *m.Handle
}
return 0
}
func (m *Transaction) GetApp() string {
if m != nil && m.App != nil {
return *m.App
}
return ""
}
func (m *Transaction) GetMarkChanges() bool {
if m != nil && m.MarkChanges != nil {
return *m.MarkChanges
}
return Default_Transaction_MarkChanges
}
type Query struct {
Header *InternalHeader `protobuf:"bytes,39,opt,name=header" json:"header,omitempty"`
App *string `protobuf:"bytes,1,req,name=app" json:"app,omitempty"`
NameSpace *string `protobuf:"bytes,29,opt,name=name_space" json:"name_space,omitempty"`
Kind *string `protobuf:"bytes,3,opt,name=kind" json:"kind,omitempty"`
Ancestor *Reference `protobuf:"bytes,17,opt,name=ancestor" json:"ancestor,omitempty"`
Filter []*Query_Filter `protobuf:"group,4,rep,name=Filter" json:"filter,omitempty"`
SearchQuery *string `protobuf:"bytes,8,opt,name=search_query" json:"search_query,omitempty"`
Order []*Query_Order `protobuf:"group,9,rep,name=Order" json:"order,omitempty"`
Hint *Query_Hint `protobuf:"varint,18,opt,name=hint,enum=appengine.Query_Hint" json:"hint,omitempty"`
Count *int32 `protobuf:"varint,23,opt,name=count" json:"count,omitempty"`
Offset *int32 `protobuf:"varint,12,opt,name=offset,def=0" json:"offset,omitempty"`
Limit *int32 `protobuf:"varint,16,opt,name=limit" json:"limit,omitempty"`
CompiledCursor *CompiledCursor `protobuf:"bytes,30,opt,name=compiled_cursor" json:"compiled_cursor,omitempty"`
EndCompiledCursor *CompiledCursor `protobuf:"bytes,31,opt,name=end_compiled_cursor" json:"end_compiled_cursor,omitempty"`
CompositeIndex []*CompositeIndex `protobuf:"bytes,19,rep,name=composite_index" json:"composite_index,omitempty"`
RequirePerfectPlan *bool `protobuf:"varint,20,opt,name=require_perfect_plan,def=0" json:"require_perfect_plan,omitempty"`
KeysOnly *bool `protobuf:"varint,21,opt,name=keys_only,def=0" json:"keys_only,omitempty"`
Transaction *Transaction `protobuf:"bytes,22,opt,name=transaction" json:"transaction,omitempty"`
Compile *bool `protobuf:"varint,25,opt,name=compile,def=0" json:"compile,omitempty"`
FailoverMs *int64 `protobuf:"varint,26,opt,name=failover_ms" json:"failover_ms,omitempty"`
Strong *bool `protobuf:"varint,32,opt,name=strong" json:"strong,omitempty"`
PropertyName []string `protobuf:"bytes,33,rep,name=property_name" json:"property_name,omitempty"`
GroupByPropertyName []string `protobuf:"bytes,34,rep,name=group_by_property_name" json:"group_by_property_name,omitempty"`
Distinct *bool `protobuf:"varint,24,opt,name=distinct" json:"distinct,omitempty"`
MinSafeTimeSeconds *int64 `protobuf:"varint,35,opt,name=min_safe_time_seconds" json:"min_safe_time_seconds,omitempty"`
SafeReplicaName []string `protobuf:"bytes,36,rep,name=safe_replica_name" json:"safe_replica_name,omitempty"`
PersistOffset *bool `protobuf:"varint,37,opt,name=persist_offset,def=0" json:"persist_offset,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Query) Reset() { *m = Query{} }
func (m *Query) String() string { return proto.CompactTextString(m) }
func (*Query) ProtoMessage() {}
const Default_Query_Offset int32 = 0
const Default_Query_RequirePerfectPlan bool = false
const Default_Query_KeysOnly bool = false
const Default_Query_Compile bool = false
const Default_Query_PersistOffset bool = false
func (m *Query) GetHeader() *InternalHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *Query) GetApp() string {
if m != nil && m.App != nil {
return *m.App
}
return ""
}
func (m *Query) GetNameSpace() string {
if m != nil && m.NameSpace != nil {
return *m.NameSpace
}
return ""
}
func (m *Query) GetKind() string {
if m != nil && m.Kind != nil {
return *m.Kind
}
return ""
}
func (m *Query) GetAncestor() *Reference {
if m != nil {
return m.Ancestor
}
return nil
}
func (m *Query) GetFilter() []*Query_Filter {
if m != nil {
return m.Filter
}
return nil
}
func (m *Query) GetSearchQuery() string {
if m != nil && m.SearchQuery != nil {
return *m.SearchQuery
}
return ""
}
func (m *Query) GetOrder() []*Query_Order {
if m != nil {
return m.Order
}
return nil
}
func (m *Query) GetHint() Query_Hint {
if m != nil && m.Hint != nil {
return *m.Hint
}
return Query_ORDER_FIRST
}
func (m *Query) GetCount() int32 {
if m != nil && m.Count != nil {
return *m.Count
}
return 0
}
func (m *Query) GetOffset() int32 {
if m != nil && m.Offset != nil {
return *m.Offset
}
return Default_Query_Offset
}
func (m *Query) GetLimit() int32 {
if m != nil && m.Limit != nil {
return *m.Limit
}
return 0
}
func (m *Query) GetCompiledCursor() *CompiledCursor {
if m != nil {
return m.CompiledCursor
}
return nil
}
func (m *Query) GetEndCompiledCursor() *CompiledCursor {
if m != nil {
return m.EndCompiledCursor
}
return nil
}
func (m *Query) GetCompositeIndex() []*CompositeIndex {
if m != nil {
return m.CompositeIndex
}
return nil
}
func (m *Query) GetRequirePerfectPlan() bool {
if m != nil && m.RequirePerfectPlan != nil {
return *m.RequirePerfectPlan
}
return Default_Query_RequirePerfectPlan
}
func (m *Query) GetKeysOnly() bool {
if m != nil && m.KeysOnly != nil {
return *m.KeysOnly
}
return Default_Query_KeysOnly
}
func (m *Query) GetTransaction() *Transaction {
if m != nil {
return m.Transaction
}
return nil
}
func (m *Query) GetCompile() bool {
if m != nil && m.Compile != nil {
return *m.Compile
}
return Default_Query_Compile
}
func (m *Query) GetFailoverMs() int64 {
if m != nil && m.FailoverMs != nil {
return *m.FailoverMs
}
return 0
}
func (m *Query) GetStrong() bool {
if m != nil && m.Strong != nil {
return *m.Strong
}
return false
}
func (m *Query) GetPropertyName() []string {
if m != nil {
return m.PropertyName
}
return nil
}
func (m *Query) GetGroupByPropertyName() []string {
if m != nil {
return m.GroupByPropertyName
}
return nil
}
func (m *Query) GetDistinct() bool {
if m != nil && m.Distinct != nil {
return *m.Distinct
}
return false
}
func (m *Query) GetMinSafeTimeSeconds() int64 {
if m != nil && m.MinSafeTimeSeconds != nil {
return *m.MinSafeTimeSeconds
}
return 0
}
func (m *Query) GetSafeReplicaName() []string {
if m != nil {
return m.SafeReplicaName
}
return nil
}
func (m *Query) GetPersistOffset() bool {
if m != nil && m.PersistOffset != nil {
return *m.PersistOffset
}
return Default_Query_PersistOffset
}
type Query_Filter struct {
Op *Query_Filter_Operator `protobuf:"varint,6,req,name=op,enum=appengine.Query_Filter_Operator" json:"op,omitempty"`
Property []*Property `protobuf:"bytes,14,rep,name=property" json:"property,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Query_Filter) Reset() { *m = Query_Filter{} }
func (m *Query_Filter) String() string { return proto.CompactTextString(m) }
func (*Query_Filter) ProtoMessage() {}
func (m *Query_Filter) GetOp() Query_Filter_Operator {
if m != nil && m.Op != nil {
return *m.Op
}
return Query_Filter_LESS_THAN
}
func (m *Query_Filter) GetProperty() []*Property {
if m != nil {
return m.Property
}
return nil
}
type Query_Order struct {
Property *string `protobuf:"bytes,10,req,name=property" json:"property,omitempty"`
Direction *Query_Order_Direction `protobuf:"varint,11,opt,name=direction,enum=appengine.Query_Order_Direction,def=1" json:"direction,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Query_Order) Reset() { *m = Query_Order{} }
func (m *Query_Order) String() string { return proto.CompactTextString(m) }
func (*Query_Order) ProtoMessage() {}
const Default_Query_Order_Direction Query_Order_Direction = Query_Order_ASCENDING
func (m *Query_Order) GetProperty() string {
if m != nil && m.Property != nil {
return *m.Property
}
return ""
}
func (m *Query_Order) GetDirection() Query_Order_Direction {
if m != nil && m.Direction != nil {
return *m.Direction
}
return Default_Query_Order_Direction
}
type CompiledQuery struct {
Primaryscan *CompiledQuery_PrimaryScan `protobuf:"group,1,req,name=PrimaryScan" json:"primaryscan,omitempty"`
Mergejoinscan []*CompiledQuery_MergeJoinScan `protobuf:"group,7,rep,name=MergeJoinScan" json:"mergejoinscan,omitempty"`
IndexDef *Index `protobuf:"bytes,21,opt,name=index_def" json:"index_def,omitempty"`
Offset *int32 `protobuf:"varint,10,opt,name=offset,def=0" json:"offset,omitempty"`
Limit *int32 `protobuf:"varint,11,opt,name=limit" json:"limit,omitempty"`
KeysOnly *bool `protobuf:"varint,12,req,name=keys_only" json:"keys_only,omitempty"`
PropertyName []string `protobuf:"bytes,24,rep,name=property_name" json:"property_name,omitempty"`
DistinctInfixSize *int32 `protobuf:"varint,25,opt,name=distinct_infix_size" json:"distinct_infix_size,omitempty"`
Entityfilter *CompiledQuery_EntityFilter `protobuf:"group,13,opt,name=EntityFilter" json:"entityfilter,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CompiledQuery) Reset() { *m = CompiledQuery{} }
func (m *CompiledQuery) String() string { return proto.CompactTextString(m) }
func (*CompiledQuery) ProtoMessage() {}
const Default_CompiledQuery_Offset int32 = 0
func (m *CompiledQuery) GetPrimaryscan() *CompiledQuery_PrimaryScan {
if m != nil {
return m.Primaryscan
}
return nil
}
func (m *CompiledQuery) GetMergejoinscan() []*CompiledQuery_MergeJoinScan {
if m != nil {
return m.Mergejoinscan
}
return nil
}
func (m *CompiledQuery) GetIndexDef() *Index {
if m != nil {
return m.IndexDef
}
return nil
}
func (m *CompiledQuery) GetOffset() int32 {
if m != nil && m.Offset != nil {
return *m.Offset
}
return Default_CompiledQuery_Offset
}
func (m *CompiledQuery) GetLimit() int32 {
if m != nil && m.Limit != nil {
return *m.Limit
}
return 0
}
func (m *CompiledQuery) GetKeysOnly() bool {
if m != nil && m.KeysOnly != nil {
return *m.KeysOnly
}
return false
}
func (m *CompiledQuery) GetPropertyName() []string {
if m != nil {
return m.PropertyName
}
return nil
}
func (m *CompiledQuery) GetDistinctInfixSize() int32 {
if m != nil && m.DistinctInfixSize != nil {
return *m.DistinctInfixSize
}
return 0
}
func (m *CompiledQuery) GetEntityfilter() *CompiledQuery_EntityFilter {
if m != nil {
return m.Entityfilter
}
return nil
}
type CompiledQuery_PrimaryScan struct {
IndexName *string `protobuf:"bytes,2,opt,name=index_name" json:"index_name,omitempty"`
StartKey *string `protobuf:"bytes,3,opt,name=start_key" json:"start_key,omitempty"`
StartInclusive *bool `protobuf:"varint,4,opt,name=start_inclusive" json:"start_inclusive,omitempty"`
EndKey *string `protobuf:"bytes,5,opt,name=end_key" json:"end_key,omitempty"`
EndInclusive *bool `protobuf:"varint,6,opt,name=end_inclusive" json:"end_inclusive,omitempty"`
StartPostfixValue []string `protobuf:"bytes,22,rep,name=start_postfix_value" json:"start_postfix_value,omitempty"`
EndPostfixValue []string `protobuf:"bytes,23,rep,name=end_postfix_value" json:"end_postfix_value,omitempty"`
EndUnappliedLogTimestampUs *int64 `protobuf:"varint,19,opt,name=end_unapplied_log_timestamp_us" json:"end_unapplied_log_timestamp_us,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CompiledQuery_PrimaryScan) Reset() { *m = CompiledQuery_PrimaryScan{} }
func (m *CompiledQuery_PrimaryScan) String() string { return proto.CompactTextString(m) }
func (*CompiledQuery_PrimaryScan) ProtoMessage() {}
func (m *CompiledQuery_PrimaryScan) GetIndexName() string {
if m != nil && m.IndexName != nil {
return *m.IndexName
}
return ""
}
func (m *CompiledQuery_PrimaryScan) GetStartKey() string {
if m != nil && m.StartKey != nil {
return *m.StartKey
}
return ""
}
func (m *CompiledQuery_PrimaryScan) GetStartInclusive() bool {
if m != nil && m.StartInclusive != nil {
return *m.StartInclusive
}
return false
}
func (m *CompiledQuery_PrimaryScan) GetEndKey() string {
if m != nil && m.EndKey != nil {
return *m.EndKey
}
return ""
}
func (m *CompiledQuery_PrimaryScan) GetEndInclusive() bool {
if m != nil && m.EndInclusive != nil {
return *m.EndInclusive
}
return false
}
func (m *CompiledQuery_PrimaryScan) GetStartPostfixValue() []string {
if m != nil {
return m.StartPostfixValue
}
return nil
}
func (m *CompiledQuery_PrimaryScan) GetEndPostfixValue() []string {
if m != nil {
return m.EndPostfixValue
}
return nil
}
func (m *CompiledQuery_PrimaryScan) GetEndUnappliedLogTimestampUs() int64 {
if m != nil && m.EndUnappliedLogTimestampUs != nil {
return *m.EndUnappliedLogTimestampUs
}
return 0
}
type CompiledQuery_MergeJoinScan struct {
IndexName *string `protobuf:"bytes,8,req,name=index_name" json:"index_name,omitempty"`
PrefixValue []string `protobuf:"bytes,9,rep,name=prefix_value" json:"prefix_value,omitempty"`
ValuePrefix *bool `protobuf:"varint,20,opt,name=value_prefix,def=0" json:"value_prefix,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CompiledQuery_MergeJoinScan) Reset() { *m = CompiledQuery_MergeJoinScan{} }
func (m *CompiledQuery_MergeJoinScan) String() string { return proto.CompactTextString(m) }
func (*CompiledQuery_MergeJoinScan) ProtoMessage() {}
const Default_CompiledQuery_MergeJoinScan_ValuePrefix bool = false
func (m *CompiledQuery_MergeJoinScan) GetIndexName() string {
if m != nil && m.IndexName != nil {
return *m.IndexName
}
return ""
}
func (m *CompiledQuery_MergeJoinScan) GetPrefixValue() []string {
if m != nil {
return m.PrefixValue
}
return nil
}
func (m *CompiledQuery_MergeJoinScan) GetValuePrefix() bool {
if m != nil && m.ValuePrefix != nil {
return *m.ValuePrefix
}
return Default_CompiledQuery_MergeJoinScan_ValuePrefix
}
type CompiledQuery_EntityFilter struct {
Distinct *bool `protobuf:"varint,14,opt,name=distinct,def=0" json:"distinct,omitempty"`
Kind *string `protobuf:"bytes,17,opt,name=kind" json:"kind,omitempty"`
Ancestor *Reference `protobuf:"bytes,18,opt,name=ancestor" json:"ancestor,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CompiledQuery_EntityFilter) Reset() { *m = CompiledQuery_EntityFilter{} }
func (m *CompiledQuery_EntityFilter) String() string { return proto.CompactTextString(m) }
func (*CompiledQuery_EntityFilter) ProtoMessage() {}
const Default_CompiledQuery_EntityFilter_Distinct bool = false
func (m *CompiledQuery_EntityFilter) GetDistinct() bool {
if m != nil && m.Distinct != nil {
return *m.Distinct
}
return Default_CompiledQuery_EntityFilter_Distinct
}
func (m *CompiledQuery_EntityFilter) GetKind() string {
if m != nil && m.Kind != nil {
return *m.Kind
}
return ""
}
func (m *CompiledQuery_EntityFilter) GetAncestor() *Reference {
if m != nil {
return m.Ancestor
}
return nil
}
type CompiledCursor struct {
Position *CompiledCursor_Position `protobuf:"group,2,opt,name=Position" json:"position,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CompiledCursor) Reset() { *m = CompiledCursor{} }
func (m *CompiledCursor) String() string { return proto.CompactTextString(m) }
func (*CompiledCursor) ProtoMessage() {}
func (m *CompiledCursor) GetPosition() *CompiledCursor_Position {
if m != nil {
return m.Position
}
return nil
}
type CompiledCursor_Position struct {
StartKey *string `protobuf:"bytes,27,opt,name=start_key" json:"start_key,omitempty"`
Indexvalue []*CompiledCursor_Position_IndexValue `protobuf:"group,29,rep,name=IndexValue" json:"indexvalue,omitempty"`
Key *Reference `protobuf:"bytes,32,opt,name=key" json:"key,omitempty"`
StartInclusive *bool `protobuf:"varint,28,opt,name=start_inclusive,def=1" json:"start_inclusive,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CompiledCursor_Position) Reset() { *m = CompiledCursor_Position{} }
func (m *CompiledCursor_Position) String() string { return proto.CompactTextString(m) }
func (*CompiledCursor_Position) ProtoMessage() {}
const Default_CompiledCursor_Position_StartInclusive bool = true
func (m *CompiledCursor_Position) GetStartKey() string {
if m != nil && m.StartKey != nil {
return *m.StartKey
}
return ""
}
func (m *CompiledCursor_Position) GetIndexvalue() []*CompiledCursor_Position_IndexValue {
if m != nil {
return m.Indexvalue
}
return nil
}
func (m *CompiledCursor_Position) GetKey() *Reference {
if m != nil {
return m.Key
}
return nil
}
func (m *CompiledCursor_Position) GetStartInclusive() bool {
if m != nil && m.StartInclusive != nil {
return *m.StartInclusive
}
return Default_CompiledCursor_Position_StartInclusive
}
type CompiledCursor_Position_IndexValue struct {
Property *string `protobuf:"bytes,30,opt,name=property" json:"property,omitempty"`
Value *PropertyValue `protobuf:"bytes,31,req,name=value" json:"value,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CompiledCursor_Position_IndexValue) Reset() { *m = CompiledCursor_Position_IndexValue{} }
func (m *CompiledCursor_Position_IndexValue) String() string { return proto.CompactTextString(m) }
func (*CompiledCursor_Position_IndexValue) ProtoMessage() {}
func (m *CompiledCursor_Position_IndexValue) GetProperty() string {
if m != nil && m.Property != nil {
return *m.Property
}
return ""
}
func (m *CompiledCursor_Position_IndexValue) GetValue() *PropertyValue {
if m != nil {
return m.Value
}
return nil
}
type Cursor struct {
Cursor *uint64 `protobuf:"fixed64,1,req,name=cursor" json:"cursor,omitempty"`
App *string `protobuf:"bytes,2,opt,name=app" json:"app,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Cursor) Reset() { *m = Cursor{} }
func (m *Cursor) String() string { return proto.CompactTextString(m) }
func (*Cursor) ProtoMessage() {}
func (m *Cursor) GetCursor() uint64 {
if m != nil && m.Cursor != nil {
return *m.Cursor
}
return 0
}
func (m *Cursor) GetApp() string {
if m != nil && m.App != nil {
return *m.App
}
return ""
}
type Error struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *Error) Reset() { *m = Error{} }
func (m *Error) String() string { return proto.CompactTextString(m) }
func (*Error) ProtoMessage() {}
type Cost struct {
IndexWrites *int32 `protobuf:"varint,1,opt,name=index_writes" json:"index_writes,omitempty"`
IndexWriteBytes *int32 `protobuf:"varint,2,opt,name=index_write_bytes" json:"index_write_bytes,omitempty"`
EntityWrites *int32 `protobuf:"varint,3,opt,name=entity_writes" json:"entity_writes,omitempty"`
EntityWriteBytes *int32 `protobuf:"varint,4,opt,name=entity_write_bytes" json:"entity_write_bytes,omitempty"`
Commitcost *Cost_CommitCost `protobuf:"group,5,opt,name=CommitCost" json:"commitcost,omitempty"`
ApproximateStorageDelta *int32 `protobuf:"varint,8,opt,name=approximate_storage_delta" json:"approximate_storage_delta,omitempty"`
IdSequenceUpdates *int32 `protobuf:"varint,9,opt,name=id_sequence_updates" json:"id_sequence_updates,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Cost) Reset() { *m = Cost{} }
func (m *Cost) String() string { return proto.CompactTextString(m) }
func (*Cost) ProtoMessage() {}
func (m *Cost) GetIndexWrites() int32 {
if m != nil && m.IndexWrites != nil {
return *m.IndexWrites
}
return 0
}
func (m *Cost) GetIndexWriteBytes() int32 {
if m != nil && m.IndexWriteBytes != nil {
return *m.IndexWriteBytes
}
return 0
}
func (m *Cost) GetEntityWrites() int32 {
if m != nil && m.EntityWrites != nil {
return *m.EntityWrites
}
return 0
}
func (m *Cost) GetEntityWriteBytes() int32 {
if m != nil && m.EntityWriteBytes != nil {
return *m.EntityWriteBytes
}
return 0
}
func (m *Cost) GetCommitcost() *Cost_CommitCost {
if m != nil {
return m.Commitcost
}
return nil
}
func (m *Cost) GetApproximateStorageDelta() int32 {
if m != nil && m.ApproximateStorageDelta != nil {
return *m.ApproximateStorageDelta
}
return 0
}
func (m *Cost) GetIdSequenceUpdates() int32 {
if m != nil && m.IdSequenceUpdates != nil {
return *m.IdSequenceUpdates
}
return 0
}
type Cost_CommitCost struct {
RequestedEntityPuts *int32 `protobuf:"varint,6,opt,name=requested_entity_puts" json:"requested_entity_puts,omitempty"`
RequestedEntityDeletes *int32 `protobuf:"varint,7,opt,name=requested_entity_deletes" json:"requested_entity_deletes,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Cost_CommitCost) Reset() { *m = Cost_CommitCost{} }
func (m *Cost_CommitCost) String() string { return proto.CompactTextString(m) }
func (*Cost_CommitCost) ProtoMessage() {}
func (m *Cost_CommitCost) GetRequestedEntityPuts() int32 {
if m != nil && m.RequestedEntityPuts != nil {
return *m.RequestedEntityPuts
}
return 0
}
func (m *Cost_CommitCost) GetRequestedEntityDeletes() int32 {
if m != nil && m.RequestedEntityDeletes != nil {
return *m.RequestedEntityDeletes
}
return 0
}
type GetRequest struct {
Header *InternalHeader `protobuf:"bytes,6,opt,name=header" json:"header,omitempty"`
Key []*Reference `protobuf:"bytes,1,rep,name=key" json:"key,omitempty"`
Transaction *Transaction `protobuf:"bytes,2,opt,name=transaction" json:"transaction,omitempty"`
FailoverMs *int64 `protobuf:"varint,3,opt,name=failover_ms" json:"failover_ms,omitempty"`
Strong *bool `protobuf:"varint,4,opt,name=strong" json:"strong,omitempty"`
AllowDeferred *bool `protobuf:"varint,5,opt,name=allow_deferred,def=0" json:"allow_deferred,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetRequest) Reset() { *m = GetRequest{} }
func (m *GetRequest) String() string { return proto.CompactTextString(m) }
func (*GetRequest) ProtoMessage() {}
const Default_GetRequest_AllowDeferred bool = false
func (m *GetRequest) GetHeader() *InternalHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *GetRequest) GetKey() []*Reference {
if m != nil {
return m.Key
}
return nil
}
func (m *GetRequest) GetTransaction() *Transaction {
if m != nil {
return m.Transaction
}
return nil
}
func (m *GetRequest) GetFailoverMs() int64 {
if m != nil && m.FailoverMs != nil {
return *m.FailoverMs
}
return 0
}
func (m *GetRequest) GetStrong() bool {
if m != nil && m.Strong != nil {
return *m.Strong
}
return false
}
func (m *GetRequest) GetAllowDeferred() bool {
if m != nil && m.AllowDeferred != nil {
return *m.AllowDeferred
}
return Default_GetRequest_AllowDeferred
}
type GetResponse struct {
Entity []*GetResponse_Entity `protobuf:"group,1,rep,name=Entity" json:"entity,omitempty"`
Deferred []*Reference `protobuf:"bytes,5,rep,name=deferred" json:"deferred,omitempty"`
InOrder *bool `protobuf:"varint,6,opt,name=in_order,def=1" json:"in_order,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetResponse) Reset() { *m = GetResponse{} }
func (m *GetResponse) String() string { return proto.CompactTextString(m) }
func (*GetResponse) ProtoMessage() {}
const Default_GetResponse_InOrder bool = true
func (m *GetResponse) GetEntity() []*GetResponse_Entity {
if m != nil {
return m.Entity
}
return nil
}
func (m *GetResponse) GetDeferred() []*Reference {
if m != nil {
return m.Deferred
}
return nil
}
func (m *GetResponse) GetInOrder() bool {
if m != nil && m.InOrder != nil {
return *m.InOrder
}
return Default_GetResponse_InOrder
}
type GetResponse_Entity struct {
Entity *EntityProto `protobuf:"bytes,2,opt,name=entity" json:"entity,omitempty"`
Key *Reference `protobuf:"bytes,4,opt,name=key" json:"key,omitempty"`
Version *int64 `protobuf:"varint,3,opt,name=version" json:"version,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetResponse_Entity) Reset() { *m = GetResponse_Entity{} }
func (m *GetResponse_Entity) String() string { return proto.CompactTextString(m) }
func (*GetResponse_Entity) ProtoMessage() {}
func (m *GetResponse_Entity) GetEntity() *EntityProto {
if m != nil {
return m.Entity
}
return nil
}
func (m *GetResponse_Entity) GetKey() *Reference {
if m != nil {
return m.Key
}
return nil
}
func (m *GetResponse_Entity) GetVersion() int64 {
if m != nil && m.Version != nil {
return *m.Version
}
return 0
}
type PutRequest struct {
Header *InternalHeader `protobuf:"bytes,11,opt,name=header" json:"header,omitempty"`
Entity []*EntityProto `protobuf:"bytes,1,rep,name=entity" json:"entity,omitempty"`
Transaction *Transaction `protobuf:"bytes,2,opt,name=transaction" json:"transaction,omitempty"`
CompositeIndex []*CompositeIndex `protobuf:"bytes,3,rep,name=composite_index" json:"composite_index,omitempty"`
Trusted *bool `protobuf:"varint,4,opt,name=trusted,def=0" json:"trusted,omitempty"`
Force *bool `protobuf:"varint,7,opt,name=force,def=0" json:"force,omitempty"`
MarkChanges *bool `protobuf:"varint,8,opt,name=mark_changes,def=0" json:"mark_changes,omitempty"`
Snapshot []*Snapshot `protobuf:"bytes,9,rep,name=snapshot" json:"snapshot,omitempty"`
AutoIdPolicy *PutRequest_AutoIdPolicy `protobuf:"varint,10,opt,name=auto_id_policy,enum=appengine.PutRequest_AutoIdPolicy,def=0" json:"auto_id_policy,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *PutRequest) Reset() { *m = PutRequest{} }
func (m *PutRequest) String() string { return proto.CompactTextString(m) }
func (*PutRequest) ProtoMessage() {}
const Default_PutRequest_Trusted bool = false
const Default_PutRequest_Force bool = false
const Default_PutRequest_MarkChanges bool = false
const Default_PutRequest_AutoIdPolicy PutRequest_AutoIdPolicy = PutRequest_CURRENT
func (m *PutRequest) GetHeader() *InternalHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *PutRequest) GetEntity() []*EntityProto {
if m != nil {
return m.Entity
}
return nil
}
func (m *PutRequest) GetTransaction() *Transaction {
if m != nil {
return m.Transaction
}
return nil
}
func (m *PutRequest) GetCompositeIndex() []*CompositeIndex {
if m != nil {
return m.CompositeIndex
}
return nil
}
func (m *PutRequest) GetTrusted() bool {
if m != nil && m.Trusted != nil {
return *m.Trusted
}
return Default_PutRequest_Trusted
}
func (m *PutRequest) GetForce() bool {
if m != nil && m.Force != nil {
return *m.Force
}
return Default_PutRequest_Force
}
func (m *PutRequest) GetMarkChanges() bool {
if m != nil && m.MarkChanges != nil {
return *m.MarkChanges
}
return Default_PutRequest_MarkChanges
}
func (m *PutRequest) GetSnapshot() []*Snapshot {
if m != nil {
return m.Snapshot
}
return nil
}
func (m *PutRequest) GetAutoIdPolicy() PutRequest_AutoIdPolicy {
if m != nil && m.AutoIdPolicy != nil {
return *m.AutoIdPolicy
}
return Default_PutRequest_AutoIdPolicy
}
type PutResponse struct {
Key []*Reference `protobuf:"bytes,1,rep,name=key" json:"key,omitempty"`
Cost *Cost `protobuf:"bytes,2,opt,name=cost" json:"cost,omitempty"`
Version []int64 `protobuf:"varint,3,rep,name=version" json:"version,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *PutResponse) Reset() { *m = PutResponse{} }
func (m *PutResponse) String() string { return proto.CompactTextString(m) }
func (*PutResponse) ProtoMessage() {}
func (m *PutResponse) GetKey() []*Reference {
if m != nil {
return m.Key
}
return nil
}
func (m *PutResponse) GetCost() *Cost {
if m != nil {
return m.Cost
}
return nil
}
func (m *PutResponse) GetVersion() []int64 {
if m != nil {
return m.Version
}
return nil
}
type TouchRequest struct {
Header *InternalHeader `protobuf:"bytes,10,opt,name=header" json:"header,omitempty"`
Key []*Reference `protobuf:"bytes,1,rep,name=key" json:"key,omitempty"`
CompositeIndex []*CompositeIndex `protobuf:"bytes,2,rep,name=composite_index" json:"composite_index,omitempty"`
Force *bool `protobuf:"varint,3,opt,name=force,def=0" json:"force,omitempty"`
Snapshot []*Snapshot `protobuf:"bytes,9,rep,name=snapshot" json:"snapshot,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TouchRequest) Reset() { *m = TouchRequest{} }
func (m *TouchRequest) String() string { return proto.CompactTextString(m) }
func (*TouchRequest) ProtoMessage() {}
const Default_TouchRequest_Force bool = false
func (m *TouchRequest) GetHeader() *InternalHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *TouchRequest) GetKey() []*Reference {
if m != nil {
return m.Key
}
return nil
}
func (m *TouchRequest) GetCompositeIndex() []*CompositeIndex {
if m != nil {
return m.CompositeIndex
}
return nil
}
func (m *TouchRequest) GetForce() bool {
if m != nil && m.Force != nil {
return *m.Force
}
return Default_TouchRequest_Force
}
func (m *TouchRequest) GetSnapshot() []*Snapshot {
if m != nil {
return m.Snapshot
}
return nil
}
type TouchResponse struct {
Cost *Cost `protobuf:"bytes,1,opt,name=cost" json:"cost,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TouchResponse) Reset() { *m = TouchResponse{} }
func (m *TouchResponse) String() string { return proto.CompactTextString(m) }
func (*TouchResponse) ProtoMessage() {}
func (m *TouchResponse) GetCost() *Cost {
if m != nil {
return m.Cost
}
return nil
}
type DeleteRequest struct {
Header *InternalHeader `protobuf:"bytes,10,opt,name=header" json:"header,omitempty"`
Key []*Reference `protobuf:"bytes,6,rep,name=key" json:"key,omitempty"`
Transaction *Transaction `protobuf:"bytes,5,opt,name=transaction" json:"transaction,omitempty"`
Trusted *bool `protobuf:"varint,4,opt,name=trusted,def=0" json:"trusted,omitempty"`
Force *bool `protobuf:"varint,7,opt,name=force,def=0" json:"force,omitempty"`
MarkChanges *bool `protobuf:"varint,8,opt,name=mark_changes,def=0" json:"mark_changes,omitempty"`
Snapshot []*Snapshot `protobuf:"bytes,9,rep,name=snapshot" json:"snapshot,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *DeleteRequest) Reset() { *m = DeleteRequest{} }
func (m *DeleteRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteRequest) ProtoMessage() {}
const Default_DeleteRequest_Trusted bool = false
const Default_DeleteRequest_Force bool = false
const Default_DeleteRequest_MarkChanges bool = false
func (m *DeleteRequest) GetHeader() *InternalHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *DeleteRequest) GetKey() []*Reference {
if m != nil {
return m.Key
}
return nil
}
func (m *DeleteRequest) GetTransaction() *Transaction {
if m != nil {
return m.Transaction
}
return nil
}
func (m *DeleteRequest) GetTrusted() bool {
if m != nil && m.Trusted != nil {
return *m.Trusted
}
return Default_DeleteRequest_Trusted
}
func (m *DeleteRequest) GetForce() bool {
if m != nil && m.Force != nil {
return *m.Force
}
return Default_DeleteRequest_Force
}
func (m *DeleteRequest) GetMarkChanges() bool {
if m != nil && m.MarkChanges != nil {
return *m.MarkChanges
}
return Default_DeleteRequest_MarkChanges
}
func (m *DeleteRequest) GetSnapshot() []*Snapshot {
if m != nil {
return m.Snapshot
}
return nil
}
type DeleteResponse struct {
Cost *Cost `protobuf:"bytes,1,opt,name=cost" json:"cost,omitempty"`
Version []int64 `protobuf:"varint,3,rep,name=version" json:"version,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *DeleteResponse) Reset() { *m = DeleteResponse{} }
func (m *DeleteResponse) String() string { return proto.CompactTextString(m) }
func (*DeleteResponse) ProtoMessage() {}
func (m *DeleteResponse) GetCost() *Cost {
if m != nil {
return m.Cost
}
return nil
}
func (m *DeleteResponse) GetVersion() []int64 {
if m != nil {
return m.Version
}
return nil
}
type NextRequest struct {
Header *InternalHeader `protobuf:"bytes,5,opt,name=header" json:"header,omitempty"`
Cursor *Cursor `protobuf:"bytes,1,req,name=cursor" json:"cursor,omitempty"`
Count *int32 `protobuf:"varint,2,opt,name=count" json:"count,omitempty"`
Offset *int32 `protobuf:"varint,4,opt,name=offset,def=0" json:"offset,omitempty"`
Compile *bool `protobuf:"varint,3,opt,name=compile,def=0" json:"compile,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *NextRequest) Reset() { *m = NextRequest{} }
func (m *NextRequest) String() string { return proto.CompactTextString(m) }
func (*NextRequest) ProtoMessage() {}
const Default_NextRequest_Offset int32 = 0
const Default_NextRequest_Compile bool = false
func (m *NextRequest) GetHeader() *InternalHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *NextRequest) GetCursor() *Cursor {
if m != nil {
return m.Cursor
}
return nil
}
func (m *NextRequest) GetCount() int32 {
if m != nil && m.Count != nil {
return *m.Count
}
return 0
}
func (m *NextRequest) GetOffset() int32 {
if m != nil && m.Offset != nil {
return *m.Offset
}
return Default_NextRequest_Offset
}
func (m *NextRequest) GetCompile() bool {
if m != nil && m.Compile != nil {
return *m.Compile
}
return Default_NextRequest_Compile
}
type QueryResult struct {
Cursor *Cursor `protobuf:"bytes,1,opt,name=cursor" json:"cursor,omitempty"`
Result []*EntityProto `protobuf:"bytes,2,rep,name=result" json:"result,omitempty"`
SkippedResults *int32 `protobuf:"varint,7,opt,name=skipped_results" json:"skipped_results,omitempty"`
MoreResults *bool `protobuf:"varint,3,req,name=more_results" json:"more_results,omitempty"`
KeysOnly *bool `protobuf:"varint,4,opt,name=keys_only" json:"keys_only,omitempty"`
IndexOnly *bool `protobuf:"varint,9,opt,name=index_only" json:"index_only,omitempty"`
SmallOps *bool `protobuf:"varint,10,opt,name=small_ops" json:"small_ops,omitempty"`
CompiledQuery *CompiledQuery `protobuf:"bytes,5,opt,name=compiled_query" json:"compiled_query,omitempty"`
CompiledCursor *CompiledCursor `protobuf:"bytes,6,opt,name=compiled_cursor" json:"compiled_cursor,omitempty"`
Index []*CompositeIndex `protobuf:"bytes,8,rep,name=index" json:"index,omitempty"`
Version []int64 `protobuf:"varint,11,rep,name=version" json:"version,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *QueryResult) Reset() { *m = QueryResult{} }
func (m *QueryResult) String() string { return proto.CompactTextString(m) }
func (*QueryResult) ProtoMessage() {}
func (m *QueryResult) GetCursor() *Cursor {
if m != nil {
return m.Cursor
}
return nil
}
func (m *QueryResult) GetResult() []*EntityProto {
if m != nil {
return m.Result
}
return nil
}
func (m *QueryResult) GetSkippedResults() int32 {
if m != nil && m.SkippedResults != nil {
return *m.SkippedResults
}
return 0
}
func (m *QueryResult) GetMoreResults() bool {
if m != nil && m.MoreResults != nil {
return *m.MoreResults
}
return false
}
func (m *QueryResult) GetKeysOnly() bool {
if m != nil && m.KeysOnly != nil {
return *m.KeysOnly
}
return false
}
func (m *QueryResult) GetIndexOnly() bool {
if m != nil && m.IndexOnly != nil {
return *m.IndexOnly
}
return false
}
func (m *QueryResult) GetSmallOps() bool {
if m != nil && m.SmallOps != nil {
return *m.SmallOps
}
return false
}
func (m *QueryResult) GetCompiledQuery() *CompiledQuery {
if m != nil {
return m.CompiledQuery
}
return nil
}
func (m *QueryResult) GetCompiledCursor() *CompiledCursor {
if m != nil {
return m.CompiledCursor
}
return nil
}
func (m *QueryResult) GetIndex() []*CompositeIndex {
if m != nil {
return m.Index
}
return nil
}
func (m *QueryResult) GetVersion() []int64 {
if m != nil {
return m.Version
}
return nil
}
type AllocateIdsRequest struct {
Header *InternalHeader `protobuf:"bytes,4,opt,name=header" json:"header,omitempty"`
ModelKey *Reference `protobuf:"bytes,1,opt,name=model_key" json:"model_key,omitempty"`
Size *int64 `protobuf:"varint,2,opt,name=size" json:"size,omitempty"`
Max *int64 `protobuf:"varint,3,opt,name=max" json:"max,omitempty"`
Reserve []*Reference `protobuf:"bytes,5,rep,name=reserve" json:"reserve,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *AllocateIdsRequest) Reset() { *m = AllocateIdsRequest{} }
func (m *AllocateIdsRequest) String() string { return proto.CompactTextString(m) }
func (*AllocateIdsRequest) ProtoMessage() {}
func (m *AllocateIdsRequest) GetHeader() *InternalHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *AllocateIdsRequest) GetModelKey() *Reference {
if m != nil {
return m.ModelKey
}
return nil
}
func (m *AllocateIdsRequest) GetSize() int64 {
if m != nil && m.Size != nil {
return *m.Size
}
return 0
}
func (m *AllocateIdsRequest) GetMax() int64 {
if m != nil && m.Max != nil {
return *m.Max
}
return 0
}
func (m *AllocateIdsRequest) GetReserve() []*Reference {
if m != nil {
return m.Reserve
}
return nil
}
type AllocateIdsResponse struct {
Start *int64 `protobuf:"varint,1,req,name=start" json:"start,omitempty"`
End *int64 `protobuf:"varint,2,req,name=end" json:"end,omitempty"`
Cost *Cost `protobuf:"bytes,3,opt,name=cost" json:"cost,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *AllocateIdsResponse) Reset() { *m = AllocateIdsResponse{} }
func (m *AllocateIdsResponse) String() string { return proto.CompactTextString(m) }
func (*AllocateIdsResponse) ProtoMessage() {}
func (m *AllocateIdsResponse) GetStart() int64 {
if m != nil && m.Start != nil {
return *m.Start
}
return 0
}
func (m *AllocateIdsResponse) GetEnd() int64 {
if m != nil && m.End != nil {
return *m.End
}
return 0
}
func (m *AllocateIdsResponse) GetCost() *Cost {
if m != nil {
return m.Cost
}
return nil
}
type CompositeIndices struct {
Index []*CompositeIndex `protobuf:"bytes,1,rep,name=index" json:"index,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CompositeIndices) Reset() { *m = CompositeIndices{} }
func (m *CompositeIndices) String() string { return proto.CompactTextString(m) }
func (*CompositeIndices) ProtoMessage() {}
func (m *CompositeIndices) GetIndex() []*CompositeIndex {
if m != nil {
return m.Index
}
return nil
}
type AddActionsRequest struct {
Header *InternalHeader `protobuf:"bytes,3,opt,name=header" json:"header,omitempty"`
Transaction *Transaction `protobuf:"bytes,1,req,name=transaction" json:"transaction,omitempty"`
Action []*Action `protobuf:"bytes,2,rep,name=action" json:"action,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *AddActionsRequest) Reset() { *m = AddActionsRequest{} }
func (m *AddActionsRequest) String() string { return proto.CompactTextString(m) }
func (*AddActionsRequest) ProtoMessage() {}
func (m *AddActionsRequest) GetHeader() *InternalHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *AddActionsRequest) GetTransaction() *Transaction {
if m != nil {
return m.Transaction
}
return nil
}
func (m *AddActionsRequest) GetAction() []*Action {
if m != nil {
return m.Action
}
return nil
}
type AddActionsResponse struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *AddActionsResponse) Reset() { *m = AddActionsResponse{} }
func (m *AddActionsResponse) String() string { return proto.CompactTextString(m) }
func (*AddActionsResponse) ProtoMessage() {}
type BeginTransactionRequest struct {
Header *InternalHeader `protobuf:"bytes,3,opt,name=header" json:"header,omitempty"`
App *string `protobuf:"bytes,1,req,name=app" json:"app,omitempty"`
AllowMultipleEg *bool `protobuf:"varint,2,opt,name=allow_multiple_eg,def=0" json:"allow_multiple_eg,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *BeginTransactionRequest) Reset() { *m = BeginTransactionRequest{} }
func (m *BeginTransactionRequest) String() string { return proto.CompactTextString(m) }
func (*BeginTransactionRequest) ProtoMessage() {}
const Default_BeginTransactionRequest_AllowMultipleEg bool = false
func (m *BeginTransactionRequest) GetHeader() *InternalHeader {
if m != nil {
return m.Header
}
return nil
}
func (m *BeginTransactionRequest) GetApp() string {
if m != nil && m.App != nil {
return *m.App
}
return ""
}
func (m *BeginTransactionRequest) GetAllowMultipleEg() bool {
if m != nil && m.AllowMultipleEg != nil {
return *m.AllowMultipleEg
}
return Default_BeginTransactionRequest_AllowMultipleEg
}
type CommitResponse struct {
Cost *Cost `protobuf:"bytes,1,opt,name=cost" json:"cost,omitempty"`
Version []*CommitResponse_Version `protobuf:"group,3,rep,name=Version" json:"version,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CommitResponse) Reset() { *m = CommitResponse{} }
func (m *CommitResponse) String() string { return proto.CompactTextString(m) }
func (*CommitResponse) ProtoMessage() {}
func (m *CommitResponse) GetCost() *Cost {
if m != nil {
return m.Cost
}
return nil
}
func (m *CommitResponse) GetVersion() []*CommitResponse_Version {
if m != nil {
return m.Version
}
return nil
}
type CommitResponse_Version struct {
RootEntityKey *Reference `protobuf:"bytes,4,req,name=root_entity_key" json:"root_entity_key,omitempty"`
Version *int64 `protobuf:"varint,5,req,name=version" json:"version,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CommitResponse_Version) Reset() { *m = CommitResponse_Version{} }
func (m *CommitResponse_Version) String() string { return proto.CompactTextString(m) }
func (*CommitResponse_Version) ProtoMessage() {}
func (m *CommitResponse_Version) GetRootEntityKey() *Reference {
if m != nil {
return m.RootEntityKey
}
return nil
}
func (m *CommitResponse_Version) GetVersion() int64 {
if m != nil && m.Version != nil {
return *m.Version
}
return 0
}
func init() {
}
================================================
FILE: vendor/google.golang.org/appengine/internal/datastore/datastore_v3.proto
================================================
syntax = "proto2";
option go_package = "datastore";
package appengine;
message Action{}
message PropertyValue {
optional int64 int64Value = 1;
optional bool booleanValue = 2;
optional string stringValue = 3;
optional double doubleValue = 4;
optional group PointValue = 5 {
required double x = 6;
required double y = 7;
}
optional group UserValue = 8 {
required string email = 9;
required string auth_domain = 10;
optional string nickname = 11;
optional string federated_identity = 21;
optional string federated_provider = 22;
}
optional group ReferenceValue = 12 {
required string app = 13;
optional string name_space = 20;
repeated group PathElement = 14 {
required string type = 15;
optional int64 id = 16;
optional string name = 17;
}
}
}
message Property {
enum Meaning {
NO_MEANING = 0;
BLOB = 14;
TEXT = 15;
BYTESTRING = 16;
ATOM_CATEGORY = 1;
ATOM_LINK = 2;
ATOM_TITLE = 3;
ATOM_CONTENT = 4;
ATOM_SUMMARY = 5;
ATOM_AUTHOR = 6;
GD_WHEN = 7;
GD_EMAIL = 8;
GEORSS_POINT = 9;
GD_IM = 10;
GD_PHONENUMBER = 11;
GD_POSTALADDRESS = 12;
GD_RATING = 13;
BLOBKEY = 17;
ENTITY_PROTO = 19;
INDEX_VALUE = 18;
};
optional Meaning meaning = 1 [default = NO_MEANING];
optional string meaning_uri = 2;
required string name = 3;
required PropertyValue value = 5;
required bool multiple = 4;
optional bool searchable = 6 [default=false];
enum FtsTokenizationOption {
HTML = 1;
ATOM = 2;
}
optional FtsTokenizationOption fts_tokenization_option = 8;
optional string locale = 9 [default = "en"];
}
message Path {
repeated group Element = 1 {
required string type = 2;
optional int64 id = 3;
optional string name = 4;
}
}
message Reference {
required string app = 13;
optional string name_space = 20;
required Path path = 14;
}
message User {
required string email = 1;
required string auth_domain = 2;
optional string nickname = 3;
optional string federated_identity = 6;
optional string federated_provider = 7;
}
message EntityProto {
required Reference key = 13;
required Path entity_group = 16;
optional User owner = 17;
enum Kind {
GD_CONTACT = 1;
GD_EVENT = 2;
GD_MESSAGE = 3;
}
optional Kind kind = 4;
optional string kind_uri = 5;
repeated Property property = 14;
repeated Property raw_property = 15;
optional int32 rank = 18;
}
message CompositeProperty {
required int64 index_id = 1;
repeated string value = 2;
}
message Index {
required string entity_type = 1;
required bool ancestor = 5;
repeated group Property = 2 {
required string name = 3;
enum Direction {
ASCENDING = 1;
DESCENDING = 2;
}
optional Direction direction = 4 [default = ASCENDING];
}
}
message CompositeIndex {
required string app_id = 1;
required int64 id = 2;
required Index definition = 3;
enum State {
WRITE_ONLY = 1;
READ_WRITE = 2;
DELETED = 3;
ERROR = 4;
}
required State state = 4;
optional bool only_use_if_required = 6 [default = false];
}
message IndexPostfix {
message IndexValue {
required string property_name = 1;
required PropertyValue value = 2;
}
repeated IndexValue index_value = 1;
optional Reference key = 2;
optional bool before = 3 [default=true];
}
message IndexPosition {
optional string key = 1;
optional bool before = 2 [default=true];
}
message Snapshot {
enum Status {
INACTIVE = 0;
ACTIVE = 1;
}
required int64 ts = 1;
}
message InternalHeader {
optional string qos = 1;
}
message Transaction {
optional InternalHeader header = 4;
required fixed64 handle = 1;
required string app = 2;
optional bool mark_changes = 3 [default = false];
}
message Query {
optional InternalHeader header = 39;
required string app = 1;
optional string name_space = 29;
optional string kind = 3;
optional Reference ancestor = 17;
repeated group Filter = 4 {
enum Operator {
LESS_THAN = 1;
LESS_THAN_OR_EQUAL = 2;
GREATER_THAN = 3;
GREATER_THAN_OR_EQUAL = 4;
EQUAL = 5;
IN = 6;
EXISTS = 7;
}
required Operator op = 6;
repeated Property property = 14;
}
optional string search_query = 8;
repeated group Order = 9 {
enum Direction {
ASCENDING = 1;
DESCENDING = 2;
}
required string property = 10;
optional Direction direction = 11 [default = ASCENDING];
}
enum Hint {
ORDER_FIRST = 1;
ANCESTOR_FIRST = 2;
FILTER_FIRST = 3;
}
optional Hint hint = 18;
optional int32 count = 23;
optional int32 offset = 12 [default = 0];
optional int32 limit = 16;
optional CompiledCursor compiled_cursor = 30;
optional CompiledCursor end_compiled_cursor = 31;
repeated CompositeIndex composite_index = 19;
optional bool require_perfect_plan = 20 [default = false];
optional bool keys_only = 21 [default = false];
optional Transaction transaction = 22;
optional bool compile = 25 [default = false];
optional int64 failover_ms = 26;
optional bool strong = 32;
repeated string property_name = 33;
repeated string group_by_property_name = 34;
optional bool distinct = 24;
optional int64 min_safe_time_seconds = 35;
repeated string safe_replica_name = 36;
optional bool persist_offset = 37 [default=false];
}
message CompiledQuery {
required group PrimaryScan = 1 {
optional string index_name = 2;
optional string start_key = 3;
optional bool start_inclusive = 4;
optional string end_key = 5;
optional bool end_inclusive = 6;
repeated string start_postfix_value = 22;
repeated string end_postfix_value = 23;
optional int64 end_unapplied_log_timestamp_us = 19;
}
repeated group MergeJoinScan = 7 {
required string index_name = 8;
repeated string prefix_value = 9;
optional bool value_prefix = 20 [default=false];
}
optional Index index_def = 21;
optional int32 offset = 10 [default = 0];
optional int32 limit = 11;
required bool keys_only = 12;
repeated string property_name = 24;
optional int32 distinct_infix_size = 25;
optional group EntityFilter = 13 {
optional bool distinct = 14 [default=false];
optional string kind = 17;
optional Reference ancestor = 18;
}
}
message CompiledCursor {
optional group Position = 2 {
optional string start_key = 27;
repeated group IndexValue = 29 {
optional string property = 30;
required PropertyValue value = 31;
}
optional Reference key = 32;
optional bool start_inclusive = 28 [default=true];
}
}
message Cursor {
required fixed64 cursor = 1;
optional string app = 2;
}
message Error {
enum ErrorCode {
BAD_REQUEST = 1;
CONCURRENT_TRANSACTION = 2;
INTERNAL_ERROR = 3;
NEED_INDEX = 4;
TIMEOUT = 5;
PERMISSION_DENIED = 6;
BIGTABLE_ERROR = 7;
COMMITTED_BUT_STILL_APPLYING = 8;
CAPABILITY_DISABLED = 9;
TRY_ALTERNATE_BACKEND = 10;
SAFE_TIME_TOO_OLD = 11;
}
}
message Cost {
optional int32 index_writes = 1;
optional int32 index_write_bytes = 2;
optional int32 entity_writes = 3;
optional int32 entity_write_bytes = 4;
optional group CommitCost = 5 {
optional int32 requested_entity_puts = 6;
optional int32 requested_entity_deletes = 7;
};
optional int32 approximate_storage_delta = 8;
optional int32 id_sequence_updates = 9;
}
message GetRequest {
optional InternalHeader header = 6;
repeated Reference key = 1;
optional Transaction transaction = 2;
optional int64 failover_ms = 3;
optional bool strong = 4;
optional bool allow_deferred = 5 [default=false];
}
message GetResponse {
repeated group Entity = 1 {
optional EntityProto entity = 2;
optional Reference key = 4;
optional int64 version = 3;
}
repeated Reference deferred = 5;
optional bool in_order = 6 [default=true];
}
message PutRequest {
optional InternalHeader header = 11;
repeated EntityProto entity = 1;
optional Transaction transaction = 2;
repeated CompositeIndex composite_index = 3;
optional bool trusted = 4 [default = false];
optional bool force = 7 [default = false];
optional bool mark_changes = 8 [default = false];
repeated Snapshot snapshot = 9;
enum AutoIdPolicy {
CURRENT = 0;
SEQUENTIAL = 1;
}
optional AutoIdPolicy auto_id_policy = 10 [default = CURRENT];
}
message PutResponse {
repeated Reference key = 1;
optional Cost cost = 2;
repeated int64 version = 3;
}
message TouchRequest {
optional InternalHeader header = 10;
repeated Reference key = 1;
repeated CompositeIndex composite_index = 2;
optional bool force = 3 [default = false];
repeated Snapshot snapshot = 9;
}
message TouchResponse {
optional Cost cost = 1;
}
message DeleteRequest {
optional InternalHeader header = 10;
repeated Reference key = 6;
optional Transaction transaction = 5;
optional bool trusted = 4 [default = false];
optional bool force = 7 [default = false];
optional bool mark_changes = 8 [default = false];
repeated Snapshot snapshot = 9;
}
message DeleteResponse {
optional Cost cost = 1;
repeated int64 version = 3;
}
message NextRequest {
optional InternalHeader header = 5;
required Cursor cursor = 1;
optional int32 count = 2;
optional int32 offset = 4 [default = 0];
optional bool compile = 3 [default = false];
}
message QueryResult {
optional Cursor cursor = 1;
repeated EntityProto result = 2;
optional int32 skipped_results = 7;
required bool more_results = 3;
optional bool keys_only = 4;
optional bool index_only = 9;
optional bool small_ops = 10;
optional CompiledQuery compiled_query = 5;
optional CompiledCursor compiled_cursor = 6;
repeated CompositeIndex index = 8;
repeated int64 version = 11;
}
message AllocateIdsRequest {
optional InternalHeader header = 4;
optional Reference model_key = 1;
optional int64 size = 2;
optional int64 max = 3;
repeated Reference reserve = 5;
}
message AllocateIdsResponse {
required int64 start = 1;
required int64 end = 2;
optional Cost cost = 3;
}
message CompositeIndices {
repeated CompositeIndex index = 1;
}
message AddActionsRequest {
optional InternalHeader header = 3;
required Transaction transaction = 1;
repeated Action action = 2;
}
message AddActionsResponse {
}
message BeginTransactionRequest {
optional InternalHeader header = 3;
required string app = 1;
optional bool allow_multiple_eg = 2 [default = false];
}
message CommitResponse {
optional Cost cost = 1;
repeated group Version = 3 {
required Reference root_entity_key = 4;
required int64 version = 5;
}
}
================================================
FILE: vendor/google.golang.org/appengine/internal/identity.go
================================================
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
package internal
import netcontext "golang.org/x/net/context"
// These functions are implementations of the wrapper functions
// in ../appengine/identity.go. See that file for commentary.
func AppID(c netcontext.Context) string {
return appID(FullyQualifiedAppID(c))
}
================================================
FILE: vendor/google.golang.org/appengine/internal/identity_classic.go
================================================
// Copyright 2015 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
// +build appengine
package internal
import (
"appengine"
netcontext "golang.org/x/net/context"
)
func DefaultVersionHostname(ctx netcontext.Context) string {
return appengine.DefaultVersionHostname(fromContext(ctx))
}
func RequestID(ctx netcontext.Context) string { return appengine.RequestID(fromContext(ctx)) }
func Datacenter(_ netcontext.Context) string { return appengine.Datacenter() }
func ServerSoftware() string { return appengine.ServerSoftware() }
func ModuleName(ctx netcontext.Context) string { return appengine.ModuleName(fromContext(ctx)) }
func VersionID(ctx netcontext.Context) string { return appengine.VersionID(fromContext(ctx)) }
func InstanceID() string { return appengine.InstanceID() }
func IsDevAppServer() bool { return appengine.IsDevAppServer() }
func fullyQualifiedAppID(ctx netcontext.Context) string { return fromContext(ctx).FullyQualifiedAppID() }
================================================
FILE: vendor/google.golang.org/appengine/internal/identity_vm.go
================================================
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
// +build !appengine
package internal
import (
"net/http"
"os"
netcontext "golang.org/x/net/context"
)
// These functions are implementations of the wrapper functions
// in ../appengine/identity.go. See that file for commentary.
const (
hDefaultVersionHostname = "X-AppEngine-Default-Version-Hostname"
hRequestLogId = "X-AppEngine-Request-Log-Id"
hDatacenter = "X-AppEngine-Datacenter"
)
func ctxHeaders(ctx netcontext.Context) http.Header {
return fromContext(ctx).Request().Header
}
func DefaultVersionHostname(ctx netcontext.Context) string {
return ctxHeaders(ctx).Get(hDefaultVersionHostname)
}
func RequestID(ctx netcontext.Context) string {
return ctxHeaders(ctx).Get(hRequestLogId)
}
func Datacenter(ctx netcontext.Context) string {
return ctxHeaders(ctx).Get(hDatacenter)
}
func ServerSoftware() string {
// TODO(dsymonds): Remove fallback when we've verified this.
if s := os.Getenv("SERVER_SOFTWARE"); s != "" {
return s
}
return "Google App Engine/1.x.x"
}
// TODO(dsymonds): Remove the metadata fetches.
func ModuleName(_ netcontext.Context) string {
if s := os.Getenv("GAE_MODULE_NAME"); s != "" {
return s
}
return string(mustGetMetadata("instance/attributes/gae_backend_name"))
}
func VersionID(_ netcontext.Context) string {
if s1, s2 := os.Getenv("GAE_MODULE_VERSION"), os.Getenv("GAE_MINOR_VERSION"); s1 != "" && s2 != "" {
return s1 + "." + s2
}
return string(mustGetMetadata("instance/attributes/gae_backend_version")) + "." + string(mustGetMetadata("instance/attributes/gae_backend_minor_version"))
}
func InstanceID() string {
if s := os.Getenv("GAE_MODULE_INSTANCE"); s != "" {
return s
}
return string(mustGetMetadata("instance/attributes/gae_backend_instance"))
}
func partitionlessAppID() string {
// gae_project has everything except the partition prefix.
appID := os.Getenv("GAE_LONG_APP_ID")
if appID == "" {
appID = string(mustGetMetadata("instance/attributes/gae_project"))
}
return appID
}
func fullyQualifiedAppID(_ netcontext.Context) string {
appID := partitionlessAppID()
part := os.Getenv("GAE_PARTITION")
if part == "" {
part = string(mustGetMetadata("instance/attributes/gae_partition"))
}
if part != "" {
appID = part + "~" + appID
}
return appID
}
func IsDevAppServer() bool {
return os.Getenv("RUN_WITH_DEVAPPSERVER") != ""
}
================================================
FILE: vendor/google.golang.org/appengine/internal/image/images_service.pb.go
================================================
// Code generated by protoc-gen-go.
// source: google.golang.org/appengine/internal/image/images_service.proto
// DO NOT EDIT!
/*
Package image is a generated protocol buffer package.
It is generated from these files:
google.golang.org/appengine/internal/image/images_service.proto
It has these top-level messages:
ImagesServiceError
ImagesServiceTransform
Transform
ImageData
InputSettings
OutputSettings
ImagesTransformRequest
ImagesTransformResponse
CompositeImageOptions
ImagesCanvas
ImagesCompositeRequest
ImagesCompositeResponse
ImagesHistogramRequest
ImagesHistogram
ImagesHistogramResponse
ImagesGetUrlBaseRequest
ImagesGetUrlBaseResponse
ImagesDeleteUrlBaseRequest
ImagesDeleteUrlBaseResponse
*/
package image
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type ImagesServiceError_ErrorCode int32
const (
ImagesServiceError_UNSPECIFIED_ERROR ImagesServiceError_ErrorCode = 1
ImagesServiceError_BAD_TRANSFORM_DATA ImagesServiceError_ErrorCode = 2
ImagesServiceError_NOT_IMAGE ImagesServiceError_ErrorCode = 3
ImagesServiceError_BAD_IMAGE_DATA ImagesServiceError_ErrorCode = 4
ImagesServiceError_IMAGE_TOO_LARGE ImagesServiceError_ErrorCode = 5
ImagesServiceError_INVALID_BLOB_KEY ImagesServiceError_ErrorCode = 6
ImagesServiceError_ACCESS_DENIED ImagesServiceError_ErrorCode = 7
ImagesServiceError_OBJECT_NOT_FOUND ImagesServiceError_ErrorCode = 8
)
var ImagesServiceError_ErrorCode_name = map[int32]string{
1: "UNSPECIFIED_ERROR",
2: "BAD_TRANSFORM_DATA",
3: "NOT_IMAGE",
4: "BAD_IMAGE_DATA",
5: "IMAGE_TOO_LARGE",
6: "INVALID_BLOB_KEY",
7: "ACCESS_DENIED",
8: "OBJECT_NOT_FOUND",
}
var ImagesServiceError_ErrorCode_value = map[string]int32{
"UNSPECIFIED_ERROR": 1,
"BAD_TRANSFORM_DATA": 2,
"NOT_IMAGE": 3,
"BAD_IMAGE_DATA": 4,
"IMAGE_TOO_LARGE": 5,
"INVALID_BLOB_KEY": 6,
"ACCESS_DENIED": 7,
"OBJECT_NOT_FOUND": 8,
}
func (x ImagesServiceError_ErrorCode) Enum() *ImagesServiceError_ErrorCode {
p := new(ImagesServiceError_ErrorCode)
*p = x
return p
}
func (x ImagesServiceError_ErrorCode) String() string {
return proto.EnumName(ImagesServiceError_ErrorCode_name, int32(x))
}
func (x *ImagesServiceError_ErrorCode) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(ImagesServiceError_ErrorCode_value, data, "ImagesServiceError_ErrorCode")
if err != nil {
return err
}
*x = ImagesServiceError_ErrorCode(value)
return nil
}
type ImagesServiceTransform_Type int32
const (
ImagesServiceTransform_RESIZE ImagesServiceTransform_Type = 1
ImagesServiceTransform_ROTATE ImagesServiceTransform_Type = 2
ImagesServiceTransform_HORIZONTAL_FLIP ImagesServiceTransform_Type = 3
ImagesServiceTransform_VERTICAL_FLIP ImagesServiceTransform_Type = 4
ImagesServiceTransform_CROP ImagesServiceTransform_Type = 5
ImagesServiceTransform_IM_FEELING_LUCKY ImagesServiceTransform_Type = 6
)
var ImagesServiceTransform_Type_name = map[int32]string{
1: "RESIZE",
2: "ROTATE",
3: "HORIZONTAL_FLIP",
4: "VERTICAL_FLIP",
5: "CROP",
6: "IM_FEELING_LUCKY",
}
var ImagesServiceTransform_Type_value = map[string]int32{
"RESIZE": 1,
"ROTATE": 2,
"HORIZONTAL_FLIP": 3,
"VERTICAL_FLIP": 4,
"CROP": 5,
"IM_FEELING_LUCKY": 6,
}
func (x ImagesServiceTransform_Type) Enum() *ImagesServiceTransform_Type {
p := new(ImagesServiceTransform_Type)
*p = x
return p
}
func (x ImagesServiceTransform_Type) String() string {
return proto.EnumName(ImagesServiceTransform_Type_name, int32(x))
}
func (x *ImagesServiceTransform_Type) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(ImagesServiceTransform_Type_value, data, "ImagesServiceTransform_Type")
if err != nil {
return err
}
*x = ImagesServiceTransform_Type(value)
return nil
}
type InputSettings_ORIENTATION_CORRECTION_TYPE int32
const (
InputSettings_UNCHANGED_ORIENTATION InputSettings_ORIENTATION_CORRECTION_TYPE = 0
InputSettings_CORRECT_ORIENTATION InputSettings_ORIENTATION_CORRECTION_TYPE = 1
)
var InputSettings_ORIENTATION_CORRECTION_TYPE_name = map[int32]string{
0: "UNCHANGED_ORIENTATION",
1: "CORRECT_ORIENTATION",
}
var InputSettings_ORIENTATION_CORRECTION_TYPE_value = map[string]int32{
"UNCHANGED_ORIENTATION": 0,
"CORRECT_ORIENTATION": 1,
}
func (x InputSettings_ORIENTATION_CORRECTION_TYPE) Enum() *InputSettings_ORIENTATION_CORRECTION_TYPE {
p := new(InputSettings_ORIENTATION_CORRECTION_TYPE)
*p = x
return p
}
func (x InputSettings_ORIENTATION_CORRECTION_TYPE) String() string {
return proto.EnumName(InputSettings_ORIENTATION_CORRECTION_TYPE_name, int32(x))
}
func (x *InputSettings_ORIENTATION_CORRECTION_TYPE) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(InputSettings_ORIENTATION_CORRECTION_TYPE_value, data, "InputSettings_ORIENTATION_CORRECTION_TYPE")
if err != nil {
return err
}
*x = InputSettings_ORIENTATION_CORRECTION_TYPE(value)
return nil
}
type OutputSettings_MIME_TYPE int32
const (
OutputSettings_PNG OutputSettings_MIME_TYPE = 0
OutputSettings_JPEG OutputSettings_MIME_TYPE = 1
OutputSettings_WEBP OutputSettings_MIME_TYPE = 2
)
var OutputSettings_MIME_TYPE_name = map[int32]string{
0: "PNG",
1: "JPEG",
2: "WEBP",
}
var OutputSettings_MIME_TYPE_value = map[string]int32{
"PNG": 0,
"JPEG": 1,
"WEBP": 2,
}
func (x OutputSettings_MIME_TYPE) Enum() *OutputSettings_MIME_TYPE {
p := new(OutputSettings_MIME_TYPE)
*p = x
return p
}
func (x OutputSettings_MIME_TYPE) String() string {
return proto.EnumName(OutputSettings_MIME_TYPE_name, int32(x))
}
func (x *OutputSettings_MIME_TYPE) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(OutputSettings_MIME_TYPE_value, data, "OutputSettings_MIME_TYPE")
if err != nil {
return err
}
*x = OutputSettings_MIME_TYPE(value)
return nil
}
type CompositeImageOptions_ANCHOR int32
const (
CompositeImageOptions_TOP_LEFT CompositeImageOptions_ANCHOR = 0
CompositeImageOptions_TOP CompositeImageOptions_ANCHOR = 1
CompositeImageOptions_TOP_RIGHT CompositeImageOptions_ANCHOR = 2
CompositeImageOptions_LEFT CompositeImageOptions_ANCHOR = 3
CompositeImageOptions_CENTER CompositeImageOptions_ANCHOR = 4
CompositeImageOptions_RIGHT CompositeImageOptions_ANCHOR = 5
CompositeImageOptions_BOTTOM_LEFT CompositeImageOptions_ANCHOR = 6
CompositeImageOptions_BOTTOM CompositeImageOptions_ANCHOR = 7
CompositeImageOptions_BOTTOM_RIGHT CompositeImageOptions_ANCHOR = 8
)
var CompositeImageOptions_ANCHOR_name = map[int32]string{
0: "TOP_LEFT",
1: "TOP",
2: "TOP_RIGHT",
3: "LEFT",
4: "CENTER",
5: "RIGHT",
6: "BOTTOM_LEFT",
7: "BOTTOM",
8: "BOTTOM_RIGHT",
}
var CompositeImageOptions_ANCHOR_value = map[string]int32{
"TOP_LEFT": 0,
"TOP": 1,
"TOP_RIGHT": 2,
"LEFT": 3,
"CENTER": 4,
"RIGHT": 5,
"BOTTOM_LEFT": 6,
"BOTTOM": 7,
"BOTTOM_RIGHT": 8,
}
func (x CompositeImageOptions_ANCHOR) Enum() *CompositeImageOptions_ANCHOR {
p := new(CompositeImageOptions_ANCHOR)
*p = x
return p
}
func (x CompositeImageOptions_ANCHOR) String() string {
return proto.EnumName(CompositeImageOptions_ANCHOR_name, int32(x))
}
func (x *CompositeImageOptions_ANCHOR) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(CompositeImageOptions_ANCHOR_value, data, "CompositeImageOptions_ANCHOR")
if err != nil {
return err
}
*x = CompositeImageOptions_ANCHOR(value)
return nil
}
type ImagesServiceError struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *ImagesServiceError) Reset() { *m = ImagesServiceError{} }
func (m *ImagesServiceError) String() string { return proto.CompactTextString(m) }
func (*ImagesServiceError) ProtoMessage() {}
type ImagesServiceTransform struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *ImagesServiceTransform) Reset() { *m = ImagesServiceTransform{} }
func (m *ImagesServiceTransform) String() string { return proto.CompactTextString(m) }
func (*ImagesServiceTransform) ProtoMessage() {}
type Transform struct {
Width *int32 `protobuf:"varint,1,opt,name=width" json:"width,omitempty"`
Height *int32 `protobuf:"varint,2,opt,name=height" json:"height,omitempty"`
CropToFit *bool `protobuf:"varint,11,opt,name=crop_to_fit,def=0" json:"crop_to_fit,omitempty"`
CropOffsetX *float32 `protobuf:"fixed32,12,opt,name=crop_offset_x,def=0.5" json:"crop_offset_x,omitempty"`
CropOffsetY *float32 `protobuf:"fixed32,13,opt,name=crop_offset_y,def=0.5" json:"crop_offset_y,omitempty"`
Rotate *int32 `protobuf:"varint,3,opt,name=rotate,def=0" json:"rotate,omitempty"`
HorizontalFlip *bool `protobuf:"varint,4,opt,name=horizontal_flip,def=0" json:"horizontal_flip,omitempty"`
VerticalFlip *bool `protobuf:"varint,5,opt,name=vertical_flip,def=0" json:"vertical_flip,omitempty"`
CropLeftX *float32 `protobuf:"fixed32,6,opt,name=crop_left_x,def=0" json:"crop_left_x,omitempty"`
CropTopY *float32 `protobuf:"fixed32,7,opt,name=crop_top_y,def=0" json:"crop_top_y,omitempty"`
CropRightX *float32 `protobuf:"fixed32,8,opt,name=crop_right_x,def=1" json:"crop_right_x,omitempty"`
CropBottomY *float32 `protobuf:"fixed32,9,opt,name=crop_bottom_y,def=1" json:"crop_bottom_y,omitempty"`
Autolevels *bool `protobuf:"varint,10,opt,name=autolevels,def=0" json:"autolevels,omitempty"`
AllowStretch *bool `protobuf:"varint,14,opt,name=allow_stretch,def=0" json:"allow_stretch,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Transform) Reset() { *m = Transform{} }
func (m *Transform) String() string { return proto.CompactTextString(m) }
func (*Transform) ProtoMessage() {}
const Default_Transform_CropToFit bool = false
const Default_Transform_CropOffsetX float32 = 0.5
const Default_Transform_CropOffsetY float32 = 0.5
const Default_Transform_Rotate int32 = 0
const Default_Transform_HorizontalFlip bool = false
const Default_Transform_VerticalFlip bool = false
const Default_Transform_CropLeftX float32 = 0
const Default_Transform_CropTopY float32 = 0
const Default_Transform_CropRightX float32 = 1
const Default_Transform_CropBottomY float32 = 1
const Default_Transform_Autolevels bool = false
const Default_Transform_AllowStretch bool = false
func (m *Transform) GetWidth() int32 {
if m != nil && m.Width != nil {
return *m.Width
}
return 0
}
func (m *Transform) GetHeight() int32 {
if m != nil && m.Height != nil {
return *m.Height
}
return 0
}
func (m *Transform) GetCropToFit() bool {
if m != nil && m.CropToFit != nil {
return *m.CropToFit
}
return Default_Transform_CropToFit
}
func (m *Transform) GetCropOffsetX() float32 {
if m != nil && m.CropOffsetX != nil {
return *m.CropOffsetX
}
return Default_Transform_CropOffsetX
}
func (m *Transform) GetCropOffsetY() float32 {
if m != nil && m.CropOffsetY != nil {
return *m.CropOffsetY
}
return Default_Transform_CropOffsetY
}
func (m *Transform) GetRotate() int32 {
if m != nil && m.Rotate != nil {
return *m.Rotate
}
return Default_Transform_Rotate
}
func (m *Transform) GetHorizontalFlip() bool {
if m != nil && m.HorizontalFlip != nil {
return *m.HorizontalFlip
}
return Default_Transform_HorizontalFlip
}
func (m *Transform) GetVerticalFlip() bool {
if m != nil && m.VerticalFlip != nil {
return *m.VerticalFlip
}
return Default_Transform_VerticalFlip
}
func (m *Transform) GetCropLeftX() float32 {
if m != nil && m.CropLeftX != nil {
return *m.CropLeftX
}
return Default_Transform_CropLeftX
}
func (m *Transform) GetCropTopY() float32 {
if m != nil && m.CropTopY != nil {
return *m.CropTopY
}
return Default_Transform_CropTopY
}
func (m *Transform) GetCropRightX() float32 {
if m != nil && m.CropRightX != nil {
return *m.CropRightX
}
return Default_Transform_CropRightX
}
func (m *Transform) GetCropBottomY() float32 {
if m != nil && m.CropBottomY != nil {
return *m.CropBottomY
}
return Default_Transform_CropBottomY
}
func (m *Transform) GetAutolevels() bool {
if m != nil && m.Autolevels != nil {
return *m.Autolevels
}
return Default_Transform_Autolevels
}
func (m *Transform) GetAllowStretch() bool {
if m != nil && m.AllowStretch != nil {
return *m.AllowStretch
}
return Default_Transform_AllowStretch
}
type ImageData struct {
Content []byte `protobuf:"bytes,1,req,name=content" json:"content,omitempty"`
BlobKey *string `protobuf:"bytes,2,opt,name=blob_key" json:"blob_key,omitempty"`
Width *int32 `protobuf:"varint,3,opt,name=width" json:"width,omitempty"`
Height *int32 `protobuf:"varint,4,opt,name=height" json:"height,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ImageData) Reset() { *m = ImageData{} }
func (m *ImageData) String() string { return proto.CompactTextString(m) }
func (*ImageData) ProtoMessage() {}
func (m *ImageData) GetContent() []byte {
if m != nil {
return m.Content
}
return nil
}
func (m *ImageData) GetBlobKey() string {
if m != nil && m.BlobKey != nil {
return *m.BlobKey
}
return ""
}
func (m *ImageData) GetWidth() int32 {
if m != nil && m.Width != nil {
return *m.Width
}
return 0
}
func (m *ImageData) GetHeight() int32 {
if m != nil && m.Height != nil {
return *m.Height
}
return 0
}
type InputSettings struct {
CorrectExifOrientation *InputSettings_ORIENTATION_CORRECTION_TYPE `protobuf:"varint,1,opt,name=correct_exif_orientation,enum=appengine.InputSettings_ORIENTATION_CORRECTION_TYPE,def=0" json:"correct_exif_orientation,omitempty"`
ParseMetadata *bool `protobuf:"varint,2,opt,name=parse_metadata,def=0" json:"parse_metadata,omitempty"`
TransparentSubstitutionRgb *int32 `protobuf:"varint,3,opt,name=transparent_substitution_rgb" json:"transparent_substitution_rgb,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *InputSettings) Reset() { *m = InputSettings{} }
func (m *InputSettings) String() string { return proto.CompactTextString(m) }
func (*InputSettings) ProtoMessage() {}
const Default_InputSettings_CorrectExifOrientation InputSettings_ORIENTATION_CORRECTION_TYPE = InputSettings_UNCHANGED_ORIENTATION
const Default_InputSettings_ParseMetadata bool = false
func (m *InputSettings) GetCorrectExifOrientation() InputSettings_ORIENTATION_CORRECTION_TYPE {
if m != nil && m.CorrectExifOrientation != nil {
return *m.CorrectExifOrientation
}
return Default_InputSettings_CorrectExifOrientation
}
func (m *InputSettings) GetParseMetadata() bool {
if m != nil && m.ParseMetadata != nil {
return *m.ParseMetadata
}
return Default_InputSettings_ParseMetadata
}
func (m *InputSettings) GetTransparentSubstitutionRgb() int32 {
if m != nil && m.TransparentSubstitutionRgb != nil {
return *m.TransparentSubstitutionRgb
}
return 0
}
type OutputSettings struct {
MimeType *OutputSettings_MIME_TYPE `protobuf:"varint,1,opt,name=mime_type,enum=appengine.OutputSettings_MIME_TYPE,def=0" json:"mime_type,omitempty"`
Quality *int32 `protobuf:"varint,2,opt,name=quality" json:"quality,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *OutputSettings) Reset() { *m = OutputSettings{} }
func (m *OutputSettings) String() string { return proto.CompactTextString(m) }
func (*OutputSettings) ProtoMessage() {}
const Default_OutputSettings_MimeType OutputSettings_MIME_TYPE = OutputSettings_PNG
func (m *OutputSettings) GetMimeType() OutputSettings_MIME_TYPE {
if m != nil && m.MimeType != nil {
return *m.MimeType
}
return Default_OutputSettings_MimeType
}
func (m *OutputSettings) GetQuality() int32 {
if m != nil && m.Quality != nil {
return *m.Quality
}
return 0
}
type ImagesTransformRequest struct {
Image *ImageData `protobuf:"bytes,1,req,name=image" json:"image,omitempty"`
Transform []*Transform `protobuf:"bytes,2,rep,name=transform" json:"transform,omitempty"`
Output *OutputSettings `protobuf:"bytes,3,req,name=output" json:"output,omitempty"`
Input *InputSettings `protobuf:"bytes,4,opt,name=input" json:"input,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ImagesTransformRequest) Reset() { *m = ImagesTransformRequest{} }
func (m *ImagesTransformRequest) String() string { return proto.CompactTextString(m) }
func (*ImagesTransformRequest) ProtoMessage() {}
func (m *ImagesTransformRequest) GetImage() *ImageData {
if m != nil {
return m.Image
}
return nil
}
func (m *ImagesTransformRequest) GetTransform() []*Transform {
if m != nil {
return m.Transform
}
return nil
}
func (m *ImagesTransformRequest) GetOutput() *OutputSettings {
if m != nil {
return m.Output
}
return nil
}
func (m *ImagesTransformRequest) GetInput() *InputSettings {
if m != nil {
return m.Input
}
return nil
}
type ImagesTransformResponse struct {
Image *ImageData `protobuf:"bytes,1,req,name=image" json:"image,omitempty"`
SourceMetadata *string `protobuf:"bytes,2,opt,name=source_metadata" json:"source_metadata,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ImagesTransformResponse) Reset() { *m = ImagesTransformResponse{} }
func (m *ImagesTransformResponse) String() string { return proto.CompactTextString(m) }
func (*ImagesTransformResponse) ProtoMessage() {}
func (m *ImagesTransformResponse) GetImage() *ImageData {
if m != nil {
return m.Image
}
return nil
}
func (m *ImagesTransformResponse) GetSourceMetadata() string {
if m != nil && m.SourceMetadata != nil {
return *m.SourceMetadata
}
return ""
}
type CompositeImageOptions struct {
SourceIndex *int32 `protobuf:"varint,1,req,name=source_index" json:"source_index,omitempty"`
XOffset *int32 `protobuf:"varint,2,req,name=x_offset" json:"x_offset,omitempty"`
YOffset *int32 `protobuf:"varint,3,req,name=y_offset" json:"y_offset,omitempty"`
Opacity *float32 `protobuf:"fixed32,4,req,name=opacity" json:"opacity,omitempty"`
Anchor *CompositeImageOptions_ANCHOR `protobuf:"varint,5,req,name=anchor,enum=appengine.CompositeImageOptions_ANCHOR" json:"anchor,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CompositeImageOptions) Reset() { *m = CompositeImageOptions{} }
func (m *CompositeImageOptions) String() string { return proto.CompactTextString(m) }
func (*CompositeImageOptions) ProtoMessage() {}
func (m *CompositeImageOptions) GetSourceIndex() int32 {
if m != nil && m.SourceIndex != nil {
return *m.SourceIndex
}
return 0
}
func (m *CompositeImageOptions) GetXOffset() int32 {
if m != nil && m.XOffset != nil {
return *m.XOffset
}
return 0
}
func (m *CompositeImageOptions) GetYOffset() int32 {
if m != nil && m.YOffset != nil {
return *m.YOffset
}
return 0
}
func (m *CompositeImageOptions) GetOpacity() float32 {
if m != nil && m.Opacity != nil {
return *m.Opacity
}
return 0
}
func (m *CompositeImageOptions) GetAnchor() CompositeImageOptions_ANCHOR {
if m != nil && m.Anchor != nil {
return *m.Anchor
}
return CompositeImageOptions_TOP_LEFT
}
type ImagesCanvas struct {
Width *int32 `protobuf:"varint,1,req,name=width" json:"width,omitempty"`
Height *int32 `protobuf:"varint,2,req,name=height" json:"height,omitempty"`
Output *OutputSettings `protobuf:"bytes,3,req,name=output" json:"output,omitempty"`
Color *int32 `protobuf:"varint,4,opt,name=color,def=-1" json:"color,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ImagesCanvas) Reset() { *m = ImagesCanvas{} }
func (m *ImagesCanvas) String() string { return proto.CompactTextString(m) }
func (*ImagesCanvas) ProtoMessage() {}
const Default_ImagesCanvas_Color int32 = -1
func (m *ImagesCanvas) GetWidth() int32 {
if m != nil && m.Width != nil {
return *m.Width
}
return 0
}
func (m *ImagesCanvas) GetHeight() int32 {
if m != nil && m.Height != nil {
return *m.Height
}
return 0
}
func (m *ImagesCanvas) GetOutput() *OutputSettings {
if m != nil {
return m.Output
}
return nil
}
func (m *ImagesCanvas) GetColor() int32 {
if m != nil && m.Color != nil {
return *m.Color
}
return Default_ImagesCanvas_Color
}
type ImagesCompositeRequest struct {
Image []*ImageData `protobuf:"bytes,1,rep,name=image" json:"image,omitempty"`
Options []*CompositeImageOptions `protobuf:"bytes,2,rep,name=options" json:"options,omitempty"`
Canvas *ImagesCanvas `protobuf:"bytes,3,req,name=canvas" json:"canvas,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ImagesCompositeRequest) Reset() { *m = ImagesCompositeRequest{} }
func (m *ImagesCompositeRequest) String() string { return proto.CompactTextString(m) }
func (*ImagesCompositeRequest) ProtoMessage() {}
func (m *ImagesCompositeRequest) GetImage() []*ImageData {
if m != nil {
return m.Image
}
return nil
}
func (m *ImagesCompositeRequest) GetOptions() []*CompositeImageOptions {
if m != nil {
return m.Options
}
return nil
}
func (m *ImagesCompositeRequest) GetCanvas() *ImagesCanvas {
if m != nil {
return m.Canvas
}
return nil
}
type ImagesCompositeResponse struct {
Image *ImageData `protobuf:"bytes,1,req,name=image" json:"image,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ImagesCompositeResponse) Reset() { *m = ImagesCompositeResponse{} }
func (m *ImagesCompositeResponse) String() string { return proto.CompactTextString(m) }
func (*ImagesCompositeResponse) ProtoMessage() {}
func (m *ImagesCompositeResponse) GetImage() *ImageData {
if m != nil {
return m.Image
}
return nil
}
type ImagesHistogramRequest struct {
Image *ImageData `protobuf:"bytes,1,req,name=image" json:"image,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ImagesHistogramRequest) Reset() { *m = ImagesHistogramRequest{} }
func (m *ImagesHistogramRequest) String() string { return proto.CompactTextString(m) }
func (*ImagesHistogramRequest) ProtoMessage() {}
func (m *ImagesHistogramRequest) GetImage() *ImageData {
if m != nil {
return m.Image
}
return nil
}
type ImagesHistogram struct {
Red []int32 `protobuf:"varint,1,rep,name=red" json:"red,omitempty"`
Green []int32 `protobuf:"varint,2,rep,name=green" json:"green,omitempty"`
Blue []int32 `protobuf:"varint,3,rep,name=blue" json:"blue,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ImagesHistogram) Reset() { *m = ImagesHistogram{} }
func (m *ImagesHistogram) String() string { return proto.CompactTextString(m) }
func (*ImagesHistogram) ProtoMessage() {}
func (m *ImagesHistogram) GetRed() []int32 {
if m != nil {
return m.Red
}
return nil
}
func (m *ImagesHistogram) GetGreen() []int32 {
if m != nil {
return m.Green
}
return nil
}
func (m *ImagesHistogram) GetBlue() []int32 {
if m != nil {
return m.Blue
}
return nil
}
type ImagesHistogramResponse struct {
Histogram *ImagesHistogram `protobuf:"bytes,1,req,name=histogram" json:"histogram,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ImagesHistogramResponse) Reset() { *m = ImagesHistogramResponse{} }
func (m *ImagesHistogramResponse) String() string { return proto.CompactTextString(m) }
func (*ImagesHistogramResponse) ProtoMessage() {}
func (m *ImagesHistogramResponse) GetHistogram() *ImagesHistogram {
if m != nil {
return m.Histogram
}
return nil
}
type ImagesGetUrlBaseRequest struct {
BlobKey *string `protobuf:"bytes,1,req,name=blob_key" json:"blob_key,omitempty"`
CreateSecureUrl *bool `protobuf:"varint,2,opt,name=create_secure_url,def=0" json:"create_secure_url,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ImagesGetUrlBaseRequest) Reset() { *m = ImagesGetUrlBaseRequest{} }
func (m *ImagesGetUrlBaseRequest) String() string { return proto.CompactTextString(m) }
func (*ImagesGetUrlBaseRequest) ProtoMessage() {}
const Default_ImagesGetUrlBaseRequest_CreateSecureUrl bool = false
func (m *ImagesGetUrlBaseRequest) GetBlobKey() string {
if m != nil && m.BlobKey != nil {
return *m.BlobKey
}
return ""
}
func (m *ImagesGetUrlBaseRequest) GetCreateSecureUrl() bool {
if m != nil && m.CreateSecureUrl != nil {
return *m.CreateSecureUrl
}
return Default_ImagesGetUrlBaseRequest_CreateSecureUrl
}
type ImagesGetUrlBaseResponse struct {
Url *string `protobuf:"bytes,1,req,name=url" json:"url,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ImagesGetUrlBaseResponse) Reset() { *m = ImagesGetUrlBaseResponse{} }
func (m *ImagesGetUrlBaseResponse) String() string { return proto.CompactTextString(m) }
func (*ImagesGetUrlBaseResponse) ProtoMessage() {}
func (m *ImagesGetUrlBaseResponse) GetUrl() string {
if m != nil && m.Url != nil {
return *m.Url
}
return ""
}
type ImagesDeleteUrlBaseRequest struct {
BlobKey *string `protobuf:"bytes,1,req,name=blob_key" json:"blob_key,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ImagesDeleteUrlBaseRequest) Reset() { *m = ImagesDeleteUrlBaseRequest{} }
func (m *ImagesDeleteUrlBaseRequest) String() string { return proto.CompactTextString(m) }
func (*ImagesDeleteUrlBaseRequest) ProtoMessage() {}
func (m *ImagesDeleteUrlBaseRequest) GetBlobKey() string {
if m != nil && m.BlobKey != nil {
return *m.BlobKey
}
return ""
}
type ImagesDeleteUrlBaseResponse struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *ImagesDeleteUrlBaseResponse) Reset() { *m = ImagesDeleteUrlBaseResponse{} }
func (m *ImagesDeleteUrlBaseResponse) String() string { return proto.CompactTextString(m) }
func (*ImagesDeleteUrlBaseResponse) ProtoMessage() {}
func init() {
}
================================================
FILE: vendor/google.golang.org/appengine/internal/image/images_service.proto
================================================
syntax = "proto2";
option go_package = "image";
package appengine;
message ImagesServiceError {
enum ErrorCode {
UNSPECIFIED_ERROR = 1;
BAD_TRANSFORM_DATA = 2;
NOT_IMAGE = 3;
BAD_IMAGE_DATA = 4;
IMAGE_TOO_LARGE = 5;
INVALID_BLOB_KEY = 6;
ACCESS_DENIED = 7;
OBJECT_NOT_FOUND = 8;
}
}
message ImagesServiceTransform {
enum Type {
RESIZE = 1;
ROTATE = 2;
HORIZONTAL_FLIP = 3;
VERTICAL_FLIP = 4;
CROP = 5;
IM_FEELING_LUCKY = 6;
}
}
message Transform {
optional int32 width = 1;
optional int32 height = 2;
optional bool crop_to_fit = 11 [default = false];
optional float crop_offset_x = 12 [default = 0.5];
optional float crop_offset_y = 13 [default = 0.5];
optional int32 rotate = 3 [default = 0];
optional bool horizontal_flip = 4 [default = false];
optional bool vertical_flip = 5 [default = false];
optional float crop_left_x = 6 [default = 0.0];
optional float crop_top_y = 7 [default = 0.0];
optional float crop_right_x = 8 [default = 1.0];
optional float crop_bottom_y = 9 [default = 1.0];
optional bool autolevels = 10 [default = false];
optional bool allow_stretch = 14 [default = false];
}
message ImageData {
required bytes content = 1 [ctype=CORD];
optional string blob_key = 2;
optional int32 width = 3;
optional int32 height = 4;
}
message InputSettings {
enum ORIENTATION_CORRECTION_TYPE {
UNCHANGED_ORIENTATION = 0;
CORRECT_ORIENTATION = 1;
}
optional ORIENTATION_CORRECTION_TYPE correct_exif_orientation = 1
[default=UNCHANGED_ORIENTATION];
optional bool parse_metadata = 2 [default=false];
optional int32 transparent_substitution_rgb = 3;
}
message OutputSettings {
enum MIME_TYPE {
PNG = 0;
JPEG = 1;
WEBP = 2;
}
optional MIME_TYPE mime_type = 1 [default=PNG];
optional int32 quality = 2;
}
message ImagesTransformRequest {
required ImageData image = 1;
repeated Transform transform = 2;
required OutputSettings output = 3;
optional InputSettings input = 4;
}
message ImagesTransformResponse {
required ImageData image = 1;
optional string source_metadata = 2;
}
message CompositeImageOptions {
required int32 source_index = 1;
required int32 x_offset = 2;
required int32 y_offset = 3;
required float opacity = 4;
enum ANCHOR {
TOP_LEFT = 0;
TOP = 1;
TOP_RIGHT = 2;
LEFT = 3;
CENTER = 4;
RIGHT = 5;
BOTTOM_LEFT = 6;
BOTTOM = 7;
BOTTOM_RIGHT = 8;
}
required ANCHOR anchor = 5;
}
message ImagesCanvas {
required int32 width = 1;
required int32 height = 2;
required OutputSettings output = 3;
optional int32 color = 4 [default=-1];
}
message ImagesCompositeRequest {
repeated ImageData image = 1;
repeated CompositeImageOptions options = 2;
required ImagesCanvas canvas = 3;
}
message ImagesCompositeResponse {
required ImageData image = 1;
}
message ImagesHistogramRequest {
required ImageData image = 1;
}
message ImagesHistogram {
repeated int32 red = 1;
repeated int32 green = 2;
repeated int32 blue = 3;
}
message ImagesHistogramResponse {
required ImagesHistogram histogram = 1;
}
message ImagesGetUrlBaseRequest {
required string blob_key = 1;
optional bool create_secure_url = 2 [default = false];
}
message ImagesGetUrlBaseResponse {
required string url = 1;
}
message ImagesDeleteUrlBaseRequest {
required string blob_key = 1;
}
message ImagesDeleteUrlBaseResponse {
}
================================================
FILE: vendor/google.golang.org/appengine/internal/internal.go
================================================
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
// Package internal provides support for package appengine.
//
// Programs should not use this package directly. Its API is not stable.
// Use packages appengine and appengine/* instead.
package internal
import (
"fmt"
"io"
"log"
"net/http"
"net/url"
"os"
"github.com/golang/protobuf/proto"
remotepb "google.golang.org/appengine/internal/remote_api"
)
// errorCodeMaps is a map of service name to the error code map for the service.
var errorCodeMaps = make(map[string]map[int32]string)
// RegisterErrorCodeMap is called from API implementations to register their
// error code map. This should only be called from init functions.
func RegisterErrorCodeMap(service string, m map[int32]string) {
errorCodeMaps[service] = m
}
type timeoutCodeKey struct {
service string
code int32
}
// timeoutCodes is the set of service+code pairs that represent timeouts.
var timeoutCodes = make(map[timeoutCodeKey]bool)
func RegisterTimeoutErrorCode(service string, code int32) {
timeoutCodes[timeoutCodeKey{service, code}] = true
}
// APIError is the type returned by appengine.Context's Call method
// when an API call fails in an API-specific way. This may be, for instance,
// a taskqueue API call failing with TaskQueueServiceError::UNKNOWN_QUEUE.
type APIError struct {
Service string
Detail string
Code int32 // API-specific error code
}
func (e *APIError) Error() string {
if e.Code == 0 {
if e.Detail == "" {
return "APIError "
}
return e.Detail
}
s := fmt.Sprintf("API error %d", e.Code)
if m, ok := errorCodeMaps[e.Service]; ok {
s += " (" + e.Service + ": " + m[e.Code] + ")"
} else {
// Shouldn't happen, but provide a bit more detail if it does.
s = e.Service + " " + s
}
if e.Detail != "" {
s += ": " + e.Detail
}
return s
}
func (e *APIError) IsTimeout() bool {
return timeoutCodes[timeoutCodeKey{e.Service, e.Code}]
}
// CallError is the type returned by appengine.Context's Call method when an
// API call fails in a generic way, such as RpcError::CAPABILITY_DISABLED.
type CallError struct {
Detail string
Code int32
// TODO: Remove this if we get a distinguishable error code.
Timeout bool
}
func (e *CallError) Error() string {
var msg string
switch remotepb.RpcError_ErrorCode(e.Code) {
case remotepb.RpcError_UNKNOWN:
return e.Detail
case remotepb.RpcError_OVER_QUOTA:
msg = "Over quota"
case remotepb.RpcError_CAPABILITY_DISABLED:
msg = "Capability disabled"
case remotepb.RpcError_CANCELLED:
msg = "Canceled"
default:
msg = fmt.Sprintf("Call error %d", e.Code)
}
s := msg + ": " + e.Detail
if e.Timeout {
s += " (timeout)"
}
return s
}
func (e *CallError) IsTimeout() bool {
return e.Timeout
}
func Main() {
installHealthChecker(http.DefaultServeMux)
port := "8080"
if s := os.Getenv("PORT"); s != "" {
port = s
}
if err := http.ListenAndServe(":"+port, http.HandlerFunc(handleHTTP)); err != nil {
log.Fatalf("http.ListenAndServe: %v", err)
}
}
func installHealthChecker(mux *http.ServeMux) {
// If no health check handler has been installed by this point, add a trivial one.
const healthPath = "/_ah/health"
hreq := &http.Request{
Method: "GET",
URL: &url.URL{
Path: healthPath,
},
}
if _, pat := mux.Handler(hreq); pat != healthPath {
mux.HandleFunc(healthPath, func(w http.ResponseWriter, r *http.Request) {
io.WriteString(w, "ok")
})
}
}
// NamespaceMods is a map from API service to a function that will mutate an RPC request to attach a namespace.
// The function should be prepared to be called on the same message more than once; it should only modify the
// RPC request the first time.
var NamespaceMods = make(map[string]func(m proto.Message, namespace string))
================================================
FILE: vendor/google.golang.org/appengine/internal/log/log_service.pb.go
================================================
// Code generated by protoc-gen-go.
// source: google.golang.org/appengine/internal/log/log_service.proto
// DO NOT EDIT!
/*
Package log is a generated protocol buffer package.
It is generated from these files:
google.golang.org/appengine/internal/log/log_service.proto
It has these top-level messages:
LogServiceError
UserAppLogLine
UserAppLogGroup
FlushRequest
SetStatusRequest
LogOffset
LogLine
RequestLog
LogModuleVersion
LogReadRequest
LogReadResponse
LogUsageRecord
LogUsageRequest
LogUsageResponse
*/
package log
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type LogServiceError_ErrorCode int32
const (
LogServiceError_OK LogServiceError_ErrorCode = 0
LogServiceError_INVALID_REQUEST LogServiceError_ErrorCode = 1
LogServiceError_STORAGE_ERROR LogServiceError_ErrorCode = 2
)
var LogServiceError_ErrorCode_name = map[int32]string{
0: "OK",
1: "INVALID_REQUEST",
2: "STORAGE_ERROR",
}
var LogServiceError_ErrorCode_value = map[string]int32{
"OK": 0,
"INVALID_REQUEST": 1,
"STORAGE_ERROR": 2,
}
func (x LogServiceError_ErrorCode) Enum() *LogServiceError_ErrorCode {
p := new(LogServiceError_ErrorCode)
*p = x
return p
}
func (x LogServiceError_ErrorCode) String() string {
return proto.EnumName(LogServiceError_ErrorCode_name, int32(x))
}
func (x *LogServiceError_ErrorCode) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(LogServiceError_ErrorCode_value, data, "LogServiceError_ErrorCode")
if err != nil {
return err
}
*x = LogServiceError_ErrorCode(value)
return nil
}
type LogServiceError struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *LogServiceError) Reset() { *m = LogServiceError{} }
func (m *LogServiceError) String() string { return proto.CompactTextString(m) }
func (*LogServiceError) ProtoMessage() {}
type UserAppLogLine struct {
TimestampUsec *int64 `protobuf:"varint,1,req,name=timestamp_usec" json:"timestamp_usec,omitempty"`
Level *int64 `protobuf:"varint,2,req,name=level" json:"level,omitempty"`
Message *string `protobuf:"bytes,3,req,name=message" json:"message,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *UserAppLogLine) Reset() { *m = UserAppLogLine{} }
func (m *UserAppLogLine) String() string { return proto.CompactTextString(m) }
func (*UserAppLogLine) ProtoMessage() {}
func (m *UserAppLogLine) GetTimestampUsec() int64 {
if m != nil && m.TimestampUsec != nil {
return *m.TimestampUsec
}
return 0
}
func (m *UserAppLogLine) GetLevel() int64 {
if m != nil && m.Level != nil {
return *m.Level
}
return 0
}
func (m *UserAppLogLine) GetMessage() string {
if m != nil && m.Message != nil {
return *m.Message
}
return ""
}
type UserAppLogGroup struct {
LogLine []*UserAppLogLine `protobuf:"bytes,2,rep,name=log_line" json:"log_line,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *UserAppLogGroup) Reset() { *m = UserAppLogGroup{} }
func (m *UserAppLogGroup) String() string { return proto.CompactTextString(m) }
func (*UserAppLogGroup) ProtoMessage() {}
func (m *UserAppLogGroup) GetLogLine() []*UserAppLogLine {
if m != nil {
return m.LogLine
}
return nil
}
type FlushRequest struct {
Logs []byte `protobuf:"bytes,1,opt,name=logs" json:"logs,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *FlushRequest) Reset() { *m = FlushRequest{} }
func (m *FlushRequest) String() string { return proto.CompactTextString(m) }
func (*FlushRequest) ProtoMessage() {}
func (m *FlushRequest) GetLogs() []byte {
if m != nil {
return m.Logs
}
return nil
}
type SetStatusRequest struct {
Status *string `protobuf:"bytes,1,req,name=status" json:"status,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *SetStatusRequest) Reset() { *m = SetStatusRequest{} }
func (m *SetStatusRequest) String() string { return proto.CompactTextString(m) }
func (*SetStatusRequest) ProtoMessage() {}
func (m *SetStatusRequest) GetStatus() string {
if m != nil && m.Status != nil {
return *m.Status
}
return ""
}
type LogOffset struct {
RequestId []byte `protobuf:"bytes,1,opt,name=request_id" json:"request_id,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *LogOffset) Reset() { *m = LogOffset{} }
func (m *LogOffset) String() string { return proto.CompactTextString(m) }
func (*LogOffset) ProtoMessage() {}
func (m *LogOffset) GetRequestId() []byte {
if m != nil {
return m.RequestId
}
return nil
}
type LogLine struct {
Time *int64 `protobuf:"varint,1,req,name=time" json:"time,omitempty"`
Level *int32 `protobuf:"varint,2,req,name=level" json:"level,omitempty"`
LogMessage *string `protobuf:"bytes,3,req,name=log_message" json:"log_message,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *LogLine) Reset() { *m = LogLine{} }
func (m *LogLine) String() string { return proto.CompactTextString(m) }
func (*LogLine) ProtoMessage() {}
func (m *LogLine) GetTime() int64 {
if m != nil && m.Time != nil {
return *m.Time
}
return 0
}
func (m *LogLine) GetLevel() int32 {
if m != nil && m.Level != nil {
return *m.Level
}
return 0
}
func (m *LogLine) GetLogMessage() string {
if m != nil && m.LogMessage != nil {
return *m.LogMessage
}
return ""
}
type RequestLog struct {
AppId *string `protobuf:"bytes,1,req,name=app_id" json:"app_id,omitempty"`
ModuleId *string `protobuf:"bytes,37,opt,name=module_id,def=default" json:"module_id,omitempty"`
VersionId *string `protobuf:"bytes,2,req,name=version_id" json:"version_id,omitempty"`
RequestId []byte `protobuf:"bytes,3,req,name=request_id" json:"request_id,omitempty"`
Offset *LogOffset `protobuf:"bytes,35,opt,name=offset" json:"offset,omitempty"`
Ip *string `protobuf:"bytes,4,req,name=ip" json:"ip,omitempty"`
Nickname *string `protobuf:"bytes,5,opt,name=nickname" json:"nickname,omitempty"`
StartTime *int64 `protobuf:"varint,6,req,name=start_time" json:"start_time,omitempty"`
EndTime *int64 `protobuf:"varint,7,req,name=end_time" json:"end_time,omitempty"`
Latency *int64 `protobuf:"varint,8,req,name=latency" json:"latency,omitempty"`
Mcycles *int64 `protobuf:"varint,9,req,name=mcycles" json:"mcycles,omitempty"`
Method *string `protobuf:"bytes,10,req,name=method" json:"method,omitempty"`
Resource *string `protobuf:"bytes,11,req,name=resource" json:"resource,omitempty"`
HttpVersion *string `protobuf:"bytes,12,req,name=http_version" json:"http_version,omitempty"`
Status *int32 `protobuf:"varint,13,req,name=status" json:"status,omitempty"`
ResponseSize *int64 `protobuf:"varint,14,req,name=response_size" json:"response_size,omitempty"`
Referrer *string `protobuf:"bytes,15,opt,name=referrer" json:"referrer,omitempty"`
UserAgent *string `protobuf:"bytes,16,opt,name=user_agent" json:"user_agent,omitempty"`
UrlMapEntry *string `protobuf:"bytes,17,req,name=url_map_entry" json:"url_map_entry,omitempty"`
Combined *string `protobuf:"bytes,18,req,name=combined" json:"combined,omitempty"`
ApiMcycles *int64 `protobuf:"varint,19,opt,name=api_mcycles" json:"api_mcycles,omitempty"`
Host *string `protobuf:"bytes,20,opt,name=host" json:"host,omitempty"`
Cost *float64 `protobuf:"fixed64,21,opt,name=cost" json:"cost,omitempty"`
TaskQueueName *string `protobuf:"bytes,22,opt,name=task_queue_name" json:"task_queue_name,omitempty"`
TaskName *string `protobuf:"bytes,23,opt,name=task_name" json:"task_name,omitempty"`
WasLoadingRequest *bool `protobuf:"varint,24,opt,name=was_loading_request" json:"was_loading_request,omitempty"`
PendingTime *int64 `protobuf:"varint,25,opt,name=pending_time" json:"pending_time,omitempty"`
ReplicaIndex *int32 `protobuf:"varint,26,opt,name=replica_index,def=-1" json:"replica_index,omitempty"`
Finished *bool `protobuf:"varint,27,opt,name=finished,def=1" json:"finished,omitempty"`
CloneKey []byte `protobuf:"bytes,28,opt,name=clone_key" json:"clone_key,omitempty"`
Line []*LogLine `protobuf:"bytes,29,rep,name=line" json:"line,omitempty"`
LinesIncomplete *bool `protobuf:"varint,36,opt,name=lines_incomplete" json:"lines_incomplete,omitempty"`
AppEngineRelease []byte `protobuf:"bytes,38,opt,name=app_engine_release" json:"app_engine_release,omitempty"`
ExitReason *int32 `protobuf:"varint,30,opt,name=exit_reason" json:"exit_reason,omitempty"`
WasThrottledForTime *bool `protobuf:"varint,31,opt,name=was_throttled_for_time" json:"was_throttled_for_time,omitempty"`
WasThrottledForRequests *bool `protobuf:"varint,32,opt,name=was_throttled_for_requests" json:"was_throttled_for_requests,omitempty"`
ThrottledTime *int64 `protobuf:"varint,33,opt,name=throttled_time" json:"throttled_time,omitempty"`
ServerName []byte `protobuf:"bytes,34,opt,name=server_name" json:"server_name,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *RequestLog) Reset() { *m = RequestLog{} }
func (m *RequestLog) String() string { return proto.CompactTextString(m) }
func (*RequestLog) ProtoMessage() {}
const Default_RequestLog_ModuleId string = "default"
const Default_RequestLog_ReplicaIndex int32 = -1
const Default_RequestLog_Finished bool = true
func (m *RequestLog) GetAppId() string {
if m != nil && m.AppId != nil {
return *m.AppId
}
return ""
}
func (m *RequestLog) GetModuleId() string {
if m != nil && m.ModuleId != nil {
return *m.ModuleId
}
return Default_RequestLog_ModuleId
}
func (m *RequestLog) GetVersionId() string {
if m != nil && m.VersionId != nil {
return *m.VersionId
}
return ""
}
func (m *RequestLog) GetRequestId() []byte {
if m != nil {
return m.RequestId
}
return nil
}
func (m *RequestLog) GetOffset() *LogOffset {
if m != nil {
return m.Offset
}
return nil
}
func (m *RequestLog) GetIp() string {
if m != nil && m.Ip != nil {
return *m.Ip
}
return ""
}
func (m *RequestLog) GetNickname() string {
if m != nil && m.Nickname != nil {
return *m.Nickname
}
return ""
}
func (m *RequestLog) GetStartTime() int64 {
if m != nil && m.StartTime != nil {
return *m.StartTime
}
return 0
}
func (m *RequestLog) GetEndTime() int64 {
if m != nil && m.EndTime != nil {
return *m.EndTime
}
return 0
}
func (m *RequestLog) GetLatency() int64 {
if m != nil && m.Latency != nil {
return *m.Latency
}
return 0
}
func (m *RequestLog) GetMcycles() int64 {
if m != nil && m.Mcycles != nil {
return *m.Mcycles
}
return 0
}
func (m *RequestLog) GetMethod() string {
if m != nil && m.Method != nil {
return *m.Method
}
return ""
}
func (m *RequestLog) GetResource() string {
if m != nil && m.Resource != nil {
return *m.Resource
}
return ""
}
func (m *RequestLog) GetHttpVersion() string {
if m != nil && m.HttpVersion != nil {
return *m.HttpVersion
}
return ""
}
func (m *RequestLog) GetStatus() int32 {
if m != nil && m.Status != nil {
return *m.Status
}
return 0
}
func (m *RequestLog) GetResponseSize() int64 {
if m != nil && m.ResponseSize != nil {
return *m.ResponseSize
}
return 0
}
func (m *RequestLog) GetReferrer() string {
if m != nil && m.Referrer != nil {
return *m.Referrer
}
return ""
}
func (m *RequestLog) GetUserAgent() string {
if m != nil && m.UserAgent != nil {
return *m.UserAgent
}
return ""
}
func (m *RequestLog) GetUrlMapEntry() string {
if m != nil && m.UrlMapEntry != nil {
return *m.UrlMapEntry
}
return ""
}
func (m *RequestLog) GetCombined() string {
if m != nil && m.Combined != nil {
return *m.Combined
}
return ""
}
func (m *RequestLog) GetApiMcycles() int64 {
if m != nil && m.ApiMcycles != nil {
return *m.ApiMcycles
}
return 0
}
func (m *RequestLog) GetHost() string {
if m != nil && m.Host != nil {
return *m.Host
}
return ""
}
func (m *RequestLog) GetCost() float64 {
if m != nil && m.Cost != nil {
return *m.Cost
}
return 0
}
func (m *RequestLog) GetTaskQueueName() string {
if m != nil && m.TaskQueueName != nil {
return *m.TaskQueueName
}
return ""
}
func (m *RequestLog) GetTaskName() string {
if m != nil && m.TaskName != nil {
return *m.TaskName
}
return ""
}
func (m *RequestLog) GetWasLoadingRequest() bool {
if m != nil && m.WasLoadingRequest != nil {
return *m.WasLoadingRequest
}
return false
}
func (m *RequestLog) GetPendingTime() int64 {
if m != nil && m.PendingTime != nil {
return *m.PendingTime
}
return 0
}
func (m *RequestLog) GetReplicaIndex() int32 {
if m != nil && m.ReplicaIndex != nil {
return *m.ReplicaIndex
}
return Default_RequestLog_ReplicaIndex
}
func (m *RequestLog) GetFinished() bool {
if m != nil && m.Finished != nil {
return *m.Finished
}
return Default_RequestLog_Finished
}
func (m *RequestLog) GetCloneKey() []byte {
if m != nil {
return m.CloneKey
}
return nil
}
func (m *RequestLog) GetLine() []*LogLine {
if m != nil {
return m.Line
}
return nil
}
func (m *RequestLog) GetLinesIncomplete() bool {
if m != nil && m.LinesIncomplete != nil {
return *m.LinesIncomplete
}
return false
}
func (m *RequestLog) GetAppEngineRelease() []byte {
if m != nil {
return m.AppEngineRelease
}
return nil
}
func (m *RequestLog) GetExitReason() int32 {
if m != nil && m.ExitReason != nil {
return *m.ExitReason
}
return 0
}
func (m *RequestLog) GetWasThrottledForTime() bool {
if m != nil && m.WasThrottledForTime != nil {
return *m.WasThrottledForTime
}
return false
}
func (m *RequestLog) GetWasThrottledForRequests() bool {
if m != nil && m.WasThrottledForRequests != nil {
return *m.WasThrottledForRequests
}
return false
}
func (m *RequestLog) GetThrottledTime() int64 {
if m != nil && m.ThrottledTime != nil {
return *m.ThrottledTime
}
return 0
}
func (m *RequestLog) GetServerName() []byte {
if m != nil {
return m.ServerName
}
return nil
}
type LogModuleVersion struct {
ModuleId *string `protobuf:"bytes,1,opt,name=module_id,def=default" json:"module_id,omitempty"`
VersionId *string `protobuf:"bytes,2,opt,name=version_id" json:"version_id,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *LogModuleVersion) Reset() { *m = LogModuleVersion{} }
func (m *LogModuleVersion) String() string { return proto.CompactTextString(m) }
func (*LogModuleVersion) ProtoMessage() {}
const Default_LogModuleVersion_ModuleId string = "default"
func (m *LogModuleVersion) GetModuleId() string {
if m != nil && m.ModuleId != nil {
return *m.ModuleId
}
return Default_LogModuleVersion_ModuleId
}
func (m *LogModuleVersion) GetVersionId() string {
if m != nil && m.VersionId != nil {
return *m.VersionId
}
return ""
}
type LogReadRequest struct {
AppId *string `protobuf:"bytes,1,req,name=app_id" json:"app_id,omitempty"`
VersionId []string `protobuf:"bytes,2,rep,name=version_id" json:"version_id,omitempty"`
ModuleVersion []*LogModuleVersion `protobuf:"bytes,19,rep,name=module_version" json:"module_version,omitempty"`
StartTime *int64 `protobuf:"varint,3,opt,name=start_time" json:"start_time,omitempty"`
EndTime *int64 `protobuf:"varint,4,opt,name=end_time" json:"end_time,omitempty"`
Offset *LogOffset `protobuf:"bytes,5,opt,name=offset" json:"offset,omitempty"`
RequestId [][]byte `protobuf:"bytes,6,rep,name=request_id" json:"request_id,omitempty"`
MinimumLogLevel *int32 `protobuf:"varint,7,opt,name=minimum_log_level" json:"minimum_log_level,omitempty"`
IncludeIncomplete *bool `protobuf:"varint,8,opt,name=include_incomplete" json:"include_incomplete,omitempty"`
Count *int64 `protobuf:"varint,9,opt,name=count" json:"count,omitempty"`
CombinedLogRegex *string `protobuf:"bytes,14,opt,name=combined_log_regex" json:"combined_log_regex,omitempty"`
HostRegex *string `protobuf:"bytes,15,opt,name=host_regex" json:"host_regex,omitempty"`
ReplicaIndex *int32 `protobuf:"varint,16,opt,name=replica_index" json:"replica_index,omitempty"`
IncludeAppLogs *bool `protobuf:"varint,10,opt,name=include_app_logs" json:"include_app_logs,omitempty"`
AppLogsPerRequest *int32 `protobuf:"varint,17,opt,name=app_logs_per_request" json:"app_logs_per_request,omitempty"`
IncludeHost *bool `protobuf:"varint,11,opt,name=include_host" json:"include_host,omitempty"`
IncludeAll *bool `protobuf:"varint,12,opt,name=include_all" json:"include_all,omitempty"`
CacheIterator *bool `protobuf:"varint,13,opt,name=cache_iterator" json:"cache_iterator,omitempty"`
NumShards *int32 `protobuf:"varint,18,opt,name=num_shards" json:"num_shards,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *LogReadRequest) Reset() { *m = LogReadRequest{} }
func (m *LogReadRequest) String() string { return proto.CompactTextString(m) }
func (*LogReadRequest) ProtoMessage() {}
func (m *LogReadRequest) GetAppId() string {
if m != nil && m.AppId != nil {
return *m.AppId
}
return ""
}
func (m *LogReadRequest) GetVersionId() []string {
if m != nil {
return m.VersionId
}
return nil
}
func (m *LogReadRequest) GetModuleVersion() []*LogModuleVersion {
if m != nil {
return m.ModuleVersion
}
return nil
}
func (m *LogReadRequest) GetStartTime() int64 {
if m != nil && m.StartTime != nil {
return *m.StartTime
}
return 0
}
func (m *LogReadRequest) GetEndTime() int64 {
if m != nil && m.EndTime != nil {
return *m.EndTime
}
return 0
}
func (m *LogReadRequest) GetOffset() *LogOffset {
if m != nil {
return m.Offset
}
return nil
}
func (m *LogReadRequest) GetRequestId() [][]byte {
if m != nil {
return m.RequestId
}
return nil
}
func (m *LogReadRequest) GetMinimumLogLevel() int32 {
if m != nil && m.MinimumLogLevel != nil {
return *m.MinimumLogLevel
}
return 0
}
func (m *LogReadRequest) GetIncludeIncomplete() bool {
if m != nil && m.IncludeIncomplete != nil {
return *m.IncludeIncomplete
}
return false
}
func (m *LogReadRequest) GetCount() int64 {
if m != nil && m.Count != nil {
return *m.Count
}
return 0
}
func (m *LogReadRequest) GetCombinedLogRegex() string {
if m != nil && m.CombinedLogRegex != nil {
return *m.CombinedLogRegex
}
return ""
}
func (m *LogReadRequest) GetHostRegex() string {
if m != nil && m.HostRegex != nil {
return *m.HostRegex
}
return ""
}
func (m *LogReadRequest) GetReplicaIndex() int32 {
if m != nil && m.ReplicaIndex != nil {
return *m.ReplicaIndex
}
return 0
}
func (m *LogReadRequest) GetIncludeAppLogs() bool {
if m != nil && m.IncludeAppLogs != nil {
return *m.IncludeAppLogs
}
return false
}
func (m *LogReadRequest) GetAppLogsPerRequest() int32 {
if m != nil && m.AppLogsPerRequest != nil {
return *m.AppLogsPerRequest
}
return 0
}
func (m *LogReadRequest) GetIncludeHost() bool {
if m != nil && m.IncludeHost != nil {
return *m.IncludeHost
}
return false
}
func (m *LogReadRequest) GetIncludeAll() bool {
if m != nil && m.IncludeAll != nil {
return *m.IncludeAll
}
return false
}
func (m *LogReadRequest) GetCacheIterator() bool {
if m != nil && m.CacheIterator != nil {
return *m.CacheIterator
}
return false
}
func (m *LogReadRequest) GetNumShards() int32 {
if m != nil && m.NumShards != nil {
return *m.NumShards
}
return 0
}
type LogReadResponse struct {
Log []*RequestLog `protobuf:"bytes,1,rep,name=log" json:"log,omitempty"`
Offset *LogOffset `protobuf:"bytes,2,opt,name=offset" json:"offset,omitempty"`
LastEndTime *int64 `protobuf:"varint,3,opt,name=last_end_time" json:"last_end_time,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *LogReadResponse) Reset() { *m = LogReadResponse{} }
func (m *LogReadResponse) String() string { return proto.CompactTextString(m) }
func (*LogReadResponse) ProtoMessage() {}
func (m *LogReadResponse) GetLog() []*RequestLog {
if m != nil {
return m.Log
}
return nil
}
func (m *LogReadResponse) GetOffset() *LogOffset {
if m != nil {
return m.Offset
}
return nil
}
func (m *LogReadResponse) GetLastEndTime() int64 {
if m != nil && m.LastEndTime != nil {
return *m.LastEndTime
}
return 0
}
type LogUsageRecord struct {
VersionId *string `protobuf:"bytes,1,opt,name=version_id" json:"version_id,omitempty"`
StartTime *int32 `protobuf:"varint,2,opt,name=start_time" json:"start_time,omitempty"`
EndTime *int32 `protobuf:"varint,3,opt,name=end_time" json:"end_time,omitempty"`
Count *int64 `protobuf:"varint,4,opt,name=count" json:"count,omitempty"`
TotalSize *int64 `protobuf:"varint,5,opt,name=total_size" json:"total_size,omitempty"`
Records *int32 `protobuf:"varint,6,opt,name=records" json:"records,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *LogUsageRecord) Reset() { *m = LogUsageRecord{} }
func (m *LogUsageRecord) String() string { return proto.CompactTextString(m) }
func (*LogUsageRecord) ProtoMessage() {}
func (m *LogUsageRecord) GetVersionId() string {
if m != nil && m.VersionId != nil {
return *m.VersionId
}
return ""
}
func (m *LogUsageRecord) GetStartTime() int32 {
if m != nil && m.StartTime != nil {
return *m.StartTime
}
return 0
}
func (m *LogUsageRecord) GetEndTime() int32 {
if m != nil && m.EndTime != nil {
return *m.EndTime
}
return 0
}
func (m *LogUsageRecord) GetCount() int64 {
if m != nil && m.Count != nil {
return *m.Count
}
return 0
}
func (m *LogUsageRecord) GetTotalSize() int64 {
if m != nil && m.TotalSize != nil {
return *m.TotalSize
}
return 0
}
func (m *LogUsageRecord) GetRecords() int32 {
if m != nil && m.Records != nil {
return *m.Records
}
return 0
}
type LogUsageRequest struct {
AppId *string `protobuf:"bytes,1,req,name=app_id" json:"app_id,omitempty"`
VersionId []string `protobuf:"bytes,2,rep,name=version_id" json:"version_id,omitempty"`
StartTime *int32 `protobuf:"varint,3,opt,name=start_time" json:"start_time,omitempty"`
EndTime *int32 `protobuf:"varint,4,opt,name=end_time" json:"end_time,omitempty"`
ResolutionHours *uint32 `protobuf:"varint,5,opt,name=resolution_hours,def=1" json:"resolution_hours,omitempty"`
CombineVersions *bool `protobuf:"varint,6,opt,name=combine_versions" json:"combine_versions,omitempty"`
UsageVersion *int32 `protobuf:"varint,7,opt,name=usage_version" json:"usage_version,omitempty"`
VersionsOnly *bool `protobuf:"varint,8,opt,name=versions_only" json:"versions_only,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *LogUsageRequest) Reset() { *m = LogUsageRequest{} }
func (m *LogUsageRequest) String() string { return proto.CompactTextString(m) }
func (*LogUsageRequest) ProtoMessage() {}
const Default_LogUsageRequest_ResolutionHours uint32 = 1
func (m *LogUsageRequest) GetAppId() string {
if m != nil && m.AppId != nil {
return *m.AppId
}
return ""
}
func (m *LogUsageRequest) GetVersionId() []string {
if m != nil {
return m.VersionId
}
return nil
}
func (m *LogUsageRequest) GetStartTime() int32 {
if m != nil && m.StartTime != nil {
return *m.StartTime
}
return 0
}
func (m *LogUsageRequest) GetEndTime() int32 {
if m != nil && m.EndTime != nil {
return *m.EndTime
}
return 0
}
func (m *LogUsageRequest) GetResolutionHours() uint32 {
if m != nil && m.ResolutionHours != nil {
return *m.ResolutionHours
}
return Default_LogUsageRequest_ResolutionHours
}
func (m *LogUsageRequest) GetCombineVersions() bool {
if m != nil && m.CombineVersions != nil {
return *m.CombineVersions
}
return false
}
func (m *LogUsageRequest) GetUsageVersion() int32 {
if m != nil && m.UsageVersion != nil {
return *m.UsageVersion
}
return 0
}
func (m *LogUsageRequest) GetVersionsOnly() bool {
if m != nil && m.VersionsOnly != nil {
return *m.VersionsOnly
}
return false
}
type LogUsageResponse struct {
Usage []*LogUsageRecord `protobuf:"bytes,1,rep,name=usage" json:"usage,omitempty"`
Summary *LogUsageRecord `protobuf:"bytes,2,opt,name=summary" json:"summary,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *LogUsageResponse) Reset() { *m = LogUsageResponse{} }
func (m *LogUsageResponse) String() string { return proto.CompactTextString(m) }
func (*LogUsageResponse) ProtoMessage() {}
func (m *LogUsageResponse) GetUsage() []*LogUsageRecord {
if m != nil {
return m.Usage
}
return nil
}
func (m *LogUsageResponse) GetSummary() *LogUsageRecord {
if m != nil {
return m.Summary
}
return nil
}
func init() {
}
================================================
FILE: vendor/google.golang.org/appengine/internal/log/log_service.proto
================================================
syntax = "proto2";
option go_package = "log";
package appengine;
message LogServiceError {
enum ErrorCode {
OK = 0;
INVALID_REQUEST = 1;
STORAGE_ERROR = 2;
}
}
message UserAppLogLine {
required int64 timestamp_usec = 1;
required int64 level = 2;
required string message = 3;
}
message UserAppLogGroup {
repeated UserAppLogLine log_line = 2;
}
message FlushRequest {
optional bytes logs = 1;
}
message SetStatusRequest {
required string status = 1;
}
message LogOffset {
optional bytes request_id = 1;
}
message LogLine {
required int64 time = 1;
required int32 level = 2;
required string log_message = 3;
}
message RequestLog {
required string app_id = 1;
optional string module_id = 37 [default="default"];
required string version_id = 2;
required bytes request_id = 3;
optional LogOffset offset = 35;
required string ip = 4;
optional string nickname = 5;
required int64 start_time = 6;
required int64 end_time = 7;
required int64 latency = 8;
required int64 mcycles = 9;
required string method = 10;
required string resource = 11;
required string http_version = 12;
required int32 status = 13;
required int64 response_size = 14;
optional string referrer = 15;
optional string user_agent = 16;
required string url_map_entry = 17;
required string combined = 18;
optional int64 api_mcycles = 19;
optional string host = 20;
optional double cost = 21;
optional string task_queue_name = 22;
optional string task_name = 23;
optional bool was_loading_request = 24;
optional int64 pending_time = 25;
optional int32 replica_index = 26 [default = -1];
optional bool finished = 27 [default = true];
optional bytes clone_key = 28;
repeated LogLine line = 29;
optional bool lines_incomplete = 36;
optional bytes app_engine_release = 38;
optional int32 exit_reason = 30;
optional bool was_throttled_for_time = 31;
optional bool was_throttled_for_requests = 32;
optional int64 throttled_time = 33;
optional bytes server_name = 34;
}
message LogModuleVersion {
optional string module_id = 1 [default="default"];
optional string version_id = 2;
}
message LogReadRequest {
required string app_id = 1;
repeated string version_id = 2;
repeated LogModuleVersion module_version = 19;
optional int64 start_time = 3;
optional int64 end_time = 4;
optional LogOffset offset = 5;
repeated bytes request_id = 6;
optional int32 minimum_log_level = 7;
optional bool include_incomplete = 8;
optional int64 count = 9;
optional string combined_log_regex = 14;
optional string host_regex = 15;
optional int32 replica_index = 16;
optional bool include_app_logs = 10;
optional int32 app_logs_per_request = 17;
optional bool include_host = 11;
optional bool include_all = 12;
optional bool cache_iterator = 13;
optional int32 num_shards = 18;
}
message LogReadResponse {
repeated RequestLog log = 1;
optional LogOffset offset = 2;
optional int64 last_end_time = 3;
}
message LogUsageRecord {
optional string version_id = 1;
optional int32 start_time = 2;
optional int32 end_time = 3;
optional int64 count = 4;
optional int64 total_size = 5;
optional int32 records = 6;
}
message LogUsageRequest {
required string app_id = 1;
repeated string version_id = 2;
optional int32 start_time = 3;
optional int32 end_time = 4;
optional uint32 resolution_hours = 5 [default = 1];
optional bool combine_versions = 6;
optional int32 usage_version = 7;
optional bool versions_only = 8;
}
message LogUsageResponse {
repeated LogUsageRecord usage = 1;
optional LogUsageRecord summary = 2;
}
================================================
FILE: vendor/google.golang.org/appengine/internal/mail/mail_service.pb.go
================================================
// Code generated by protoc-gen-go.
// source: google.golang.org/appengine/internal/mail/mail_service.proto
// DO NOT EDIT!
/*
Package mail is a generated protocol buffer package.
It is generated from these files:
google.golang.org/appengine/internal/mail/mail_service.proto
It has these top-level messages:
MailServiceError
MailAttachment
MailHeader
MailMessage
*/
package mail
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type MailServiceError_ErrorCode int32
const (
MailServiceError_OK MailServiceError_ErrorCode = 0
MailServiceError_INTERNAL_ERROR MailServiceError_ErrorCode = 1
MailServiceError_BAD_REQUEST MailServiceError_ErrorCode = 2
MailServiceError_UNAUTHORIZED_SENDER MailServiceError_ErrorCode = 3
MailServiceError_INVALID_ATTACHMENT_TYPE MailServiceError_ErrorCode = 4
MailServiceError_INVALID_HEADER_NAME MailServiceError_ErrorCode = 5
MailServiceError_INVALID_CONTENT_ID MailServiceError_ErrorCode = 6
)
var MailServiceError_ErrorCode_name = map[int32]string{
0: "OK",
1: "INTERNAL_ERROR",
2: "BAD_REQUEST",
3: "UNAUTHORIZED_SENDER",
4: "INVALID_ATTACHMENT_TYPE",
5: "INVALID_HEADER_NAME",
6: "INVALID_CONTENT_ID",
}
var MailServiceError_ErrorCode_value = map[string]int32{
"OK": 0,
"INTERNAL_ERROR": 1,
"BAD_REQUEST": 2,
"UNAUTHORIZED_SENDER": 3,
"INVALID_ATTACHMENT_TYPE": 4,
"INVALID_HEADER_NAME": 5,
"INVALID_CONTENT_ID": 6,
}
func (x MailServiceError_ErrorCode) Enum() *MailServiceError_ErrorCode {
p := new(MailServiceError_ErrorCode)
*p = x
return p
}
func (x MailServiceError_ErrorCode) String() string {
return proto.EnumName(MailServiceError_ErrorCode_name, int32(x))
}
func (x *MailServiceError_ErrorCode) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(MailServiceError_ErrorCode_value, data, "MailServiceError_ErrorCode")
if err != nil {
return err
}
*x = MailServiceError_ErrorCode(value)
return nil
}
type MailServiceError struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *MailServiceError) Reset() { *m = MailServiceError{} }
func (m *MailServiceError) String() string { return proto.CompactTextString(m) }
func (*MailServiceError) ProtoMessage() {}
type MailAttachment struct {
FileName *string `protobuf:"bytes,1,req,name=FileName" json:"FileName,omitempty"`
Data []byte `protobuf:"bytes,2,req,name=Data" json:"Data,omitempty"`
ContentID *string `protobuf:"bytes,3,opt,name=ContentID" json:"ContentID,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *MailAttachment) Reset() { *m = MailAttachment{} }
func (m *MailAttachment) String() string { return proto.CompactTextString(m) }
func (*MailAttachment) ProtoMessage() {}
func (m *MailAttachment) GetFileName() string {
if m != nil && m.FileName != nil {
return *m.FileName
}
return ""
}
func (m *MailAttachment) GetData() []byte {
if m != nil {
return m.Data
}
return nil
}
func (m *MailAttachment) GetContentID() string {
if m != nil && m.ContentID != nil {
return *m.ContentID
}
return ""
}
type MailHeader struct {
Name *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
Value *string `protobuf:"bytes,2,req,name=value" json:"value,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *MailHeader) Reset() { *m = MailHeader{} }
func (m *MailHeader) String() string { return proto.CompactTextString(m) }
func (*MailHeader) ProtoMessage() {}
func (m *MailHeader) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *MailHeader) GetValue() string {
if m != nil && m.Value != nil {
return *m.Value
}
return ""
}
type MailMessage struct {
Sender *string `protobuf:"bytes,1,req,name=Sender" json:"Sender,omitempty"`
ReplyTo *string `protobuf:"bytes,2,opt,name=ReplyTo" json:"ReplyTo,omitempty"`
To []string `protobuf:"bytes,3,rep,name=To" json:"To,omitempty"`
Cc []string `protobuf:"bytes,4,rep,name=Cc" json:"Cc,omitempty"`
Bcc []string `protobuf:"bytes,5,rep,name=Bcc" json:"Bcc,omitempty"`
Subject *string `protobuf:"bytes,6,req,name=Subject" json:"Subject,omitempty"`
TextBody *string `protobuf:"bytes,7,opt,name=TextBody" json:"TextBody,omitempty"`
HtmlBody *string `protobuf:"bytes,8,opt,name=HtmlBody" json:"HtmlBody,omitempty"`
Attachment []*MailAttachment `protobuf:"bytes,9,rep,name=Attachment" json:"Attachment,omitempty"`
Header []*MailHeader `protobuf:"bytes,10,rep,name=Header" json:"Header,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *MailMessage) Reset() { *m = MailMessage{} }
func (m *MailMessage) String() string { return proto.CompactTextString(m) }
func (*MailMessage) ProtoMessage() {}
func (m *MailMessage) GetSender() string {
if m != nil && m.Sender != nil {
return *m.Sender
}
return ""
}
func (m *MailMessage) GetReplyTo() string {
if m != nil && m.ReplyTo != nil {
return *m.ReplyTo
}
return ""
}
func (m *MailMessage) GetTo() []string {
if m != nil {
return m.To
}
return nil
}
func (m *MailMessage) GetCc() []string {
if m != nil {
return m.Cc
}
return nil
}
func (m *MailMessage) GetBcc() []string {
if m != nil {
return m.Bcc
}
return nil
}
func (m *MailMessage) GetSubject() string {
if m != nil && m.Subject != nil {
return *m.Subject
}
return ""
}
func (m *MailMessage) GetTextBody() string {
if m != nil && m.TextBody != nil {
return *m.TextBody
}
return ""
}
func (m *MailMessage) GetHtmlBody() string {
if m != nil && m.HtmlBody != nil {
return *m.HtmlBody
}
return ""
}
func (m *MailMessage) GetAttachment() []*MailAttachment {
if m != nil {
return m.Attachment
}
return nil
}
func (m *MailMessage) GetHeader() []*MailHeader {
if m != nil {
return m.Header
}
return nil
}
func init() {
}
================================================
FILE: vendor/google.golang.org/appengine/internal/mail/mail_service.proto
================================================
syntax = "proto2";
option go_package = "mail";
package appengine;
message MailServiceError {
enum ErrorCode {
OK = 0;
INTERNAL_ERROR = 1;
BAD_REQUEST = 2;
UNAUTHORIZED_SENDER = 3;
INVALID_ATTACHMENT_TYPE = 4;
INVALID_HEADER_NAME = 5;
INVALID_CONTENT_ID = 6;
}
}
message MailAttachment {
required string FileName = 1;
required bytes Data = 2;
optional string ContentID = 3;
}
message MailHeader {
required string name = 1;
required string value = 2;
}
message MailMessage {
required string Sender = 1;
optional string ReplyTo = 2;
repeated string To = 3;
repeated string Cc = 4;
repeated string Bcc = 5;
required string Subject = 6;
optional string TextBody = 7;
optional string HtmlBody = 8;
repeated MailAttachment Attachment = 9;
repeated MailHeader Header = 10;
}
================================================
FILE: vendor/google.golang.org/appengine/internal/memcache/memcache_service.pb.go
================================================
// Code generated by protoc-gen-go.
// source: google.golang.org/appengine/internal/memcache/memcache_service.proto
// DO NOT EDIT!
/*
Package memcache is a generated protocol buffer package.
It is generated from these files:
google.golang.org/appengine/internal/memcache/memcache_service.proto
It has these top-level messages:
MemcacheServiceError
AppOverride
MemcacheGetRequest
MemcacheGetResponse
MemcacheSetRequest
MemcacheSetResponse
MemcacheDeleteRequest
MemcacheDeleteResponse
MemcacheIncrementRequest
MemcacheIncrementResponse
MemcacheBatchIncrementRequest
MemcacheBatchIncrementResponse
MemcacheFlushRequest
MemcacheFlushResponse
MemcacheStatsRequest
MergedNamespaceStats
MemcacheStatsResponse
MemcacheGrabTailRequest
MemcacheGrabTailResponse
*/
package memcache
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type MemcacheServiceError_ErrorCode int32
const (
MemcacheServiceError_OK MemcacheServiceError_ErrorCode = 0
MemcacheServiceError_UNSPECIFIED_ERROR MemcacheServiceError_ErrorCode = 1
MemcacheServiceError_NAMESPACE_NOT_SET MemcacheServiceError_ErrorCode = 2
MemcacheServiceError_PERMISSION_DENIED MemcacheServiceError_ErrorCode = 3
MemcacheServiceError_INVALID_VALUE MemcacheServiceError_ErrorCode = 6
)
var MemcacheServiceError_ErrorCode_name = map[int32]string{
0: "OK",
1: "UNSPECIFIED_ERROR",
2: "NAMESPACE_NOT_SET",
3: "PERMISSION_DENIED",
6: "INVALID_VALUE",
}
var MemcacheServiceError_ErrorCode_value = map[string]int32{
"OK": 0,
"UNSPECIFIED_ERROR": 1,
"NAMESPACE_NOT_SET": 2,
"PERMISSION_DENIED": 3,
"INVALID_VALUE": 6,
}
func (x MemcacheServiceError_ErrorCode) Enum() *MemcacheServiceError_ErrorCode {
p := new(MemcacheServiceError_ErrorCode)
*p = x
return p
}
func (x MemcacheServiceError_ErrorCode) String() string {
return proto.EnumName(MemcacheServiceError_ErrorCode_name, int32(x))
}
func (x *MemcacheServiceError_ErrorCode) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(MemcacheServiceError_ErrorCode_value, data, "MemcacheServiceError_ErrorCode")
if err != nil {
return err
}
*x = MemcacheServiceError_ErrorCode(value)
return nil
}
type MemcacheSetRequest_SetPolicy int32
const (
MemcacheSetRequest_SET MemcacheSetRequest_SetPolicy = 1
MemcacheSetRequest_ADD MemcacheSetRequest_SetPolicy = 2
MemcacheSetRequest_REPLACE MemcacheSetRequest_SetPolicy = 3
MemcacheSetRequest_CAS MemcacheSetRequest_SetPolicy = 4
)
var MemcacheSetRequest_SetPolicy_name = map[int32]string{
1: "SET",
2: "ADD",
3: "REPLACE",
4: "CAS",
}
var MemcacheSetRequest_SetPolicy_value = map[string]int32{
"SET": 1,
"ADD": 2,
"REPLACE": 3,
"CAS": 4,
}
func (x MemcacheSetRequest_SetPolicy) Enum() *MemcacheSetRequest_SetPolicy {
p := new(MemcacheSetRequest_SetPolicy)
*p = x
return p
}
func (x MemcacheSetRequest_SetPolicy) String() string {
return proto.EnumName(MemcacheSetRequest_SetPolicy_name, int32(x))
}
func (x *MemcacheSetRequest_SetPolicy) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(MemcacheSetRequest_SetPolicy_value, data, "MemcacheSetRequest_SetPolicy")
if err != nil {
return err
}
*x = MemcacheSetRequest_SetPolicy(value)
return nil
}
type MemcacheSetResponse_SetStatusCode int32
const (
MemcacheSetResponse_STORED MemcacheSetResponse_SetStatusCode = 1
MemcacheSetResponse_NOT_STORED MemcacheSetResponse_SetStatusCode = 2
MemcacheSetResponse_ERROR MemcacheSetResponse_SetStatusCode = 3
MemcacheSetResponse_EXISTS MemcacheSetResponse_SetStatusCode = 4
)
var MemcacheSetResponse_SetStatusCode_name = map[int32]string{
1: "STORED",
2: "NOT_STORED",
3: "ERROR",
4: "EXISTS",
}
var MemcacheSetResponse_SetStatusCode_value = map[string]int32{
"STORED": 1,
"NOT_STORED": 2,
"ERROR": 3,
"EXISTS": 4,
}
func (x MemcacheSetResponse_SetStatusCode) Enum() *MemcacheSetResponse_SetStatusCode {
p := new(MemcacheSetResponse_SetStatusCode)
*p = x
return p
}
func (x MemcacheSetResponse_SetStatusCode) String() string {
return proto.EnumName(MemcacheSetResponse_SetStatusCode_name, int32(x))
}
func (x *MemcacheSetResponse_SetStatusCode) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(MemcacheSetResponse_SetStatusCode_value, data, "MemcacheSetResponse_SetStatusCode")
if err != nil {
return err
}
*x = MemcacheSetResponse_SetStatusCode(value)
return nil
}
type MemcacheDeleteResponse_DeleteStatusCode int32
const (
MemcacheDeleteResponse_DELETED MemcacheDeleteResponse_DeleteStatusCode = 1
MemcacheDeleteResponse_NOT_FOUND MemcacheDeleteResponse_DeleteStatusCode = 2
)
var MemcacheDeleteResponse_DeleteStatusCode_name = map[int32]string{
1: "DELETED",
2: "NOT_FOUND",
}
var MemcacheDeleteResponse_DeleteStatusCode_value = map[string]int32{
"DELETED": 1,
"NOT_FOUND": 2,
}
func (x MemcacheDeleteResponse_DeleteStatusCode) Enum() *MemcacheDeleteResponse_DeleteStatusCode {
p := new(MemcacheDeleteResponse_DeleteStatusCode)
*p = x
return p
}
func (x MemcacheDeleteResponse_DeleteStatusCode) String() string {
return proto.EnumName(MemcacheDeleteResponse_DeleteStatusCode_name, int32(x))
}
func (x *MemcacheDeleteResponse_DeleteStatusCode) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(MemcacheDeleteResponse_DeleteStatusCode_value, data, "MemcacheDeleteResponse_DeleteStatusCode")
if err != nil {
return err
}
*x = MemcacheDeleteResponse_DeleteStatusCode(value)
return nil
}
type MemcacheIncrementRequest_Direction int32
const (
MemcacheIncrementRequest_INCREMENT MemcacheIncrementRequest_Direction = 1
MemcacheIncrementRequest_DECREMENT MemcacheIncrementRequest_Direction = 2
)
var MemcacheIncrementRequest_Direction_name = map[int32]string{
1: "INCREMENT",
2: "DECREMENT",
}
var MemcacheIncrementRequest_Direction_value = map[string]int32{
"INCREMENT": 1,
"DECREMENT": 2,
}
func (x MemcacheIncrementRequest_Direction) Enum() *MemcacheIncrementRequest_Direction {
p := new(MemcacheIncrementRequest_Direction)
*p = x
return p
}
func (x MemcacheIncrementRequest_Direction) String() string {
return proto.EnumName(MemcacheIncrementRequest_Direction_name, int32(x))
}
func (x *MemcacheIncrementRequest_Direction) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(MemcacheIncrementRequest_Direction_value, data, "MemcacheIncrementRequest_Direction")
if err != nil {
return err
}
*x = MemcacheIncrementRequest_Direction(value)
return nil
}
type MemcacheIncrementResponse_IncrementStatusCode int32
const (
MemcacheIncrementResponse_OK MemcacheIncrementResponse_IncrementStatusCode = 1
MemcacheIncrementResponse_NOT_CHANGED MemcacheIncrementResponse_IncrementStatusCode = 2
MemcacheIncrementResponse_ERROR MemcacheIncrementResponse_IncrementStatusCode = 3
)
var MemcacheIncrementResponse_IncrementStatusCode_name = map[int32]string{
1: "OK",
2: "NOT_CHANGED",
3: "ERROR",
}
var MemcacheIncrementResponse_IncrementStatusCode_value = map[string]int32{
"OK": 1,
"NOT_CHANGED": 2,
"ERROR": 3,
}
func (x MemcacheIncrementResponse_IncrementStatusCode) Enum() *MemcacheIncrementResponse_IncrementStatusCode {
p := new(MemcacheIncrementResponse_IncrementStatusCode)
*p = x
return p
}
func (x MemcacheIncrementResponse_IncrementStatusCode) String() string {
return proto.EnumName(MemcacheIncrementResponse_IncrementStatusCode_name, int32(x))
}
func (x *MemcacheIncrementResponse_IncrementStatusCode) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(MemcacheIncrementResponse_IncrementStatusCode_value, data, "MemcacheIncrementResponse_IncrementStatusCode")
if err != nil {
return err
}
*x = MemcacheIncrementResponse_IncrementStatusCode(value)
return nil
}
type MemcacheServiceError struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *MemcacheServiceError) Reset() { *m = MemcacheServiceError{} }
func (m *MemcacheServiceError) String() string { return proto.CompactTextString(m) }
func (*MemcacheServiceError) ProtoMessage() {}
type AppOverride struct {
AppId *string `protobuf:"bytes,1,req,name=app_id" json:"app_id,omitempty"`
NumMemcachegBackends *int32 `protobuf:"varint,2,opt,name=num_memcacheg_backends" json:"num_memcacheg_backends,omitempty"`
IgnoreShardlock *bool `protobuf:"varint,3,opt,name=ignore_shardlock" json:"ignore_shardlock,omitempty"`
MemcachePoolHint *string `protobuf:"bytes,4,opt,name=memcache_pool_hint" json:"memcache_pool_hint,omitempty"`
MemcacheShardingStrategy []byte `protobuf:"bytes,5,opt,name=memcache_sharding_strategy" json:"memcache_sharding_strategy,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *AppOverride) Reset() { *m = AppOverride{} }
func (m *AppOverride) String() string { return proto.CompactTextString(m) }
func (*AppOverride) ProtoMessage() {}
func (m *AppOverride) GetAppId() string {
if m != nil && m.AppId != nil {
return *m.AppId
}
return ""
}
func (m *AppOverride) GetNumMemcachegBackends() int32 {
if m != nil && m.NumMemcachegBackends != nil {
return *m.NumMemcachegBackends
}
return 0
}
func (m *AppOverride) GetIgnoreShardlock() bool {
if m != nil && m.IgnoreShardlock != nil {
return *m.IgnoreShardlock
}
return false
}
func (m *AppOverride) GetMemcachePoolHint() string {
if m != nil && m.MemcachePoolHint != nil {
return *m.MemcachePoolHint
}
return ""
}
func (m *AppOverride) GetMemcacheShardingStrategy() []byte {
if m != nil {
return m.MemcacheShardingStrategy
}
return nil
}
type MemcacheGetRequest struct {
Key [][]byte `protobuf:"bytes,1,rep,name=key" json:"key,omitempty"`
NameSpace *string `protobuf:"bytes,2,opt,name=name_space,def=" json:"name_space,omitempty"`
ForCas *bool `protobuf:"varint,4,opt,name=for_cas" json:"for_cas,omitempty"`
Override *AppOverride `protobuf:"bytes,5,opt,name=override" json:"override,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *MemcacheGetRequest) Reset() { *m = MemcacheGetRequest{} }
func (m *MemcacheGetRequest) String() string { return proto.CompactTextString(m) }
func (*MemcacheGetRequest) ProtoMessage() {}
func (m *MemcacheGetRequest) GetKey() [][]byte {
if m != nil {
return m.Key
}
return nil
}
func (m *MemcacheGetRequest) GetNameSpace() string {
if m != nil && m.NameSpace != nil {
return *m.NameSpace
}
return ""
}
func (m *MemcacheGetRequest) GetForCas() bool {
if m != nil && m.ForCas != nil {
return *m.ForCas
}
return false
}
func (m *MemcacheGetRequest) GetOverride() *AppOverride {
if m != nil {
return m.Override
}
return nil
}
type MemcacheGetResponse struct {
Item []*MemcacheGetResponse_Item `protobuf:"group,1,rep,name=Item" json:"item,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *MemcacheGetResponse) Reset() { *m = MemcacheGetResponse{} }
func (m *MemcacheGetResponse) String() string { return proto.CompactTextString(m) }
func (*MemcacheGetResponse) ProtoMessage() {}
func (m *MemcacheGetResponse) GetItem() []*MemcacheGetResponse_Item {
if m != nil {
return m.Item
}
return nil
}
type MemcacheGetResponse_Item struct {
Key []byte `protobuf:"bytes,2,req,name=key" json:"key,omitempty"`
Value []byte `protobuf:"bytes,3,req,name=value" json:"value,omitempty"`
Flags *uint32 `protobuf:"fixed32,4,opt,name=flags" json:"flags,omitempty"`
CasId *uint64 `protobuf:"fixed64,5,opt,name=cas_id" json:"cas_id,omitempty"`
ExpiresInSeconds *int32 `protobuf:"varint,6,opt,name=expires_in_seconds" json:"expires_in_seconds,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *MemcacheGetResponse_Item) Reset() { *m = MemcacheGetResponse_Item{} }
func (m *MemcacheGetResponse_Item) String() string { return proto.CompactTextString(m) }
func (*MemcacheGetResponse_Item) ProtoMessage() {}
func (m *MemcacheGetResponse_Item) GetKey() []byte {
if m != nil {
return m.Key
}
return nil
}
func (m *MemcacheGetResponse_Item) GetValue() []byte {
if m != nil {
return m.Value
}
return nil
}
func (m *MemcacheGetResponse_Item) GetFlags() uint32 {
if m != nil && m.Flags != nil {
return *m.Flags
}
return 0
}
func (m *MemcacheGetResponse_Item) GetCasId() uint64 {
if m != nil && m.CasId != nil {
return *m.CasId
}
return 0
}
func (m *MemcacheGetResponse_Item) GetExpiresInSeconds() int32 {
if m != nil && m.ExpiresInSeconds != nil {
return *m.ExpiresInSeconds
}
return 0
}
type MemcacheSetRequest struct {
Item []*MemcacheSetRequest_Item `protobuf:"group,1,rep,name=Item" json:"item,omitempty"`
NameSpace *string `protobuf:"bytes,7,opt,name=name_space,def=" json:"name_space,omitempty"`
Override *AppOverride `protobuf:"bytes,10,opt,name=override" json:"override,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *MemcacheSetRequest) Reset() { *m = MemcacheSetRequest{} }
func (m *MemcacheSetRequest) String() string { return proto.CompactTextString(m) }
func (*MemcacheSetRequest) ProtoMessage() {}
func (m *MemcacheSetRequest) GetItem() []*MemcacheSetRequest_Item {
if m != nil {
return m.Item
}
return nil
}
func (m *MemcacheSetRequest) GetNameSpace() string {
if m != nil && m.NameSpace != nil {
return *m.NameSpace
}
return ""
}
func (m *MemcacheSetRequest) GetOverride() *AppOverride {
if m != nil {
return m.Override
}
return nil
}
type MemcacheSetRequest_Item struct {
Key []byte `protobuf:"bytes,2,req,name=key" json:"key,omitempty"`
Value []byte `protobuf:"bytes,3,req,name=value" json:"value,omitempty"`
Flags *uint32 `protobuf:"fixed32,4,opt,name=flags" json:"flags,omitempty"`
SetPolicy *MemcacheSetRequest_SetPolicy `protobuf:"varint,5,opt,name=set_policy,enum=appengine.MemcacheSetRequest_SetPolicy,def=1" json:"set_policy,omitempty"`
ExpirationTime *uint32 `protobuf:"fixed32,6,opt,name=expiration_time,def=0" json:"expiration_time,omitempty"`
CasId *uint64 `protobuf:"fixed64,8,opt,name=cas_id" json:"cas_id,omitempty"`
ForCas *bool `protobuf:"varint,9,opt,name=for_cas" json:"for_cas,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *MemcacheSetRequest_Item) Reset() { *m = MemcacheSetRequest_Item{} }
func (m *MemcacheSetRequest_Item) String() string { return proto.CompactTextString(m) }
func (*MemcacheSetRequest_Item) ProtoMessage() {}
const Default_MemcacheSetRequest_Item_SetPolicy MemcacheSetRequest_SetPolicy = MemcacheSetRequest_SET
const Default_MemcacheSetRequest_Item_ExpirationTime uint32 = 0
func (m *MemcacheSetRequest_Item) GetKey() []byte {
if m != nil {
return m.Key
}
return nil
}
func (m *MemcacheSetRequest_Item) GetValue() []byte {
if m != nil {
return m.Value
}
return nil
}
func (m *MemcacheSetRequest_Item) GetFlags() uint32 {
if m != nil && m.Flags != nil {
return *m.Flags
}
return 0
}
func (m *MemcacheSetRequest_Item) GetSetPolicy() MemcacheSetRequest_SetPolicy {
if m != nil && m.SetPolicy != nil {
return *m.SetPolicy
}
return Default_MemcacheSetRequest_Item_SetPolicy
}
func (m *MemcacheSetRequest_Item) GetExpirationTime() uint32 {
if m != nil && m.ExpirationTime != nil {
return *m.ExpirationTime
}
return Default_MemcacheSetRequest_Item_ExpirationTime
}
func (m *MemcacheSetRequest_Item) GetCasId() uint64 {
if m != nil && m.CasId != nil {
return *m.CasId
}
return 0
}
func (m *MemcacheSetRequest_Item) GetForCas() bool {
if m != nil && m.ForCas != nil {
return *m.ForCas
}
return false
}
type MemcacheSetResponse struct {
SetStatus []MemcacheSetResponse_SetStatusCode `protobuf:"varint,1,rep,name=set_status,enum=appengine.MemcacheSetResponse_SetStatusCode" json:"set_status,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *MemcacheSetResponse) Reset() { *m = MemcacheSetResponse{} }
func (m *MemcacheSetResponse) String() string { return proto.CompactTextString(m) }
func (*MemcacheSetResponse) ProtoMessage() {}
func (m *MemcacheSetResponse) GetSetStatus() []MemcacheSetResponse_SetStatusCode {
if m != nil {
return m.SetStatus
}
return nil
}
type MemcacheDeleteRequest struct {
Item []*MemcacheDeleteRequest_Item `protobuf:"group,1,rep,name=Item" json:"item,omitempty"`
NameSpace *string `protobuf:"bytes,4,opt,name=name_space,def=" json:"name_space,omitempty"`
Override *AppOverride `protobuf:"bytes,5,opt,name=override" json:"override,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *MemcacheDeleteRequest) Reset() { *m = MemcacheDeleteRequest{} }
func (m *MemcacheDeleteRequest) String() string { return proto.CompactTextString(m) }
func (*MemcacheDeleteRequest) ProtoMessage() {}
func (m *MemcacheDeleteRequest) GetItem() []*MemcacheDeleteRequest_Item {
if m != nil {
return m.Item
}
return nil
}
func (m *MemcacheDeleteRequest) GetNameSpace() string {
if m != nil && m.NameSpace != nil {
return *m.NameSpace
}
return ""
}
func (m *MemcacheDeleteRequest) GetOverride() *AppOverride {
if m != nil {
return m.Override
}
return nil
}
type MemcacheDeleteRequest_Item struct {
Key []byte `protobuf:"bytes,2,req,name=key" json:"key,omitempty"`
DeleteTime *uint32 `protobuf:"fixed32,3,opt,name=delete_time,def=0" json:"delete_time,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *MemcacheDeleteRequest_Item) Reset() { *m = MemcacheDeleteRequest_Item{} }
func (m *MemcacheDeleteRequest_Item) String() string { return proto.CompactTextString(m) }
func (*MemcacheDeleteRequest_Item) ProtoMessage() {}
const Default_MemcacheDeleteRequest_Item_DeleteTime uint32 = 0
func (m *MemcacheDeleteRequest_Item) GetKey() []byte {
if m != nil {
return m.Key
}
return nil
}
func (m *MemcacheDeleteRequest_Item) GetDeleteTime() uint32 {
if m != nil && m.DeleteTime != nil {
return *m.DeleteTime
}
return Default_MemcacheDeleteRequest_Item_DeleteTime
}
type MemcacheDeleteResponse struct {
DeleteStatus []MemcacheDeleteResponse_DeleteStatusCode `protobuf:"varint,1,rep,name=delete_status,enum=appengine.MemcacheDeleteResponse_DeleteStatusCode" json:"delete_status,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *MemcacheDeleteResponse) Reset() { *m = MemcacheDeleteResponse{} }
func (m *MemcacheDeleteResponse) String() string { return proto.CompactTextString(m) }
func (*MemcacheDeleteResponse) ProtoMessage() {}
func (m *MemcacheDeleteResponse) GetDeleteStatus() []MemcacheDeleteResponse_DeleteStatusCode {
if m != nil {
return m.DeleteStatus
}
return nil
}
type MemcacheIncrementRequest struct {
Key []byte `protobuf:"bytes,1,req,name=key" json:"key,omitempty"`
NameSpace *string `protobuf:"bytes,4,opt,name=name_space,def=" json:"name_space,omitempty"`
Delta *uint64 `protobuf:"varint,2,opt,name=delta,def=1" json:"delta,omitempty"`
Direction *MemcacheIncrementRequest_Direction `protobuf:"varint,3,opt,name=direction,enum=appengine.MemcacheIncrementRequest_Direction,def=1" json:"direction,omitempty"`
InitialValue *uint64 `protobuf:"varint,5,opt,name=initial_value" json:"initial_value,omitempty"`
InitialFlags *uint32 `protobuf:"fixed32,6,opt,name=initial_flags" json:"initial_flags,omitempty"`
Override *AppOverride `protobuf:"bytes,7,opt,name=override" json:"override,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *MemcacheIncrementRequest) Reset() { *m = MemcacheIncrementRequest{} }
func (m *MemcacheIncrementRequest) String() string { return proto.CompactTextString(m) }
func (*MemcacheIncrementRequest) ProtoMessage() {}
const Default_MemcacheIncrementRequest_Delta uint64 = 1
const Default_MemcacheIncrementRequest_Direction MemcacheIncrementRequest_Direction = MemcacheIncrementRequest_INCREMENT
func (m *MemcacheIncrementRequest) GetKey() []byte {
if m != nil {
return m.Key
}
return nil
}
func (m *MemcacheIncrementRequest) GetNameSpace() string {
if m != nil && m.NameSpace != nil {
return *m.NameSpace
}
return ""
}
func (m *MemcacheIncrementRequest) GetDelta() uint64 {
if m != nil && m.Delta != nil {
return *m.Delta
}
return Default_MemcacheIncrementRequest_Delta
}
func (m *MemcacheIncrementRequest) GetDirection() MemcacheIncrementRequest_Direction {
if m != nil && m.Direction != nil {
return *m.Direction
}
return Default_MemcacheIncrementRequest_Direction
}
func (m *MemcacheIncrementRequest) GetInitialValue() uint64 {
if m != nil && m.InitialValue != nil {
return *m.InitialValue
}
return 0
}
func (m *MemcacheIncrementRequest) GetInitialFlags() uint32 {
if m != nil && m.InitialFlags != nil {
return *m.InitialFlags
}
return 0
}
func (m *MemcacheIncrementRequest) GetOverride() *AppOverride {
if m != nil {
return m.Override
}
return nil
}
type MemcacheIncrementResponse struct {
NewValue *uint64 `protobuf:"varint,1,opt,name=new_value" json:"new_value,omitempty"`
IncrementStatus *MemcacheIncrementResponse_IncrementStatusCode `protobuf:"varint,2,opt,name=increment_status,enum=appengine.MemcacheIncrementResponse_IncrementStatusCode" json:"increment_status,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *MemcacheIncrementResponse) Reset() { *m = MemcacheIncrementResponse{} }
func (m *MemcacheIncrementResponse) String() string { return proto.CompactTextString(m) }
func (*MemcacheIncrementResponse) ProtoMessage() {}
func (m *MemcacheIncrementResponse) GetNewValue() uint64 {
if m != nil && m.NewValue != nil {
return *m.NewValue
}
return 0
}
func (m *MemcacheIncrementResponse) GetIncrementStatus() MemcacheIncrementResponse_IncrementStatusCode {
if m != nil && m.IncrementStatus != nil {
return *m.IncrementStatus
}
return MemcacheIncrementResponse_OK
}
type MemcacheBatchIncrementRequest struct {
NameSpace *string `protobuf:"bytes,1,opt,name=name_space,def=" json:"name_space,omitempty"`
Item []*MemcacheIncrementRequest `protobuf:"bytes,2,rep,name=item" json:"item,omitempty"`
Override *AppOverride `protobuf:"bytes,3,opt,name=override" json:"override,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *MemcacheBatchIncrementRequest) Reset() { *m = MemcacheBatchIncrementRequest{} }
func (m *MemcacheBatchIncrementRequest) String() string { return proto.CompactTextString(m) }
func (*MemcacheBatchIncrementRequest) ProtoMessage() {}
func (m *MemcacheBatchIncrementRequest) GetNameSpace() string {
if m != nil && m.NameSpace != nil {
return *m.NameSpace
}
return ""
}
func (m *MemcacheBatchIncrementRequest) GetItem() []*MemcacheIncrementRequest {
if m != nil {
return m.Item
}
return nil
}
func (m *MemcacheBatchIncrementRequest) GetOverride() *AppOverride {
if m != nil {
return m.Override
}
return nil
}
type MemcacheBatchIncrementResponse struct {
Item []*MemcacheIncrementResponse `protobuf:"bytes,1,rep,name=item" json:"item,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *MemcacheBatchIncrementResponse) Reset() { *m = MemcacheBatchIncrementResponse{} }
func (m *MemcacheBatchIncrementResponse) String() string { return proto.CompactTextString(m) }
func (*MemcacheBatchIncrementResponse) ProtoMessage() {}
func (m *MemcacheBatchIncrementResponse) GetItem() []*MemcacheIncrementResponse {
if m != nil {
return m.Item
}
return nil
}
type MemcacheFlushRequest struct {
Override *AppOverride `protobuf:"bytes,1,opt,name=override" json:"override,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *MemcacheFlushRequest) Reset() { *m = MemcacheFlushRequest{} }
func (m *MemcacheFlushRequest) String() string { return proto.CompactTextString(m) }
func (*MemcacheFlushRequest) ProtoMessage() {}
func (m *MemcacheFlushRequest) GetOverride() *AppOverride {
if m != nil {
return m.Override
}
return nil
}
type MemcacheFlushResponse struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *MemcacheFlushResponse) Reset() { *m = MemcacheFlushResponse{} }
func (m *MemcacheFlushResponse) String() string { return proto.CompactTextString(m) }
func (*MemcacheFlushResponse) ProtoMessage() {}
type MemcacheStatsRequest struct {
Override *AppOverride `protobuf:"bytes,1,opt,name=override" json:"override,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *MemcacheStatsRequest) Reset() { *m = MemcacheStatsRequest{} }
func (m *MemcacheStatsRequest) String() string { return proto.CompactTextString(m) }
func (*MemcacheStatsRequest) ProtoMessage() {}
func (m *MemcacheStatsRequest) GetOverride() *AppOverride {
if m != nil {
return m.Override
}
return nil
}
type MergedNamespaceStats struct {
Hits *uint64 `protobuf:"varint,1,req,name=hits" json:"hits,omitempty"`
Misses *uint64 `protobuf:"varint,2,req,name=misses" json:"misses,omitempty"`
ByteHits *uint64 `protobuf:"varint,3,req,name=byte_hits" json:"byte_hits,omitempty"`
Items *uint64 `protobuf:"varint,4,req,name=items" json:"items,omitempty"`
Bytes *uint64 `protobuf:"varint,5,req,name=bytes" json:"bytes,omitempty"`
OldestItemAge *uint32 `protobuf:"fixed32,6,req,name=oldest_item_age" json:"oldest_item_age,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *MergedNamespaceStats) Reset() { *m = MergedNamespaceStats{} }
func (m *MergedNamespaceStats) String() string { return proto.CompactTextString(m) }
func (*MergedNamespaceStats) ProtoMessage() {}
func (m *MergedNamespaceStats) GetHits() uint64 {
if m != nil && m.Hits != nil {
return *m.Hits
}
return 0
}
func (m *MergedNamespaceStats) GetMisses() uint64 {
if m != nil && m.Misses != nil {
return *m.Misses
}
return 0
}
func (m *MergedNamespaceStats) GetByteHits() uint64 {
if m != nil && m.ByteHits != nil {
return *m.ByteHits
}
return 0
}
func (m *MergedNamespaceStats) GetItems() uint64 {
if m != nil && m.Items != nil {
return *m.Items
}
return 0
}
func (m *MergedNamespaceStats) GetBytes() uint64 {
if m != nil && m.Bytes != nil {
return *m.Bytes
}
return 0
}
func (m *MergedNamespaceStats) GetOldestItemAge() uint32 {
if m != nil && m.OldestItemAge != nil {
return *m.OldestItemAge
}
return 0
}
type MemcacheStatsResponse struct {
Stats *MergedNamespaceStats `protobuf:"bytes,1,opt,name=stats" json:"stats,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *MemcacheStatsResponse) Reset() { *m = MemcacheStatsResponse{} }
func (m *MemcacheStatsResponse) String() string { return proto.CompactTextString(m) }
func (*MemcacheStatsResponse) ProtoMessage() {}
func (m *MemcacheStatsResponse) GetStats() *MergedNamespaceStats {
if m != nil {
return m.Stats
}
return nil
}
type MemcacheGrabTailRequest struct {
ItemCount *int32 `protobuf:"varint,1,req,name=item_count" json:"item_count,omitempty"`
NameSpace *string `protobuf:"bytes,2,opt,name=name_space,def=" json:"name_space,omitempty"`
Override *AppOverride `protobuf:"bytes,3,opt,name=override" json:"override,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *MemcacheGrabTailRequest) Reset() { *m = MemcacheGrabTailRequest{} }
func (m *MemcacheGrabTailRequest) String() string { return proto.CompactTextString(m) }
func (*MemcacheGrabTailRequest) ProtoMessage() {}
func (m *MemcacheGrabTailRequest) GetItemCount() int32 {
if m != nil && m.ItemCount != nil {
return *m.ItemCount
}
return 0
}
func (m *MemcacheGrabTailRequest) GetNameSpace() string {
if m != nil && m.NameSpace != nil {
return *m.NameSpace
}
return ""
}
func (m *MemcacheGrabTailRequest) GetOverride() *AppOverride {
if m != nil {
return m.Override
}
return nil
}
type MemcacheGrabTailResponse struct {
Item []*MemcacheGrabTailResponse_Item `protobuf:"group,1,rep,name=Item" json:"item,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *MemcacheGrabTailResponse) Reset() { *m = MemcacheGrabTailResponse{} }
func (m *MemcacheGrabTailResponse) String() string { return proto.CompactTextString(m) }
func (*MemcacheGrabTailResponse) ProtoMessage() {}
func (m *MemcacheGrabTailResponse) GetItem() []*MemcacheGrabTailResponse_Item {
if m != nil {
return m.Item
}
return nil
}
type MemcacheGrabTailResponse_Item struct {
Value []byte `protobuf:"bytes,2,req,name=value" json:"value,omitempty"`
Flags *uint32 `protobuf:"fixed32,3,opt,name=flags" json:"flags,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *MemcacheGrabTailResponse_Item) Reset() { *m = MemcacheGrabTailResponse_Item{} }
func (m *MemcacheGrabTailResponse_Item) String() string { return proto.CompactTextString(m) }
func (*MemcacheGrabTailResponse_Item) ProtoMessage() {}
func (m *MemcacheGrabTailResponse_Item) GetValue() []byte {
if m != nil {
return m.Value
}
return nil
}
func (m *MemcacheGrabTailResponse_Item) GetFlags() uint32 {
if m != nil && m.Flags != nil {
return *m.Flags
}
return 0
}
func init() {
}
================================================
FILE: vendor/google.golang.org/appengine/internal/memcache/memcache_service.proto
================================================
syntax = "proto2";
option go_package = "memcache";
package appengine;
message MemcacheServiceError {
enum ErrorCode {
OK = 0;
UNSPECIFIED_ERROR = 1;
NAMESPACE_NOT_SET = 2;
PERMISSION_DENIED = 3;
INVALID_VALUE = 6;
}
}
message AppOverride {
required string app_id = 1;
optional int32 num_memcacheg_backends = 2 [deprecated=true];
optional bool ignore_shardlock = 3 [deprecated=true];
optional string memcache_pool_hint = 4 [deprecated=true];
optional bytes memcache_sharding_strategy = 5 [deprecated=true];
}
message MemcacheGetRequest {
repeated bytes key = 1;
optional string name_space = 2 [default = ""];
optional bool for_cas = 4;
optional AppOverride override = 5;
}
message MemcacheGetResponse {
repeated group Item = 1 {
required bytes key = 2;
required bytes value = 3;
optional fixed32 flags = 4;
optional fixed64 cas_id = 5;
optional int32 expires_in_seconds = 6;
}
}
message MemcacheSetRequest {
enum SetPolicy {
SET = 1;
ADD = 2;
REPLACE = 3;
CAS = 4;
}
repeated group Item = 1 {
required bytes key = 2;
required bytes value = 3;
optional fixed32 flags = 4;
optional SetPolicy set_policy = 5 [default = SET];
optional fixed32 expiration_time = 6 [default = 0];
optional fixed64 cas_id = 8;
optional bool for_cas = 9;
}
optional string name_space = 7 [default = ""];
optional AppOverride override = 10;
}
message MemcacheSetResponse {
enum SetStatusCode {
STORED = 1;
NOT_STORED = 2;
ERROR = 3;
EXISTS = 4;
}
repeated SetStatusCode set_status = 1;
}
message MemcacheDeleteRequest {
repeated group Item = 1 {
required bytes key = 2;
optional fixed32 delete_time = 3 [default = 0];
}
optional string name_space = 4 [default = ""];
optional AppOverride override = 5;
}
message MemcacheDeleteResponse {
enum DeleteStatusCode {
DELETED = 1;
NOT_FOUND = 2;
}
repeated DeleteStatusCode delete_status = 1;
}
message MemcacheIncrementRequest {
enum Direction {
INCREMENT = 1;
DECREMENT = 2;
}
required bytes key = 1;
optional string name_space = 4 [default = ""];
optional uint64 delta = 2 [default = 1];
optional Direction direction = 3 [default = INCREMENT];
optional uint64 initial_value = 5;
optional fixed32 initial_flags = 6;
optional AppOverride override = 7;
}
message MemcacheIncrementResponse {
enum IncrementStatusCode {
OK = 1;
NOT_CHANGED = 2;
ERROR = 3;
}
optional uint64 new_value = 1;
optional IncrementStatusCode increment_status = 2;
}
message MemcacheBatchIncrementRequest {
optional string name_space = 1 [default = ""];
repeated MemcacheIncrementRequest item = 2;
optional AppOverride override = 3;
}
message MemcacheBatchIncrementResponse {
repeated MemcacheIncrementResponse item = 1;
}
message MemcacheFlushRequest {
optional AppOverride override = 1;
}
message MemcacheFlushResponse {
}
message MemcacheStatsRequest {
optional AppOverride override = 1;
}
message MergedNamespaceStats {
required uint64 hits = 1;
required uint64 misses = 2;
required uint64 byte_hits = 3;
required uint64 items = 4;
required uint64 bytes = 5;
required fixed32 oldest_item_age = 6;
}
message MemcacheStatsResponse {
optional MergedNamespaceStats stats = 1;
}
message MemcacheGrabTailRequest {
required int32 item_count = 1;
optional string name_space = 2 [default = ""];
optional AppOverride override = 3;
}
message MemcacheGrabTailResponse {
repeated group Item = 1 {
required bytes value = 2;
optional fixed32 flags = 3;
}
}
================================================
FILE: vendor/google.golang.org/appengine/internal/metadata.go
================================================
// Copyright 2014 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
package internal
// This file has code for accessing metadata.
//
// References:
// https://cloud.google.com/compute/docs/metadata
import (
"fmt"
"io/ioutil"
"log"
"net/http"
"net/url"
)
const (
metadataHost = "metadata"
metadataPath = "/computeMetadata/v1/"
)
var (
metadataRequestHeaders = http.Header{
"X-Google-Metadata-Request": []string{"True"},
}
)
// TODO(dsymonds): Do we need to support default values, like Python?
func mustGetMetadata(key string) []byte {
b, err := getMetadata(key)
if err != nil {
log.Fatalf("Metadata fetch failed: %v", err)
}
return b
}
func getMetadata(key string) ([]byte, error) {
// TODO(dsymonds): May need to use url.Parse to support keys with query args.
req := &http.Request{
Method: "GET",
URL: &url.URL{
Scheme: "http",
Host: metadataHost,
Path: metadataPath + key,
},
Header: metadataRequestHeaders,
Host: metadataHost,
}
resp, err := http.DefaultClient.Do(req)
if err != nil {
return nil, err
}
defer resp.Body.Close()
if resp.StatusCode != 200 {
return nil, fmt.Errorf("metadata server returned HTTP %d", resp.StatusCode)
}
return ioutil.ReadAll(resp.Body)
}
================================================
FILE: vendor/google.golang.org/appengine/internal/modules/modules_service.pb.go
================================================
// Code generated by protoc-gen-go.
// source: google.golang.org/appengine/internal/modules/modules_service.proto
// DO NOT EDIT!
/*
Package modules is a generated protocol buffer package.
It is generated from these files:
google.golang.org/appengine/internal/modules/modules_service.proto
It has these top-level messages:
ModulesServiceError
GetModulesRequest
GetModulesResponse
GetVersionsRequest
GetVersionsResponse
GetDefaultVersionRequest
GetDefaultVersionResponse
GetNumInstancesRequest
GetNumInstancesResponse
SetNumInstancesRequest
SetNumInstancesResponse
StartModuleRequest
StartModuleResponse
StopModuleRequest
StopModuleResponse
GetHostnameRequest
GetHostnameResponse
*/
package modules
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type ModulesServiceError_ErrorCode int32
const (
ModulesServiceError_OK ModulesServiceError_ErrorCode = 0
ModulesServiceError_INVALID_MODULE ModulesServiceError_ErrorCode = 1
ModulesServiceError_INVALID_VERSION ModulesServiceError_ErrorCode = 2
ModulesServiceError_INVALID_INSTANCES ModulesServiceError_ErrorCode = 3
ModulesServiceError_TRANSIENT_ERROR ModulesServiceError_ErrorCode = 4
ModulesServiceError_UNEXPECTED_STATE ModulesServiceError_ErrorCode = 5
)
var ModulesServiceError_ErrorCode_name = map[int32]string{
0: "OK",
1: "INVALID_MODULE",
2: "INVALID_VERSION",
3: "INVALID_INSTANCES",
4: "TRANSIENT_ERROR",
5: "UNEXPECTED_STATE",
}
var ModulesServiceError_ErrorCode_value = map[string]int32{
"OK": 0,
"INVALID_MODULE": 1,
"INVALID_VERSION": 2,
"INVALID_INSTANCES": 3,
"TRANSIENT_ERROR": 4,
"UNEXPECTED_STATE": 5,
}
func (x ModulesServiceError_ErrorCode) Enum() *ModulesServiceError_ErrorCode {
p := new(ModulesServiceError_ErrorCode)
*p = x
return p
}
func (x ModulesServiceError_ErrorCode) String() string {
return proto.EnumName(ModulesServiceError_ErrorCode_name, int32(x))
}
func (x *ModulesServiceError_ErrorCode) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(ModulesServiceError_ErrorCode_value, data, "ModulesServiceError_ErrorCode")
if err != nil {
return err
}
*x = ModulesServiceError_ErrorCode(value)
return nil
}
type ModulesServiceError struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *ModulesServiceError) Reset() { *m = ModulesServiceError{} }
func (m *ModulesServiceError) String() string { return proto.CompactTextString(m) }
func (*ModulesServiceError) ProtoMessage() {}
type GetModulesRequest struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *GetModulesRequest) Reset() { *m = GetModulesRequest{} }
func (m *GetModulesRequest) String() string { return proto.CompactTextString(m) }
func (*GetModulesRequest) ProtoMessage() {}
type GetModulesResponse struct {
Module []string `protobuf:"bytes,1,rep,name=module" json:"module,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetModulesResponse) Reset() { *m = GetModulesResponse{} }
func (m *GetModulesResponse) String() string { return proto.CompactTextString(m) }
func (*GetModulesResponse) ProtoMessage() {}
func (m *GetModulesResponse) GetModule() []string {
if m != nil {
return m.Module
}
return nil
}
type GetVersionsRequest struct {
Module *string `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetVersionsRequest) Reset() { *m = GetVersionsRequest{} }
func (m *GetVersionsRequest) String() string { return proto.CompactTextString(m) }
func (*GetVersionsRequest) ProtoMessage() {}
func (m *GetVersionsRequest) GetModule() string {
if m != nil && m.Module != nil {
return *m.Module
}
return ""
}
type GetVersionsResponse struct {
Version []string `protobuf:"bytes,1,rep,name=version" json:"version,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetVersionsResponse) Reset() { *m = GetVersionsResponse{} }
func (m *GetVersionsResponse) String() string { return proto.CompactTextString(m) }
func (*GetVersionsResponse) ProtoMessage() {}
func (m *GetVersionsResponse) GetVersion() []string {
if m != nil {
return m.Version
}
return nil
}
type GetDefaultVersionRequest struct {
Module *string `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetDefaultVersionRequest) Reset() { *m = GetDefaultVersionRequest{} }
func (m *GetDefaultVersionRequest) String() string { return proto.CompactTextString(m) }
func (*GetDefaultVersionRequest) ProtoMessage() {}
func (m *GetDefaultVersionRequest) GetModule() string {
if m != nil && m.Module != nil {
return *m.Module
}
return ""
}
type GetDefaultVersionResponse struct {
Version *string `protobuf:"bytes,1,req,name=version" json:"version,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetDefaultVersionResponse) Reset() { *m = GetDefaultVersionResponse{} }
func (m *GetDefaultVersionResponse) String() string { return proto.CompactTextString(m) }
func (*GetDefaultVersionResponse) ProtoMessage() {}
func (m *GetDefaultVersionResponse) GetVersion() string {
if m != nil && m.Version != nil {
return *m.Version
}
return ""
}
type GetNumInstancesRequest struct {
Module *string `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`
Version *string `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetNumInstancesRequest) Reset() { *m = GetNumInstancesRequest{} }
func (m *GetNumInstancesRequest) String() string { return proto.CompactTextString(m) }
func (*GetNumInstancesRequest) ProtoMessage() {}
func (m *GetNumInstancesRequest) GetModule() string {
if m != nil && m.Module != nil {
return *m.Module
}
return ""
}
func (m *GetNumInstancesRequest) GetVersion() string {
if m != nil && m.Version != nil {
return *m.Version
}
return ""
}
type GetNumInstancesResponse struct {
Instances *int64 `protobuf:"varint,1,req,name=instances" json:"instances,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetNumInstancesResponse) Reset() { *m = GetNumInstancesResponse{} }
func (m *GetNumInstancesResponse) String() string { return proto.CompactTextString(m) }
func (*GetNumInstancesResponse) ProtoMessage() {}
func (m *GetNumInstancesResponse) GetInstances() int64 {
if m != nil && m.Instances != nil {
return *m.Instances
}
return 0
}
type SetNumInstancesRequest struct {
Module *string `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`
Version *string `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"`
Instances *int64 `protobuf:"varint,3,req,name=instances" json:"instances,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *SetNumInstancesRequest) Reset() { *m = SetNumInstancesRequest{} }
func (m *SetNumInstancesRequest) String() string { return proto.CompactTextString(m) }
func (*SetNumInstancesRequest) ProtoMessage() {}
func (m *SetNumInstancesRequest) GetModule() string {
if m != nil && m.Module != nil {
return *m.Module
}
return ""
}
func (m *SetNumInstancesRequest) GetVersion() string {
if m != nil && m.Version != nil {
return *m.Version
}
return ""
}
func (m *SetNumInstancesRequest) GetInstances() int64 {
if m != nil && m.Instances != nil {
return *m.Instances
}
return 0
}
type SetNumInstancesResponse struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *SetNumInstancesResponse) Reset() { *m = SetNumInstancesResponse{} }
func (m *SetNumInstancesResponse) String() string { return proto.CompactTextString(m) }
func (*SetNumInstancesResponse) ProtoMessage() {}
type StartModuleRequest struct {
Module *string `protobuf:"bytes,1,req,name=module" json:"module,omitempty"`
Version *string `protobuf:"bytes,2,req,name=version" json:"version,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *StartModuleRequest) Reset() { *m = StartModuleRequest{} }
func (m *StartModuleRequest) String() string { return proto.CompactTextString(m) }
func (*StartModuleRequest) ProtoMessage() {}
func (m *StartModuleRequest) GetModule() string {
if m != nil && m.Module != nil {
return *m.Module
}
return ""
}
func (m *StartModuleRequest) GetVersion() string {
if m != nil && m.Version != nil {
return *m.Version
}
return ""
}
type StartModuleResponse struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *StartModuleResponse) Reset() { *m = StartModuleResponse{} }
func (m *StartModuleResponse) String() string { return proto.CompactTextString(m) }
func (*StartModuleResponse) ProtoMessage() {}
type StopModuleRequest struct {
Module *string `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`
Version *string `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *StopModuleRequest) Reset() { *m = StopModuleRequest{} }
func (m *StopModuleRequest) String() string { return proto.CompactTextString(m) }
func (*StopModuleRequest) ProtoMessage() {}
func (m *StopModuleRequest) GetModule() string {
if m != nil && m.Module != nil {
return *m.Module
}
return ""
}
func (m *StopModuleRequest) GetVersion() string {
if m != nil && m.Version != nil {
return *m.Version
}
return ""
}
type StopModuleResponse struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *StopModuleResponse) Reset() { *m = StopModuleResponse{} }
func (m *StopModuleResponse) String() string { return proto.CompactTextString(m) }
func (*StopModuleResponse) ProtoMessage() {}
type GetHostnameRequest struct {
Module *string `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"`
Version *string `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"`
Instance *string `protobuf:"bytes,3,opt,name=instance" json:"instance,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetHostnameRequest) Reset() { *m = GetHostnameRequest{} }
func (m *GetHostnameRequest) String() string { return proto.CompactTextString(m) }
func (*GetHostnameRequest) ProtoMessage() {}
func (m *GetHostnameRequest) GetModule() string {
if m != nil && m.Module != nil {
return *m.Module
}
return ""
}
func (m *GetHostnameRequest) GetVersion() string {
if m != nil && m.Version != nil {
return *m.Version
}
return ""
}
func (m *GetHostnameRequest) GetInstance() string {
if m != nil && m.Instance != nil {
return *m.Instance
}
return ""
}
type GetHostnameResponse struct {
Hostname *string `protobuf:"bytes,1,req,name=hostname" json:"hostname,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetHostnameResponse) Reset() { *m = GetHostnameResponse{} }
func (m *GetHostnameResponse) String() string { return proto.CompactTextString(m) }
func (*GetHostnameResponse) ProtoMessage() {}
func (m *GetHostnameResponse) GetHostname() string {
if m != nil && m.Hostname != nil {
return *m.Hostname
}
return ""
}
func init() {
}
================================================
FILE: vendor/google.golang.org/appengine/internal/modules/modules_service.proto
================================================
syntax = "proto2";
option go_package = "modules";
package appengine;
message ModulesServiceError {
enum ErrorCode {
OK = 0;
INVALID_MODULE = 1;
INVALID_VERSION = 2;
INVALID_INSTANCES = 3;
TRANSIENT_ERROR = 4;
UNEXPECTED_STATE = 5;
}
}
message GetModulesRequest {
}
message GetModulesResponse {
repeated string module = 1;
}
message GetVersionsRequest {
optional string module = 1;
}
message GetVersionsResponse {
repeated string version = 1;
}
message GetDefaultVersionRequest {
optional string module = 1;
}
message GetDefaultVersionResponse {
required string version = 1;
}
message GetNumInstancesRequest {
optional string module = 1;
optional string version = 2;
}
message GetNumInstancesResponse {
required int64 instances = 1;
}
message SetNumInstancesRequest {
optional string module = 1;
optional string version = 2;
required int64 instances = 3;
}
message SetNumInstancesResponse {}
message StartModuleRequest {
required string module = 1;
required string version = 2;
}
message StartModuleResponse {}
message StopModuleRequest {
optional string module = 1;
optional string version = 2;
}
message StopModuleResponse {}
message GetHostnameRequest {
optional string module = 1;
optional string version = 2;
optional string instance = 3;
}
message GetHostnameResponse {
required string hostname = 1;
}
================================================
FILE: vendor/google.golang.org/appengine/internal/net.go
================================================
// Copyright 2014 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
package internal
// This file implements a network dialer that limits the number of concurrent connections.
// It is only used for API calls.
import (
"log"
"net"
"runtime"
"sync"
"time"
)
var limitSem = make(chan int, 100) // TODO(dsymonds): Use environment variable.
func limitRelease() {
// non-blocking
select {
case <-limitSem:
default:
// This should not normally happen.
log.Print("appengine: unbalanced limitSem release!")
}
}
func limitDial(network, addr string) (net.Conn, error) {
limitSem <- 1
// Dial with a timeout in case the API host is MIA.
// The connection should normally be very fast.
conn, err := net.DialTimeout(network, addr, 500*time.Millisecond)
if err != nil {
limitRelease()
return nil, err
}
lc := &limitConn{Conn: conn}
runtime.SetFinalizer(lc, (*limitConn).Close) // shouldn't usually be required
return lc, nil
}
type limitConn struct {
close sync.Once
net.Conn
}
func (lc *limitConn) Close() error {
defer lc.close.Do(func() {
limitRelease()
runtime.SetFinalizer(lc, nil)
})
return lc.Conn.Close()
}
================================================
FILE: vendor/google.golang.org/appengine/internal/regen.sh
================================================
#!/bin/bash -e
#
# This script rebuilds the generated code for the protocol buffers.
# To run this you will need protoc and goprotobuf installed;
# see https://github.com/golang/protobuf for instructions.
PKG=google.golang.org/appengine
function die() {
echo 1>&2 $*
exit 1
}
# Sanity check that the right tools are accessible.
for tool in go protoc protoc-gen-go; do
q=$(which $tool) || die "didn't find $tool"
echo 1>&2 "$tool: $q"
done
echo -n 1>&2 "finding package dir... "
pkgdir=$(go list -f '{{.Dir}}' $PKG)
echo 1>&2 $pkgdir
base=$(echo $pkgdir | sed "s,/$PKG\$,,")
echo 1>&2 "base: $base"
cd $base
# Run protoc once per package.
for dir in $(find $PKG/internal -name '*.proto' | xargs dirname | sort | uniq); do
echo 1>&2 "* $dir"
protoc --go_out=. $dir/*.proto
done
for f in $(find $PKG/internal -name '*.pb.go'); do
# Remove proto.RegisterEnum calls.
# These cause duplicate registration panics when these packages
# are used on classic App Engine. proto.RegisterEnum only affects
# parsing the text format; we don't care about that.
# https://code.google.com/p/googleappengine/issues/detail?id=11670#c17
sed -i '/proto.RegisterEnum/d' $f
done
================================================
FILE: vendor/google.golang.org/appengine/internal/remote_api/remote_api.pb.go
================================================
// Code generated by protoc-gen-go.
// source: google.golang.org/appengine/internal/remote_api/remote_api.proto
// DO NOT EDIT!
/*
Package remote_api is a generated protocol buffer package.
It is generated from these files:
google.golang.org/appengine/internal/remote_api/remote_api.proto
It has these top-level messages:
Request
ApplicationError
RpcError
Response
*/
package remote_api
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type RpcError_ErrorCode int32
const (
RpcError_UNKNOWN RpcError_ErrorCode = 0
RpcError_CALL_NOT_FOUND RpcError_ErrorCode = 1
RpcError_PARSE_ERROR RpcError_ErrorCode = 2
RpcError_SECURITY_VIOLATION RpcError_ErrorCode = 3
RpcError_OVER_QUOTA RpcError_ErrorCode = 4
RpcError_REQUEST_TOO_LARGE RpcError_ErrorCode = 5
RpcError_CAPABILITY_DISABLED RpcError_ErrorCode = 6
RpcError_FEATURE_DISABLED RpcError_ErrorCode = 7
RpcError_BAD_REQUEST RpcError_ErrorCode = 8
RpcError_RESPONSE_TOO_LARGE RpcError_ErrorCode = 9
RpcError_CANCELLED RpcError_ErrorCode = 10
RpcError_REPLAY_ERROR RpcError_ErrorCode = 11
RpcError_DEADLINE_EXCEEDED RpcError_ErrorCode = 12
)
var RpcError_ErrorCode_name = map[int32]string{
0: "UNKNOWN",
1: "CALL_NOT_FOUND",
2: "PARSE_ERROR",
3: "SECURITY_VIOLATION",
4: "OVER_QUOTA",
5: "REQUEST_TOO_LARGE",
6: "CAPABILITY_DISABLED",
7: "FEATURE_DISABLED",
8: "BAD_REQUEST",
9: "RESPONSE_TOO_LARGE",
10: "CANCELLED",
11: "REPLAY_ERROR",
12: "DEADLINE_EXCEEDED",
}
var RpcError_ErrorCode_value = map[string]int32{
"UNKNOWN": 0,
"CALL_NOT_FOUND": 1,
"PARSE_ERROR": 2,
"SECURITY_VIOLATION": 3,
"OVER_QUOTA": 4,
"REQUEST_TOO_LARGE": 5,
"CAPABILITY_DISABLED": 6,
"FEATURE_DISABLED": 7,
"BAD_REQUEST": 8,
"RESPONSE_TOO_LARGE": 9,
"CANCELLED": 10,
"REPLAY_ERROR": 11,
"DEADLINE_EXCEEDED": 12,
}
func (x RpcError_ErrorCode) Enum() *RpcError_ErrorCode {
p := new(RpcError_ErrorCode)
*p = x
return p
}
func (x RpcError_ErrorCode) String() string {
return proto.EnumName(RpcError_ErrorCode_name, int32(x))
}
func (x *RpcError_ErrorCode) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(RpcError_ErrorCode_value, data, "RpcError_ErrorCode")
if err != nil {
return err
}
*x = RpcError_ErrorCode(value)
return nil
}
type Request struct {
ServiceName *string `protobuf:"bytes,2,req,name=service_name" json:"service_name,omitempty"`
Method *string `protobuf:"bytes,3,req,name=method" json:"method,omitempty"`
Request []byte `protobuf:"bytes,4,req,name=request" json:"request,omitempty"`
RequestId *string `protobuf:"bytes,5,opt,name=request_id" json:"request_id,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Request) Reset() { *m = Request{} }
func (m *Request) String() string { return proto.CompactTextString(m) }
func (*Request) ProtoMessage() {}
func (m *Request) GetServiceName() string {
if m != nil && m.ServiceName != nil {
return *m.ServiceName
}
return ""
}
func (m *Request) GetMethod() string {
if m != nil && m.Method != nil {
return *m.Method
}
return ""
}
func (m *Request) GetRequest() []byte {
if m != nil {
return m.Request
}
return nil
}
func (m *Request) GetRequestId() string {
if m != nil && m.RequestId != nil {
return *m.RequestId
}
return ""
}
type ApplicationError struct {
Code *int32 `protobuf:"varint,1,req,name=code" json:"code,omitempty"`
Detail *string `protobuf:"bytes,2,req,name=detail" json:"detail,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ApplicationError) Reset() { *m = ApplicationError{} }
func (m *ApplicationError) String() string { return proto.CompactTextString(m) }
func (*ApplicationError) ProtoMessage() {}
func (m *ApplicationError) GetCode() int32 {
if m != nil && m.Code != nil {
return *m.Code
}
return 0
}
func (m *ApplicationError) GetDetail() string {
if m != nil && m.Detail != nil {
return *m.Detail
}
return ""
}
type RpcError struct {
Code *int32 `protobuf:"varint,1,req,name=code" json:"code,omitempty"`
Detail *string `protobuf:"bytes,2,opt,name=detail" json:"detail,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *RpcError) Reset() { *m = RpcError{} }
func (m *RpcError) String() string { return proto.CompactTextString(m) }
func (*RpcError) ProtoMessage() {}
func (m *RpcError) GetCode() int32 {
if m != nil && m.Code != nil {
return *m.Code
}
return 0
}
func (m *RpcError) GetDetail() string {
if m != nil && m.Detail != nil {
return *m.Detail
}
return ""
}
type Response struct {
Response []byte `protobuf:"bytes,1,opt,name=response" json:"response,omitempty"`
Exception []byte `protobuf:"bytes,2,opt,name=exception" json:"exception,omitempty"`
ApplicationError *ApplicationError `protobuf:"bytes,3,opt,name=application_error" json:"application_error,omitempty"`
JavaException []byte `protobuf:"bytes,4,opt,name=java_exception" json:"java_exception,omitempty"`
RpcError *RpcError `protobuf:"bytes,5,opt,name=rpc_error" json:"rpc_error,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Response) Reset() { *m = Response{} }
func (m *Response) String() string { return proto.CompactTextString(m) }
func (*Response) ProtoMessage() {}
func (m *Response) GetResponse() []byte {
if m != nil {
return m.Response
}
return nil
}
func (m *Response) GetException() []byte {
if m != nil {
return m.Exception
}
return nil
}
func (m *Response) GetApplicationError() *ApplicationError {
if m != nil {
return m.ApplicationError
}
return nil
}
func (m *Response) GetJavaException() []byte {
if m != nil {
return m.JavaException
}
return nil
}
func (m *Response) GetRpcError() *RpcError {
if m != nil {
return m.RpcError
}
return nil
}
func init() {
}
================================================
FILE: vendor/google.golang.org/appengine/internal/remote_api/remote_api.proto
================================================
syntax = "proto2";
option go_package = "remote_api";
package remote_api;
message Request {
required string service_name = 2;
required string method = 3;
required bytes request = 4;
optional string request_id = 5;
}
message ApplicationError {
required int32 code = 1;
required string detail = 2;
}
message RpcError {
enum ErrorCode {
UNKNOWN = 0;
CALL_NOT_FOUND = 1;
PARSE_ERROR = 2;
SECURITY_VIOLATION = 3;
OVER_QUOTA = 4;
REQUEST_TOO_LARGE = 5;
CAPABILITY_DISABLED = 6;
FEATURE_DISABLED = 7;
BAD_REQUEST = 8;
RESPONSE_TOO_LARGE = 9;
CANCELLED = 10;
REPLAY_ERROR = 11;
DEADLINE_EXCEEDED = 12;
}
required int32 code = 1;
optional string detail = 2;
}
message Response {
optional bytes response = 1;
optional bytes exception = 2;
optional ApplicationError application_error = 3;
optional bytes java_exception = 4;
optional RpcError rpc_error = 5;
}
================================================
FILE: vendor/google.golang.org/appengine/internal/search/search.pb.go
================================================
// Code generated by protoc-gen-go.
// source: google.golang.org/appengine/internal/search/search.proto
// DO NOT EDIT!
/*
Package search is a generated protocol buffer package.
It is generated from these files:
google.golang.org/appengine/internal/search/search.proto
It has these top-level messages:
Scope
Entry
AccessControlList
FieldValue
Field
FieldTypes
IndexShardSettings
FacetValue
Facet
DocumentMetadata
Document
SearchServiceError
RequestStatus
IndexSpec
IndexMetadata
IndexDocumentParams
IndexDocumentRequest
IndexDocumentResponse
DeleteDocumentParams
DeleteDocumentRequest
DeleteDocumentResponse
ListDocumentsParams
ListDocumentsRequest
ListDocumentsResponse
ListIndexesParams
ListIndexesRequest
ListIndexesResponse
DeleteSchemaParams
DeleteSchemaRequest
DeleteSchemaResponse
SortSpec
ScorerSpec
FieldSpec
FacetRange
FacetRequestParam
FacetAutoDetectParam
FacetRequest
FacetRefinement
SearchParams
SearchRequest
FacetResultValue
FacetResult
SearchResult
SearchResponse
*/
package search
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type Scope_Type int32
const (
Scope_USER_BY_CANONICAL_ID Scope_Type = 1
Scope_USER_BY_EMAIL Scope_Type = 2
Scope_GROUP_BY_CANONICAL_ID Scope_Type = 3
Scope_GROUP_BY_EMAIL Scope_Type = 4
Scope_GROUP_BY_DOMAIN Scope_Type = 5
Scope_ALL_USERS Scope_Type = 6
Scope_ALL_AUTHENTICATED_USERS Scope_Type = 7
)
var Scope_Type_name = map[int32]string{
1: "USER_BY_CANONICAL_ID",
2: "USER_BY_EMAIL",
3: "GROUP_BY_CANONICAL_ID",
4: "GROUP_BY_EMAIL",
5: "GROUP_BY_DOMAIN",
6: "ALL_USERS",
7: "ALL_AUTHENTICATED_USERS",
}
var Scope_Type_value = map[string]int32{
"USER_BY_CANONICAL_ID": 1,
"USER_BY_EMAIL": 2,
"GROUP_BY_CANONICAL_ID": 3,
"GROUP_BY_EMAIL": 4,
"GROUP_BY_DOMAIN": 5,
"ALL_USERS": 6,
"ALL_AUTHENTICATED_USERS": 7,
}
func (x Scope_Type) Enum() *Scope_Type {
p := new(Scope_Type)
*p = x
return p
}
func (x Scope_Type) String() string {
return proto.EnumName(Scope_Type_name, int32(x))
}
func (x *Scope_Type) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(Scope_Type_value, data, "Scope_Type")
if err != nil {
return err
}
*x = Scope_Type(value)
return nil
}
type Entry_Permission int32
const (
Entry_READ Entry_Permission = 1
Entry_WRITE Entry_Permission = 2
Entry_FULL_CONTROL Entry_Permission = 3
)
var Entry_Permission_name = map[int32]string{
1: "READ",
2: "WRITE",
3: "FULL_CONTROL",
}
var Entry_Permission_value = map[string]int32{
"READ": 1,
"WRITE": 2,
"FULL_CONTROL": 3,
}
func (x Entry_Permission) Enum() *Entry_Permission {
p := new(Entry_Permission)
*p = x
return p
}
func (x Entry_Permission) String() string {
return proto.EnumName(Entry_Permission_name, int32(x))
}
func (x *Entry_Permission) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(Entry_Permission_value, data, "Entry_Permission")
if err != nil {
return err
}
*x = Entry_Permission(value)
return nil
}
type FieldValue_ContentType int32
const (
FieldValue_TEXT FieldValue_ContentType = 0
FieldValue_HTML FieldValue_ContentType = 1
FieldValue_ATOM FieldValue_ContentType = 2
FieldValue_DATE FieldValue_ContentType = 3
FieldValue_NUMBER FieldValue_ContentType = 4
FieldValue_GEO FieldValue_ContentType = 5
)
var FieldValue_ContentType_name = map[int32]string{
0: "TEXT",
1: "HTML",
2: "ATOM",
3: "DATE",
4: "NUMBER",
5: "GEO",
}
var FieldValue_ContentType_value = map[string]int32{
"TEXT": 0,
"HTML": 1,
"ATOM": 2,
"DATE": 3,
"NUMBER": 4,
"GEO": 5,
}
func (x FieldValue_ContentType) Enum() *FieldValue_ContentType {
p := new(FieldValue_ContentType)
*p = x
return p
}
func (x FieldValue_ContentType) String() string {
return proto.EnumName(FieldValue_ContentType_name, int32(x))
}
func (x *FieldValue_ContentType) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(FieldValue_ContentType_value, data, "FieldValue_ContentType")
if err != nil {
return err
}
*x = FieldValue_ContentType(value)
return nil
}
type FacetValue_ContentType int32
const (
FacetValue_ATOM FacetValue_ContentType = 2
FacetValue_NUMBER FacetValue_ContentType = 4
)
var FacetValue_ContentType_name = map[int32]string{
2: "ATOM",
4: "NUMBER",
}
var FacetValue_ContentType_value = map[string]int32{
"ATOM": 2,
"NUMBER": 4,
}
func (x FacetValue_ContentType) Enum() *FacetValue_ContentType {
p := new(FacetValue_ContentType)
*p = x
return p
}
func (x FacetValue_ContentType) String() string {
return proto.EnumName(FacetValue_ContentType_name, int32(x))
}
func (x *FacetValue_ContentType) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(FacetValue_ContentType_value, data, "FacetValue_ContentType")
if err != nil {
return err
}
*x = FacetValue_ContentType(value)
return nil
}
type Document_Storage int32
const (
Document_DISK Document_Storage = 0
)
var Document_Storage_name = map[int32]string{
0: "DISK",
}
var Document_Storage_value = map[string]int32{
"DISK": 0,
}
func (x Document_Storage) Enum() *Document_Storage {
p := new(Document_Storage)
*p = x
return p
}
func (x Document_Storage) String() string {
return proto.EnumName(Document_Storage_name, int32(x))
}
func (x *Document_Storage) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(Document_Storage_value, data, "Document_Storage")
if err != nil {
return err
}
*x = Document_Storage(value)
return nil
}
type SearchServiceError_ErrorCode int32
const (
SearchServiceError_OK SearchServiceError_ErrorCode = 0
SearchServiceError_INVALID_REQUEST SearchServiceError_ErrorCode = 1
SearchServiceError_TRANSIENT_ERROR SearchServiceError_ErrorCode = 2
SearchServiceError_INTERNAL_ERROR SearchServiceError_ErrorCode = 3
SearchServiceError_PERMISSION_DENIED SearchServiceError_ErrorCode = 4
SearchServiceError_TIMEOUT SearchServiceError_ErrorCode = 5
SearchServiceError_CONCURRENT_TRANSACTION SearchServiceError_ErrorCode = 6
)
var SearchServiceError_ErrorCode_name = map[int32]string{
0: "OK",
1: "INVALID_REQUEST",
2: "TRANSIENT_ERROR",
3: "INTERNAL_ERROR",
4: "PERMISSION_DENIED",
5: "TIMEOUT",
6: "CONCURRENT_TRANSACTION",
}
var SearchServiceError_ErrorCode_value = map[string]int32{
"OK": 0,
"INVALID_REQUEST": 1,
"TRANSIENT_ERROR": 2,
"INTERNAL_ERROR": 3,
"PERMISSION_DENIED": 4,
"TIMEOUT": 5,
"CONCURRENT_TRANSACTION": 6,
}
func (x SearchServiceError_ErrorCode) Enum() *SearchServiceError_ErrorCode {
p := new(SearchServiceError_ErrorCode)
*p = x
return p
}
func (x SearchServiceError_ErrorCode) String() string {
return proto.EnumName(SearchServiceError_ErrorCode_name, int32(x))
}
func (x *SearchServiceError_ErrorCode) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(SearchServiceError_ErrorCode_value, data, "SearchServiceError_ErrorCode")
if err != nil {
return err
}
*x = SearchServiceError_ErrorCode(value)
return nil
}
type IndexSpec_Consistency int32
const (
IndexSpec_GLOBAL IndexSpec_Consistency = 0
IndexSpec_PER_DOCUMENT IndexSpec_Consistency = 1
)
var IndexSpec_Consistency_name = map[int32]string{
0: "GLOBAL",
1: "PER_DOCUMENT",
}
var IndexSpec_Consistency_value = map[string]int32{
"GLOBAL": 0,
"PER_DOCUMENT": 1,
}
func (x IndexSpec_Consistency) Enum() *IndexSpec_Consistency {
p := new(IndexSpec_Consistency)
*p = x
return p
}
func (x IndexSpec_Consistency) String() string {
return proto.EnumName(IndexSpec_Consistency_name, int32(x))
}
func (x *IndexSpec_Consistency) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(IndexSpec_Consistency_value, data, "IndexSpec_Consistency")
if err != nil {
return err
}
*x = IndexSpec_Consistency(value)
return nil
}
type IndexSpec_Source int32
const (
IndexSpec_SEARCH IndexSpec_Source = 0
IndexSpec_DATASTORE IndexSpec_Source = 1
IndexSpec_CLOUD_STORAGE IndexSpec_Source = 2
)
var IndexSpec_Source_name = map[int32]string{
0: "SEARCH",
1: "DATASTORE",
2: "CLOUD_STORAGE",
}
var IndexSpec_Source_value = map[string]int32{
"SEARCH": 0,
"DATASTORE": 1,
"CLOUD_STORAGE": 2,
}
func (x IndexSpec_Source) Enum() *IndexSpec_Source {
p := new(IndexSpec_Source)
*p = x
return p
}
func (x IndexSpec_Source) String() string {
return proto.EnumName(IndexSpec_Source_name, int32(x))
}
func (x *IndexSpec_Source) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(IndexSpec_Source_value, data, "IndexSpec_Source")
if err != nil {
return err
}
*x = IndexSpec_Source(value)
return nil
}
type IndexSpec_Mode int32
const (
IndexSpec_PRIORITY IndexSpec_Mode = 0
IndexSpec_BACKGROUND IndexSpec_Mode = 1
)
var IndexSpec_Mode_name = map[int32]string{
0: "PRIORITY",
1: "BACKGROUND",
}
var IndexSpec_Mode_value = map[string]int32{
"PRIORITY": 0,
"BACKGROUND": 1,
}
func (x IndexSpec_Mode) Enum() *IndexSpec_Mode {
p := new(IndexSpec_Mode)
*p = x
return p
}
func (x IndexSpec_Mode) String() string {
return proto.EnumName(IndexSpec_Mode_name, int32(x))
}
func (x *IndexSpec_Mode) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(IndexSpec_Mode_value, data, "IndexSpec_Mode")
if err != nil {
return err
}
*x = IndexSpec_Mode(value)
return nil
}
type IndexDocumentParams_Freshness int32
const (
IndexDocumentParams_SYNCHRONOUSLY IndexDocumentParams_Freshness = 0
IndexDocumentParams_WHEN_CONVENIENT IndexDocumentParams_Freshness = 1
)
var IndexDocumentParams_Freshness_name = map[int32]string{
0: "SYNCHRONOUSLY",
1: "WHEN_CONVENIENT",
}
var IndexDocumentParams_Freshness_value = map[string]int32{
"SYNCHRONOUSLY": 0,
"WHEN_CONVENIENT": 1,
}
func (x IndexDocumentParams_Freshness) Enum() *IndexDocumentParams_Freshness {
p := new(IndexDocumentParams_Freshness)
*p = x
return p
}
func (x IndexDocumentParams_Freshness) String() string {
return proto.EnumName(IndexDocumentParams_Freshness_name, int32(x))
}
func (x *IndexDocumentParams_Freshness) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(IndexDocumentParams_Freshness_value, data, "IndexDocumentParams_Freshness")
if err != nil {
return err
}
*x = IndexDocumentParams_Freshness(value)
return nil
}
type ScorerSpec_Scorer int32
const (
ScorerSpec_RESCORING_MATCH_SCORER ScorerSpec_Scorer = 0
ScorerSpec_MATCH_SCORER ScorerSpec_Scorer = 2
)
var ScorerSpec_Scorer_name = map[int32]string{
0: "RESCORING_MATCH_SCORER",
2: "MATCH_SCORER",
}
var ScorerSpec_Scorer_value = map[string]int32{
"RESCORING_MATCH_SCORER": 0,
"MATCH_SCORER": 2,
}
func (x ScorerSpec_Scorer) Enum() *ScorerSpec_Scorer {
p := new(ScorerSpec_Scorer)
*p = x
return p
}
func (x ScorerSpec_Scorer) String() string {
return proto.EnumName(ScorerSpec_Scorer_name, int32(x))
}
func (x *ScorerSpec_Scorer) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(ScorerSpec_Scorer_value, data, "ScorerSpec_Scorer")
if err != nil {
return err
}
*x = ScorerSpec_Scorer(value)
return nil
}
type SearchParams_CursorType int32
const (
SearchParams_NONE SearchParams_CursorType = 0
SearchParams_SINGLE SearchParams_CursorType = 1
SearchParams_PER_RESULT SearchParams_CursorType = 2
)
var SearchParams_CursorType_name = map[int32]string{
0: "NONE",
1: "SINGLE",
2: "PER_RESULT",
}
var SearchParams_CursorType_value = map[string]int32{
"NONE": 0,
"SINGLE": 1,
"PER_RESULT": 2,
}
func (x SearchParams_CursorType) Enum() *SearchParams_CursorType {
p := new(SearchParams_CursorType)
*p = x
return p
}
func (x SearchParams_CursorType) String() string {
return proto.EnumName(SearchParams_CursorType_name, int32(x))
}
func (x *SearchParams_CursorType) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(SearchParams_CursorType_value, data, "SearchParams_CursorType")
if err != nil {
return err
}
*x = SearchParams_CursorType(value)
return nil
}
type SearchParams_ParsingMode int32
const (
SearchParams_STRICT SearchParams_ParsingMode = 0
SearchParams_RELAXED SearchParams_ParsingMode = 1
)
var SearchParams_ParsingMode_name = map[int32]string{
0: "STRICT",
1: "RELAXED",
}
var SearchParams_ParsingMode_value = map[string]int32{
"STRICT": 0,
"RELAXED": 1,
}
func (x SearchParams_ParsingMode) Enum() *SearchParams_ParsingMode {
p := new(SearchParams_ParsingMode)
*p = x
return p
}
func (x SearchParams_ParsingMode) String() string {
return proto.EnumName(SearchParams_ParsingMode_name, int32(x))
}
func (x *SearchParams_ParsingMode) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(SearchParams_ParsingMode_value, data, "SearchParams_ParsingMode")
if err != nil {
return err
}
*x = SearchParams_ParsingMode(value)
return nil
}
type Scope struct {
Type *Scope_Type `protobuf:"varint,1,opt,name=type,enum=search.Scope_Type" json:"type,omitempty"`
Value *string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Scope) Reset() { *m = Scope{} }
func (m *Scope) String() string { return proto.CompactTextString(m) }
func (*Scope) ProtoMessage() {}
func (m *Scope) GetType() Scope_Type {
if m != nil && m.Type != nil {
return *m.Type
}
return Scope_USER_BY_CANONICAL_ID
}
func (m *Scope) GetValue() string {
if m != nil && m.Value != nil {
return *m.Value
}
return ""
}
type Entry struct {
Scope *Scope `protobuf:"bytes,1,opt,name=scope" json:"scope,omitempty"`
Permission *Entry_Permission `protobuf:"varint,2,opt,name=permission,enum=search.Entry_Permission" json:"permission,omitempty"`
DisplayName *string `protobuf:"bytes,3,opt,name=display_name" json:"display_name,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Entry) Reset() { *m = Entry{} }
func (m *Entry) String() string { return proto.CompactTextString(m) }
func (*Entry) ProtoMessage() {}
func (m *Entry) GetScope() *Scope {
if m != nil {
return m.Scope
}
return nil
}
func (m *Entry) GetPermission() Entry_Permission {
if m != nil && m.Permission != nil {
return *m.Permission
}
return Entry_READ
}
func (m *Entry) GetDisplayName() string {
if m != nil && m.DisplayName != nil {
return *m.DisplayName
}
return ""
}
type AccessControlList struct {
Owner *string `protobuf:"bytes,1,opt,name=owner" json:"owner,omitempty"`
Entries []*Entry `protobuf:"bytes,2,rep,name=entries" json:"entries,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *AccessControlList) Reset() { *m = AccessControlList{} }
func (m *AccessControlList) String() string { return proto.CompactTextString(m) }
func (*AccessControlList) ProtoMessage() {}
func (m *AccessControlList) GetOwner() string {
if m != nil && m.Owner != nil {
return *m.Owner
}
return ""
}
func (m *AccessControlList) GetEntries() []*Entry {
if m != nil {
return m.Entries
}
return nil
}
type FieldValue struct {
Type *FieldValue_ContentType `protobuf:"varint,1,opt,name=type,enum=search.FieldValue_ContentType,def=0" json:"type,omitempty"`
Language *string `protobuf:"bytes,2,opt,name=language,def=en" json:"language,omitempty"`
StringValue *string `protobuf:"bytes,3,opt,name=string_value" json:"string_value,omitempty"`
Geo *FieldValue_Geo `protobuf:"group,4,opt,name=Geo" json:"geo,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *FieldValue) Reset() { *m = FieldValue{} }
func (m *FieldValue) String() string { return proto.CompactTextString(m) }
func (*FieldValue) ProtoMessage() {}
const Default_FieldValue_Type FieldValue_ContentType = FieldValue_TEXT
const Default_FieldValue_Language string = "en"
func (m *FieldValue) GetType() FieldValue_ContentType {
if m != nil && m.Type != nil {
return *m.Type
}
return Default_FieldValue_Type
}
func (m *FieldValue) GetLanguage() string {
if m != nil && m.Language != nil {
return *m.Language
}
return Default_FieldValue_Language
}
func (m *FieldValue) GetStringValue() string {
if m != nil && m.StringValue != nil {
return *m.StringValue
}
return ""
}
func (m *FieldValue) GetGeo() *FieldValue_Geo {
if m != nil {
return m.Geo
}
return nil
}
type FieldValue_Geo struct {
Lat *float64 `protobuf:"fixed64,5,req,name=lat" json:"lat,omitempty"`
Lng *float64 `protobuf:"fixed64,6,req,name=lng" json:"lng,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *FieldValue_Geo) Reset() { *m = FieldValue_Geo{} }
func (m *FieldValue_Geo) String() string { return proto.CompactTextString(m) }
func (*FieldValue_Geo) ProtoMessage() {}
func (m *FieldValue_Geo) GetLat() float64 {
if m != nil && m.Lat != nil {
return *m.Lat
}
return 0
}
func (m *FieldValue_Geo) GetLng() float64 {
if m != nil && m.Lng != nil {
return *m.Lng
}
return 0
}
type Field struct {
Name *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
Value *FieldValue `protobuf:"bytes,2,req,name=value" json:"value,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Field) Reset() { *m = Field{} }
func (m *Field) String() string { return proto.CompactTextString(m) }
func (*Field) ProtoMessage() {}
func (m *Field) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *Field) GetValue() *FieldValue {
if m != nil {
return m.Value
}
return nil
}
type FieldTypes struct {
Name *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
Type []FieldValue_ContentType `protobuf:"varint,2,rep,name=type,enum=search.FieldValue_ContentType" json:"type,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *FieldTypes) Reset() { *m = FieldTypes{} }
func (m *FieldTypes) String() string { return proto.CompactTextString(m) }
func (*FieldTypes) ProtoMessage() {}
func (m *FieldTypes) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *FieldTypes) GetType() []FieldValue_ContentType {
if m != nil {
return m.Type
}
return nil
}
type IndexShardSettings struct {
PrevNumShards []int32 `protobuf:"varint,1,rep,name=prev_num_shards" json:"prev_num_shards,omitempty"`
NumShards *int32 `protobuf:"varint,2,req,name=num_shards,def=1" json:"num_shards,omitempty"`
PrevNumShardsSearchFalse []int32 `protobuf:"varint,3,rep,name=prev_num_shards_search_false" json:"prev_num_shards_search_false,omitempty"`
LocalReplica *string `protobuf:"bytes,4,opt,name=local_replica,def=" json:"local_replica,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *IndexShardSettings) Reset() { *m = IndexShardSettings{} }
func (m *IndexShardSettings) String() string { return proto.CompactTextString(m) }
func (*IndexShardSettings) ProtoMessage() {}
const Default_IndexShardSettings_NumShards int32 = 1
func (m *IndexShardSettings) GetPrevNumShards() []int32 {
if m != nil {
return m.PrevNumShards
}
return nil
}
func (m *IndexShardSettings) GetNumShards() int32 {
if m != nil && m.NumShards != nil {
return *m.NumShards
}
return Default_IndexShardSettings_NumShards
}
func (m *IndexShardSettings) GetPrevNumShardsSearchFalse() []int32 {
if m != nil {
return m.PrevNumShardsSearchFalse
}
return nil
}
func (m *IndexShardSettings) GetLocalReplica() string {
if m != nil && m.LocalReplica != nil {
return *m.LocalReplica
}
return ""
}
type FacetValue struct {
Type *FacetValue_ContentType `protobuf:"varint,1,opt,name=type,enum=search.FacetValue_ContentType,def=2" json:"type,omitempty"`
StringValue *string `protobuf:"bytes,3,opt,name=string_value" json:"string_value,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *FacetValue) Reset() { *m = FacetValue{} }
func (m *FacetValue) String() string { return proto.CompactTextString(m) }
func (*FacetValue) ProtoMessage() {}
const Default_FacetValue_Type FacetValue_ContentType = FacetValue_ATOM
func (m *FacetValue) GetType() FacetValue_ContentType {
if m != nil && m.Type != nil {
return *m.Type
}
return Default_FacetValue_Type
}
func (m *FacetValue) GetStringValue() string {
if m != nil && m.StringValue != nil {
return *m.StringValue
}
return ""
}
type Facet struct {
Name *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
Value *FacetValue `protobuf:"bytes,2,req,name=value" json:"value,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Facet) Reset() { *m = Facet{} }
func (m *Facet) String() string { return proto.CompactTextString(m) }
func (*Facet) ProtoMessage() {}
func (m *Facet) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *Facet) GetValue() *FacetValue {
if m != nil {
return m.Value
}
return nil
}
type DocumentMetadata struct {
Version *int64 `protobuf:"varint,1,opt,name=version" json:"version,omitempty"`
CommittedStVersion *int64 `protobuf:"varint,2,opt,name=committed_st_version" json:"committed_st_version,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *DocumentMetadata) Reset() { *m = DocumentMetadata{} }
func (m *DocumentMetadata) String() string { return proto.CompactTextString(m) }
func (*DocumentMetadata) ProtoMessage() {}
func (m *DocumentMetadata) GetVersion() int64 {
if m != nil && m.Version != nil {
return *m.Version
}
return 0
}
func (m *DocumentMetadata) GetCommittedStVersion() int64 {
if m != nil && m.CommittedStVersion != nil {
return *m.CommittedStVersion
}
return 0
}
type Document struct {
Id *string `protobuf:"bytes,1,opt,name=id" json:"id,omitempty"`
Language *string `protobuf:"bytes,2,opt,name=language,def=en" json:"language,omitempty"`
Field []*Field `protobuf:"bytes,3,rep,name=field" json:"field,omitempty"`
OrderId *int32 `protobuf:"varint,4,opt,name=order_id" json:"order_id,omitempty"`
Storage *Document_Storage `protobuf:"varint,5,opt,name=storage,enum=search.Document_Storage,def=0" json:"storage,omitempty"`
Facet []*Facet `protobuf:"bytes,8,rep,name=facet" json:"facet,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Document) Reset() { *m = Document{} }
func (m *Document) String() string { return proto.CompactTextString(m) }
func (*Document) ProtoMessage() {}
const Default_Document_Language string = "en"
const Default_Document_Storage Document_Storage = Document_DISK
func (m *Document) GetId() string {
if m != nil && m.Id != nil {
return *m.Id
}
return ""
}
func (m *Document) GetLanguage() string {
if m != nil && m.Language != nil {
return *m.Language
}
return Default_Document_Language
}
func (m *Document) GetField() []*Field {
if m != nil {
return m.Field
}
return nil
}
func (m *Document) GetOrderId() int32 {
if m != nil && m.OrderId != nil {
return *m.OrderId
}
return 0
}
func (m *Document) GetStorage() Document_Storage {
if m != nil && m.Storage != nil {
return *m.Storage
}
return Default_Document_Storage
}
func (m *Document) GetFacet() []*Facet {
if m != nil {
return m.Facet
}
return nil
}
type SearchServiceError struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *SearchServiceError) Reset() { *m = SearchServiceError{} }
func (m *SearchServiceError) String() string { return proto.CompactTextString(m) }
func (*SearchServiceError) ProtoMessage() {}
type RequestStatus struct {
Code *SearchServiceError_ErrorCode `protobuf:"varint,1,req,name=code,enum=search.SearchServiceError_ErrorCode" json:"code,omitempty"`
ErrorDetail *string `protobuf:"bytes,2,opt,name=error_detail" json:"error_detail,omitempty"`
CanonicalCode *int32 `protobuf:"varint,3,opt,name=canonical_code" json:"canonical_code,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *RequestStatus) Reset() { *m = RequestStatus{} }
func (m *RequestStatus) String() string { return proto.CompactTextString(m) }
func (*RequestStatus) ProtoMessage() {}
func (m *RequestStatus) GetCode() SearchServiceError_ErrorCode {
if m != nil && m.Code != nil {
return *m.Code
}
return SearchServiceError_OK
}
func (m *RequestStatus) GetErrorDetail() string {
if m != nil && m.ErrorDetail != nil {
return *m.ErrorDetail
}
return ""
}
func (m *RequestStatus) GetCanonicalCode() int32 {
if m != nil && m.CanonicalCode != nil {
return *m.CanonicalCode
}
return 0
}
type IndexSpec struct {
Name *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
Consistency *IndexSpec_Consistency `protobuf:"varint,2,opt,name=consistency,enum=search.IndexSpec_Consistency,def=1" json:"consistency,omitempty"`
Namespace *string `protobuf:"bytes,3,opt,name=namespace" json:"namespace,omitempty"`
Version *int32 `protobuf:"varint,4,opt,name=version" json:"version,omitempty"`
Source *IndexSpec_Source `protobuf:"varint,5,opt,name=source,enum=search.IndexSpec_Source,def=0" json:"source,omitempty"`
Mode *IndexSpec_Mode `protobuf:"varint,6,opt,name=mode,enum=search.IndexSpec_Mode,def=0" json:"mode,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *IndexSpec) Reset() { *m = IndexSpec{} }
func (m *IndexSpec) String() string { return proto.CompactTextString(m) }
func (*IndexSpec) ProtoMessage() {}
const Default_IndexSpec_Consistency IndexSpec_Consistency = IndexSpec_PER_DOCUMENT
const Default_IndexSpec_Source IndexSpec_Source = IndexSpec_SEARCH
const Default_IndexSpec_Mode IndexSpec_Mode = IndexSpec_PRIORITY
func (m *IndexSpec) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *IndexSpec) GetConsistency() IndexSpec_Consistency {
if m != nil && m.Consistency != nil {
return *m.Consistency
}
return Default_IndexSpec_Consistency
}
func (m *IndexSpec) GetNamespace() string {
if m != nil && m.Namespace != nil {
return *m.Namespace
}
return ""
}
func (m *IndexSpec) GetVersion() int32 {
if m != nil && m.Version != nil {
return *m.Version
}
return 0
}
func (m *IndexSpec) GetSource() IndexSpec_Source {
if m != nil && m.Source != nil {
return *m.Source
}
return Default_IndexSpec_Source
}
func (m *IndexSpec) GetMode() IndexSpec_Mode {
if m != nil && m.Mode != nil {
return *m.Mode
}
return Default_IndexSpec_Mode
}
type IndexMetadata struct {
IndexSpec *IndexSpec `protobuf:"bytes,1,req,name=index_spec" json:"index_spec,omitempty"`
Field []*FieldTypes `protobuf:"bytes,2,rep,name=field" json:"field,omitempty"`
Storage *IndexMetadata_Storage `protobuf:"bytes,3,opt,name=storage" json:"storage,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *IndexMetadata) Reset() { *m = IndexMetadata{} }
func (m *IndexMetadata) String() string { return proto.CompactTextString(m) }
func (*IndexMetadata) ProtoMessage() {}
func (m *IndexMetadata) GetIndexSpec() *IndexSpec {
if m != nil {
return m.IndexSpec
}
return nil
}
func (m *IndexMetadata) GetField() []*FieldTypes {
if m != nil {
return m.Field
}
return nil
}
func (m *IndexMetadata) GetStorage() *IndexMetadata_Storage {
if m != nil {
return m.Storage
}
return nil
}
type IndexMetadata_Storage struct {
AmountUsed *int64 `protobuf:"varint,1,opt,name=amount_used" json:"amount_used,omitempty"`
Limit *int64 `protobuf:"varint,2,opt,name=limit" json:"limit,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *IndexMetadata_Storage) Reset() { *m = IndexMetadata_Storage{} }
func (m *IndexMetadata_Storage) String() string { return proto.CompactTextString(m) }
func (*IndexMetadata_Storage) ProtoMessage() {}
func (m *IndexMetadata_Storage) GetAmountUsed() int64 {
if m != nil && m.AmountUsed != nil {
return *m.AmountUsed
}
return 0
}
func (m *IndexMetadata_Storage) GetLimit() int64 {
if m != nil && m.Limit != nil {
return *m.Limit
}
return 0
}
type IndexDocumentParams struct {
Document []*Document `protobuf:"bytes,1,rep,name=document" json:"document,omitempty"`
Freshness *IndexDocumentParams_Freshness `protobuf:"varint,2,opt,name=freshness,enum=search.IndexDocumentParams_Freshness,def=0" json:"freshness,omitempty"`
IndexSpec *IndexSpec `protobuf:"bytes,3,req,name=index_spec" json:"index_spec,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *IndexDocumentParams) Reset() { *m = IndexDocumentParams{} }
func (m *IndexDocumentParams) String() string { return proto.CompactTextString(m) }
func (*IndexDocumentParams) ProtoMessage() {}
const Default_IndexDocumentParams_Freshness IndexDocumentParams_Freshness = IndexDocumentParams_SYNCHRONOUSLY
func (m *IndexDocumentParams) GetDocument() []*Document {
if m != nil {
return m.Document
}
return nil
}
func (m *IndexDocumentParams) GetFreshness() IndexDocumentParams_Freshness {
if m != nil && m.Freshness != nil {
return *m.Freshness
}
return Default_IndexDocumentParams_Freshness
}
func (m *IndexDocumentParams) GetIndexSpec() *IndexSpec {
if m != nil {
return m.IndexSpec
}
return nil
}
type IndexDocumentRequest struct {
Params *IndexDocumentParams `protobuf:"bytes,1,req,name=params" json:"params,omitempty"`
AppId []byte `protobuf:"bytes,3,opt,name=app_id" json:"app_id,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *IndexDocumentRequest) Reset() { *m = IndexDocumentRequest{} }
func (m *IndexDocumentRequest) String() string { return proto.CompactTextString(m) }
func (*IndexDocumentRequest) ProtoMessage() {}
func (m *IndexDocumentRequest) GetParams() *IndexDocumentParams {
if m != nil {
return m.Params
}
return nil
}
func (m *IndexDocumentRequest) GetAppId() []byte {
if m != nil {
return m.AppId
}
return nil
}
type IndexDocumentResponse struct {
Status []*RequestStatus `protobuf:"bytes,1,rep,name=status" json:"status,omitempty"`
DocId []string `protobuf:"bytes,2,rep,name=doc_id" json:"doc_id,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *IndexDocumentResponse) Reset() { *m = IndexDocumentResponse{} }
func (m *IndexDocumentResponse) String() string { return proto.CompactTextString(m) }
func (*IndexDocumentResponse) ProtoMessage() {}
func (m *IndexDocumentResponse) GetStatus() []*RequestStatus {
if m != nil {
return m.Status
}
return nil
}
func (m *IndexDocumentResponse) GetDocId() []string {
if m != nil {
return m.DocId
}
return nil
}
type DeleteDocumentParams struct {
DocId []string `protobuf:"bytes,1,rep,name=doc_id" json:"doc_id,omitempty"`
IndexSpec *IndexSpec `protobuf:"bytes,2,req,name=index_spec" json:"index_spec,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *DeleteDocumentParams) Reset() { *m = DeleteDocumentParams{} }
func (m *DeleteDocumentParams) String() string { return proto.CompactTextString(m) }
func (*DeleteDocumentParams) ProtoMessage() {}
func (m *DeleteDocumentParams) GetDocId() []string {
if m != nil {
return m.DocId
}
return nil
}
func (m *DeleteDocumentParams) GetIndexSpec() *IndexSpec {
if m != nil {
return m.IndexSpec
}
return nil
}
type DeleteDocumentRequest struct {
Params *DeleteDocumentParams `protobuf:"bytes,1,req,name=params" json:"params,omitempty"`
AppId []byte `protobuf:"bytes,3,opt,name=app_id" json:"app_id,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *DeleteDocumentRequest) Reset() { *m = DeleteDocumentRequest{} }
func (m *DeleteDocumentRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteDocumentRequest) ProtoMessage() {}
func (m *DeleteDocumentRequest) GetParams() *DeleteDocumentParams {
if m != nil {
return m.Params
}
return nil
}
func (m *DeleteDocumentRequest) GetAppId() []byte {
if m != nil {
return m.AppId
}
return nil
}
type DeleteDocumentResponse struct {
Status []*RequestStatus `protobuf:"bytes,1,rep,name=status" json:"status,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *DeleteDocumentResponse) Reset() { *m = DeleteDocumentResponse{} }
func (m *DeleteDocumentResponse) String() string { return proto.CompactTextString(m) }
func (*DeleteDocumentResponse) ProtoMessage() {}
func (m *DeleteDocumentResponse) GetStatus() []*RequestStatus {
if m != nil {
return m.Status
}
return nil
}
type ListDocumentsParams struct {
IndexSpec *IndexSpec `protobuf:"bytes,1,req,name=index_spec" json:"index_spec,omitempty"`
StartDocId *string `protobuf:"bytes,2,opt,name=start_doc_id" json:"start_doc_id,omitempty"`
IncludeStartDoc *bool `protobuf:"varint,3,opt,name=include_start_doc,def=1" json:"include_start_doc,omitempty"`
Limit *int32 `protobuf:"varint,4,opt,name=limit,def=100" json:"limit,omitempty"`
KeysOnly *bool `protobuf:"varint,5,opt,name=keys_only" json:"keys_only,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ListDocumentsParams) Reset() { *m = ListDocumentsParams{} }
func (m *ListDocumentsParams) String() string { return proto.CompactTextString(m) }
func (*ListDocumentsParams) ProtoMessage() {}
const Default_ListDocumentsParams_IncludeStartDoc bool = true
const Default_ListDocumentsParams_Limit int32 = 100
func (m *ListDocumentsParams) GetIndexSpec() *IndexSpec {
if m != nil {
return m.IndexSpec
}
return nil
}
func (m *ListDocumentsParams) GetStartDocId() string {
if m != nil && m.StartDocId != nil {
return *m.StartDocId
}
return ""
}
func (m *ListDocumentsParams) GetIncludeStartDoc() bool {
if m != nil && m.IncludeStartDoc != nil {
return *m.IncludeStartDoc
}
return Default_ListDocumentsParams_IncludeStartDoc
}
func (m *ListDocumentsParams) GetLimit() int32 {
if m != nil && m.Limit != nil {
return *m.Limit
}
return Default_ListDocumentsParams_Limit
}
func (m *ListDocumentsParams) GetKeysOnly() bool {
if m != nil && m.KeysOnly != nil {
return *m.KeysOnly
}
return false
}
type ListDocumentsRequest struct {
Params *ListDocumentsParams `protobuf:"bytes,1,req,name=params" json:"params,omitempty"`
AppId []byte `protobuf:"bytes,2,opt,name=app_id" json:"app_id,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ListDocumentsRequest) Reset() { *m = ListDocumentsRequest{} }
func (m *ListDocumentsRequest) String() string { return proto.CompactTextString(m) }
func (*ListDocumentsRequest) ProtoMessage() {}
func (m *ListDocumentsRequest) GetParams() *ListDocumentsParams {
if m != nil {
return m.Params
}
return nil
}
func (m *ListDocumentsRequest) GetAppId() []byte {
if m != nil {
return m.AppId
}
return nil
}
type ListDocumentsResponse struct {
Status *RequestStatus `protobuf:"bytes,1,req,name=status" json:"status,omitempty"`
Document []*Document `protobuf:"bytes,2,rep,name=document" json:"document,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ListDocumentsResponse) Reset() { *m = ListDocumentsResponse{} }
func (m *ListDocumentsResponse) String() string { return proto.CompactTextString(m) }
func (*ListDocumentsResponse) ProtoMessage() {}
func (m *ListDocumentsResponse) GetStatus() *RequestStatus {
if m != nil {
return m.Status
}
return nil
}
func (m *ListDocumentsResponse) GetDocument() []*Document {
if m != nil {
return m.Document
}
return nil
}
type ListIndexesParams struct {
FetchSchema *bool `protobuf:"varint,1,opt,name=fetch_schema" json:"fetch_schema,omitempty"`
Limit *int32 `protobuf:"varint,2,opt,name=limit,def=20" json:"limit,omitempty"`
Namespace *string `protobuf:"bytes,3,opt,name=namespace" json:"namespace,omitempty"`
StartIndexName *string `protobuf:"bytes,4,opt,name=start_index_name" json:"start_index_name,omitempty"`
IncludeStartIndex *bool `protobuf:"varint,5,opt,name=include_start_index,def=1" json:"include_start_index,omitempty"`
IndexNamePrefix *string `protobuf:"bytes,6,opt,name=index_name_prefix" json:"index_name_prefix,omitempty"`
Offset *int32 `protobuf:"varint,7,opt,name=offset" json:"offset,omitempty"`
Source *IndexSpec_Source `protobuf:"varint,8,opt,name=source,enum=search.IndexSpec_Source,def=0" json:"source,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ListIndexesParams) Reset() { *m = ListIndexesParams{} }
func (m *ListIndexesParams) String() string { return proto.CompactTextString(m) }
func (*ListIndexesParams) ProtoMessage() {}
const Default_ListIndexesParams_Limit int32 = 20
const Default_ListIndexesParams_IncludeStartIndex bool = true
const Default_ListIndexesParams_Source IndexSpec_Source = IndexSpec_SEARCH
func (m *ListIndexesParams) GetFetchSchema() bool {
if m != nil && m.FetchSchema != nil {
return *m.FetchSchema
}
return false
}
func (m *ListIndexesParams) GetLimit() int32 {
if m != nil && m.Limit != nil {
return *m.Limit
}
return Default_ListIndexesParams_Limit
}
func (m *ListIndexesParams) GetNamespace() string {
if m != nil && m.Namespace != nil {
return *m.Namespace
}
return ""
}
func (m *ListIndexesParams) GetStartIndexName() string {
if m != nil && m.StartIndexName != nil {
return *m.StartIndexName
}
return ""
}
func (m *ListIndexesParams) GetIncludeStartIndex() bool {
if m != nil && m.IncludeStartIndex != nil {
return *m.IncludeStartIndex
}
return Default_ListIndexesParams_IncludeStartIndex
}
func (m *ListIndexesParams) GetIndexNamePrefix() string {
if m != nil && m.IndexNamePrefix != nil {
return *m.IndexNamePrefix
}
return ""
}
func (m *ListIndexesParams) GetOffset() int32 {
if m != nil && m.Offset != nil {
return *m.Offset
}
return 0
}
func (m *ListIndexesParams) GetSource() IndexSpec_Source {
if m != nil && m.Source != nil {
return *m.Source
}
return Default_ListIndexesParams_Source
}
type ListIndexesRequest struct {
Params *ListIndexesParams `protobuf:"bytes,1,req,name=params" json:"params,omitempty"`
AppId []byte `protobuf:"bytes,3,opt,name=app_id" json:"app_id,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ListIndexesRequest) Reset() { *m = ListIndexesRequest{} }
func (m *ListIndexesRequest) String() string { return proto.CompactTextString(m) }
func (*ListIndexesRequest) ProtoMessage() {}
func (m *ListIndexesRequest) GetParams() *ListIndexesParams {
if m != nil {
return m.Params
}
return nil
}
func (m *ListIndexesRequest) GetAppId() []byte {
if m != nil {
return m.AppId
}
return nil
}
type ListIndexesResponse struct {
Status *RequestStatus `protobuf:"bytes,1,req,name=status" json:"status,omitempty"`
IndexMetadata []*IndexMetadata `protobuf:"bytes,2,rep,name=index_metadata" json:"index_metadata,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ListIndexesResponse) Reset() { *m = ListIndexesResponse{} }
func (m *ListIndexesResponse) String() string { return proto.CompactTextString(m) }
func (*ListIndexesResponse) ProtoMessage() {}
func (m *ListIndexesResponse) GetStatus() *RequestStatus {
if m != nil {
return m.Status
}
return nil
}
func (m *ListIndexesResponse) GetIndexMetadata() []*IndexMetadata {
if m != nil {
return m.IndexMetadata
}
return nil
}
type DeleteSchemaParams struct {
Source *IndexSpec_Source `protobuf:"varint,1,opt,name=source,enum=search.IndexSpec_Source,def=0" json:"source,omitempty"`
IndexSpec []*IndexSpec `protobuf:"bytes,2,rep,name=index_spec" json:"index_spec,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *DeleteSchemaParams) Reset() { *m = DeleteSchemaParams{} }
func (m *DeleteSchemaParams) String() string { return proto.CompactTextString(m) }
func (*DeleteSchemaParams) ProtoMessage() {}
const Default_DeleteSchemaParams_Source IndexSpec_Source = IndexSpec_SEARCH
func (m *DeleteSchemaParams) GetSource() IndexSpec_Source {
if m != nil && m.Source != nil {
return *m.Source
}
return Default_DeleteSchemaParams_Source
}
func (m *DeleteSchemaParams) GetIndexSpec() []*IndexSpec {
if m != nil {
return m.IndexSpec
}
return nil
}
type DeleteSchemaRequest struct {
Params *DeleteSchemaParams `protobuf:"bytes,1,req,name=params" json:"params,omitempty"`
AppId []byte `protobuf:"bytes,3,opt,name=app_id" json:"app_id,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *DeleteSchemaRequest) Reset() { *m = DeleteSchemaRequest{} }
func (m *DeleteSchemaRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteSchemaRequest) ProtoMessage() {}
func (m *DeleteSchemaRequest) GetParams() *DeleteSchemaParams {
if m != nil {
return m.Params
}
return nil
}
func (m *DeleteSchemaRequest) GetAppId() []byte {
if m != nil {
return m.AppId
}
return nil
}
type DeleteSchemaResponse struct {
Status []*RequestStatus `protobuf:"bytes,1,rep,name=status" json:"status,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *DeleteSchemaResponse) Reset() { *m = DeleteSchemaResponse{} }
func (m *DeleteSchemaResponse) String() string { return proto.CompactTextString(m) }
func (*DeleteSchemaResponse) ProtoMessage() {}
func (m *DeleteSchemaResponse) GetStatus() []*RequestStatus {
if m != nil {
return m.Status
}
return nil
}
type SortSpec struct {
SortExpression *string `protobuf:"bytes,1,req,name=sort_expression" json:"sort_expression,omitempty"`
SortDescending *bool `protobuf:"varint,2,opt,name=sort_descending,def=1" json:"sort_descending,omitempty"`
DefaultValueText *string `protobuf:"bytes,4,opt,name=default_value_text" json:"default_value_text,omitempty"`
DefaultValueNumeric *float64 `protobuf:"fixed64,5,opt,name=default_value_numeric" json:"default_value_numeric,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *SortSpec) Reset() { *m = SortSpec{} }
func (m *SortSpec) String() string { return proto.CompactTextString(m) }
func (*SortSpec) ProtoMessage() {}
const Default_SortSpec_SortDescending bool = true
func (m *SortSpec) GetSortExpression() string {
if m != nil && m.SortExpression != nil {
return *m.SortExpression
}
return ""
}
func (m *SortSpec) GetSortDescending() bool {
if m != nil && m.SortDescending != nil {
return *m.SortDescending
}
return Default_SortSpec_SortDescending
}
func (m *SortSpec) GetDefaultValueText() string {
if m != nil && m.DefaultValueText != nil {
return *m.DefaultValueText
}
return ""
}
func (m *SortSpec) GetDefaultValueNumeric() float64 {
if m != nil && m.DefaultValueNumeric != nil {
return *m.DefaultValueNumeric
}
return 0
}
type ScorerSpec struct {
Scorer *ScorerSpec_Scorer `protobuf:"varint,1,opt,name=scorer,enum=search.ScorerSpec_Scorer,def=2" json:"scorer,omitempty"`
Limit *int32 `protobuf:"varint,2,opt,name=limit,def=1000" json:"limit,omitempty"`
MatchScorerParameters *string `protobuf:"bytes,9,opt,name=match_scorer_parameters" json:"match_scorer_parameters,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ScorerSpec) Reset() { *m = ScorerSpec{} }
func (m *ScorerSpec) String() string { return proto.CompactTextString(m) }
func (*ScorerSpec) ProtoMessage() {}
const Default_ScorerSpec_Scorer ScorerSpec_Scorer = ScorerSpec_MATCH_SCORER
const Default_ScorerSpec_Limit int32 = 1000
func (m *ScorerSpec) GetScorer() ScorerSpec_Scorer {
if m != nil && m.Scorer != nil {
return *m.Scorer
}
return Default_ScorerSpec_Scorer
}
func (m *ScorerSpec) GetLimit() int32 {
if m != nil && m.Limit != nil {
return *m.Limit
}
return Default_ScorerSpec_Limit
}
func (m *ScorerSpec) GetMatchScorerParameters() string {
if m != nil && m.MatchScorerParameters != nil {
return *m.MatchScorerParameters
}
return ""
}
type FieldSpec struct {
Name []string `protobuf:"bytes,1,rep,name=name" json:"name,omitempty"`
Expression []*FieldSpec_Expression `protobuf:"group,2,rep,name=Expression" json:"expression,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *FieldSpec) Reset() { *m = FieldSpec{} }
func (m *FieldSpec) String() string { return proto.CompactTextString(m) }
func (*FieldSpec) ProtoMessage() {}
func (m *FieldSpec) GetName() []string {
if m != nil {
return m.Name
}
return nil
}
func (m *FieldSpec) GetExpression() []*FieldSpec_Expression {
if m != nil {
return m.Expression
}
return nil
}
type FieldSpec_Expression struct {
Name *string `protobuf:"bytes,3,req,name=name" json:"name,omitempty"`
Expression *string `protobuf:"bytes,4,req,name=expression" json:"expression,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *FieldSpec_Expression) Reset() { *m = FieldSpec_Expression{} }
func (m *FieldSpec_Expression) String() string { return proto.CompactTextString(m) }
func (*FieldSpec_Expression) ProtoMessage() {}
func (m *FieldSpec_Expression) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *FieldSpec_Expression) GetExpression() string {
if m != nil && m.Expression != nil {
return *m.Expression
}
return ""
}
type FacetRange struct {
Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
Start *string `protobuf:"bytes,2,opt,name=start" json:"start,omitempty"`
End *string `protobuf:"bytes,3,opt,name=end" json:"end,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *FacetRange) Reset() { *m = FacetRange{} }
func (m *FacetRange) String() string { return proto.CompactTextString(m) }
func (*FacetRange) ProtoMessage() {}
func (m *FacetRange) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *FacetRange) GetStart() string {
if m != nil && m.Start != nil {
return *m.Start
}
return ""
}
func (m *FacetRange) GetEnd() string {
if m != nil && m.End != nil {
return *m.End
}
return ""
}
type FacetRequestParam struct {
ValueLimit *int32 `protobuf:"varint,1,opt,name=value_limit" json:"value_limit,omitempty"`
Range []*FacetRange `protobuf:"bytes,2,rep,name=range" json:"range,omitempty"`
ValueConstraint []string `protobuf:"bytes,3,rep,name=value_constraint" json:"value_constraint,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *FacetRequestParam) Reset() { *m = FacetRequestParam{} }
func (m *FacetRequestParam) String() string { return proto.CompactTextString(m) }
func (*FacetRequestParam) ProtoMessage() {}
func (m *FacetRequestParam) GetValueLimit() int32 {
if m != nil && m.ValueLimit != nil {
return *m.ValueLimit
}
return 0
}
func (m *FacetRequestParam) GetRange() []*FacetRange {
if m != nil {
return m.Range
}
return nil
}
func (m *FacetRequestParam) GetValueConstraint() []string {
if m != nil {
return m.ValueConstraint
}
return nil
}
type FacetAutoDetectParam struct {
ValueLimit *int32 `protobuf:"varint,1,opt,name=value_limit,def=10" json:"value_limit,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *FacetAutoDetectParam) Reset() { *m = FacetAutoDetectParam{} }
func (m *FacetAutoDetectParam) String() string { return proto.CompactTextString(m) }
func (*FacetAutoDetectParam) ProtoMessage() {}
const Default_FacetAutoDetectParam_ValueLimit int32 = 10
func (m *FacetAutoDetectParam) GetValueLimit() int32 {
if m != nil && m.ValueLimit != nil {
return *m.ValueLimit
}
return Default_FacetAutoDetectParam_ValueLimit
}
type FacetRequest struct {
Name *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
Params *FacetRequestParam `protobuf:"bytes,2,opt,name=params" json:"params,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *FacetRequest) Reset() { *m = FacetRequest{} }
func (m *FacetRequest) String() string { return proto.CompactTextString(m) }
func (*FacetRequest) ProtoMessage() {}
func (m *FacetRequest) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *FacetRequest) GetParams() *FacetRequestParam {
if m != nil {
return m.Params
}
return nil
}
type FacetRefinement struct {
Name *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
Value *string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
Range *FacetRefinement_Range `protobuf:"bytes,3,opt,name=range" json:"range,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *FacetRefinement) Reset() { *m = FacetRefinement{} }
func (m *FacetRefinement) String() string { return proto.CompactTextString(m) }
func (*FacetRefinement) ProtoMessage() {}
func (m *FacetRefinement) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *FacetRefinement) GetValue() string {
if m != nil && m.Value != nil {
return *m.Value
}
return ""
}
func (m *FacetRefinement) GetRange() *FacetRefinement_Range {
if m != nil {
return m.Range
}
return nil
}
type FacetRefinement_Range struct {
Start *string `protobuf:"bytes,1,opt,name=start" json:"start,omitempty"`
End *string `protobuf:"bytes,2,opt,name=end" json:"end,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *FacetRefinement_Range) Reset() { *m = FacetRefinement_Range{} }
func (m *FacetRefinement_Range) String() string { return proto.CompactTextString(m) }
func (*FacetRefinement_Range) ProtoMessage() {}
func (m *FacetRefinement_Range) GetStart() string {
if m != nil && m.Start != nil {
return *m.Start
}
return ""
}
func (m *FacetRefinement_Range) GetEnd() string {
if m != nil && m.End != nil {
return *m.End
}
return ""
}
type SearchParams struct {
IndexSpec *IndexSpec `protobuf:"bytes,1,req,name=index_spec" json:"index_spec,omitempty"`
Query *string `protobuf:"bytes,2,req,name=query" json:"query,omitempty"`
Cursor *string `protobuf:"bytes,4,opt,name=cursor" json:"cursor,omitempty"`
Offset *int32 `protobuf:"varint,11,opt,name=offset" json:"offset,omitempty"`
CursorType *SearchParams_CursorType `protobuf:"varint,5,opt,name=cursor_type,enum=search.SearchParams_CursorType,def=0" json:"cursor_type,omitempty"`
Limit *int32 `protobuf:"varint,6,opt,name=limit,def=20" json:"limit,omitempty"`
MatchedCountAccuracy *int32 `protobuf:"varint,7,opt,name=matched_count_accuracy" json:"matched_count_accuracy,omitempty"`
SortSpec []*SortSpec `protobuf:"bytes,8,rep,name=sort_spec" json:"sort_spec,omitempty"`
ScorerSpec *ScorerSpec `protobuf:"bytes,9,opt,name=scorer_spec" json:"scorer_spec,omitempty"`
FieldSpec *FieldSpec `protobuf:"bytes,10,opt,name=field_spec" json:"field_spec,omitempty"`
KeysOnly *bool `protobuf:"varint,12,opt,name=keys_only" json:"keys_only,omitempty"`
ParsingMode *SearchParams_ParsingMode `protobuf:"varint,13,opt,name=parsing_mode,enum=search.SearchParams_ParsingMode,def=0" json:"parsing_mode,omitempty"`
AutoDiscoverFacetCount *int32 `protobuf:"varint,15,opt,name=auto_discover_facet_count,def=0" json:"auto_discover_facet_count,omitempty"`
IncludeFacet []*FacetRequest `protobuf:"bytes,16,rep,name=include_facet" json:"include_facet,omitempty"`
FacetRefinement []*FacetRefinement `protobuf:"bytes,17,rep,name=facet_refinement" json:"facet_refinement,omitempty"`
FacetAutoDetectParam *FacetAutoDetectParam `protobuf:"bytes,18,opt,name=facet_auto_detect_param" json:"facet_auto_detect_param,omitempty"`
FacetDepth *int32 `protobuf:"varint,19,opt,name=facet_depth,def=1000" json:"facet_depth,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *SearchParams) Reset() { *m = SearchParams{} }
func (m *SearchParams) String() string { return proto.CompactTextString(m) }
func (*SearchParams) ProtoMessage() {}
const Default_SearchParams_CursorType SearchParams_CursorType = SearchParams_NONE
const Default_SearchParams_Limit int32 = 20
const Default_SearchParams_ParsingMode SearchParams_ParsingMode = SearchParams_STRICT
const Default_SearchParams_AutoDiscoverFacetCount int32 = 0
const Default_SearchParams_FacetDepth int32 = 1000
func (m *SearchParams) GetIndexSpec() *IndexSpec {
if m != nil {
return m.IndexSpec
}
return nil
}
func (m *SearchParams) GetQuery() string {
if m != nil && m.Query != nil {
return *m.Query
}
return ""
}
func (m *SearchParams) GetCursor() string {
if m != nil && m.Cursor != nil {
return *m.Cursor
}
return ""
}
func (m *SearchParams) GetOffset() int32 {
if m != nil && m.Offset != nil {
return *m.Offset
}
return 0
}
func (m *SearchParams) GetCursorType() SearchParams_CursorType {
if m != nil && m.CursorType != nil {
return *m.CursorType
}
return Default_SearchParams_CursorType
}
func (m *SearchParams) GetLimit() int32 {
if m != nil && m.Limit != nil {
return *m.Limit
}
return Default_SearchParams_Limit
}
func (m *SearchParams) GetMatchedCountAccuracy() int32 {
if m != nil && m.MatchedCountAccuracy != nil {
return *m.MatchedCountAccuracy
}
return 0
}
func (m *SearchParams) GetSortSpec() []*SortSpec {
if m != nil {
return m.SortSpec
}
return nil
}
func (m *SearchParams) GetScorerSpec() *ScorerSpec {
if m != nil {
return m.ScorerSpec
}
return nil
}
func (m *SearchParams) GetFieldSpec() *FieldSpec {
if m != nil {
return m.FieldSpec
}
return nil
}
func (m *SearchParams) GetKeysOnly() bool {
if m != nil && m.KeysOnly != nil {
return *m.KeysOnly
}
return false
}
func (m *SearchParams) GetParsingMode() SearchParams_ParsingMode {
if m != nil && m.ParsingMode != nil {
return *m.ParsingMode
}
return Default_SearchParams_ParsingMode
}
func (m *SearchParams) GetAutoDiscoverFacetCount() int32 {
if m != nil && m.AutoDiscoverFacetCount != nil {
return *m.AutoDiscoverFacetCount
}
return Default_SearchParams_AutoDiscoverFacetCount
}
func (m *SearchParams) GetIncludeFacet() []*FacetRequest {
if m != nil {
return m.IncludeFacet
}
return nil
}
func (m *SearchParams) GetFacetRefinement() []*FacetRefinement {
if m != nil {
return m.FacetRefinement
}
return nil
}
func (m *SearchParams) GetFacetAutoDetectParam() *FacetAutoDetectParam {
if m != nil {
return m.FacetAutoDetectParam
}
return nil
}
func (m *SearchParams) GetFacetDepth() int32 {
if m != nil && m.FacetDepth != nil {
return *m.FacetDepth
}
return Default_SearchParams_FacetDepth
}
type SearchRequest struct {
Params *SearchParams `protobuf:"bytes,1,req,name=params" json:"params,omitempty"`
AppId []byte `protobuf:"bytes,3,opt,name=app_id" json:"app_id,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *SearchRequest) Reset() { *m = SearchRequest{} }
func (m *SearchRequest) String() string { return proto.CompactTextString(m) }
func (*SearchRequest) ProtoMessage() {}
func (m *SearchRequest) GetParams() *SearchParams {
if m != nil {
return m.Params
}
return nil
}
func (m *SearchRequest) GetAppId() []byte {
if m != nil {
return m.AppId
}
return nil
}
type FacetResultValue struct {
Name *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
Count *int32 `protobuf:"varint,2,req,name=count" json:"count,omitempty"`
Refinement *FacetRefinement `protobuf:"bytes,3,req,name=refinement" json:"refinement,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *FacetResultValue) Reset() { *m = FacetResultValue{} }
func (m *FacetResultValue) String() string { return proto.CompactTextString(m) }
func (*FacetResultValue) ProtoMessage() {}
func (m *FacetResultValue) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *FacetResultValue) GetCount() int32 {
if m != nil && m.Count != nil {
return *m.Count
}
return 0
}
func (m *FacetResultValue) GetRefinement() *FacetRefinement {
if m != nil {
return m.Refinement
}
return nil
}
type FacetResult struct {
Name *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
Value []*FacetResultValue `protobuf:"bytes,2,rep,name=value" json:"value,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *FacetResult) Reset() { *m = FacetResult{} }
func (m *FacetResult) String() string { return proto.CompactTextString(m) }
func (*FacetResult) ProtoMessage() {}
func (m *FacetResult) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *FacetResult) GetValue() []*FacetResultValue {
if m != nil {
return m.Value
}
return nil
}
type SearchResult struct {
Document *Document `protobuf:"bytes,1,req,name=document" json:"document,omitempty"`
Expression []*Field `protobuf:"bytes,4,rep,name=expression" json:"expression,omitempty"`
Score []float64 `protobuf:"fixed64,2,rep,name=score" json:"score,omitempty"`
Cursor *string `protobuf:"bytes,3,opt,name=cursor" json:"cursor,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *SearchResult) Reset() { *m = SearchResult{} }
func (m *SearchResult) String() string { return proto.CompactTextString(m) }
func (*SearchResult) ProtoMessage() {}
func (m *SearchResult) GetDocument() *Document {
if m != nil {
return m.Document
}
return nil
}
func (m *SearchResult) GetExpression() []*Field {
if m != nil {
return m.Expression
}
return nil
}
func (m *SearchResult) GetScore() []float64 {
if m != nil {
return m.Score
}
return nil
}
func (m *SearchResult) GetCursor() string {
if m != nil && m.Cursor != nil {
return *m.Cursor
}
return ""
}
type SearchResponse struct {
Result []*SearchResult `protobuf:"bytes,1,rep,name=result" json:"result,omitempty"`
MatchedCount *int64 `protobuf:"varint,2,req,name=matched_count" json:"matched_count,omitempty"`
Status *RequestStatus `protobuf:"bytes,3,req,name=status" json:"status,omitempty"`
Cursor *string `protobuf:"bytes,4,opt,name=cursor" json:"cursor,omitempty"`
FacetResult []*FacetResult `protobuf:"bytes,5,rep,name=facet_result" json:"facet_result,omitempty"`
XXX_extensions map[int32]proto.Extension `json:"-"`
XXX_unrecognized []byte `json:"-"`
}
func (m *SearchResponse) Reset() { *m = SearchResponse{} }
func (m *SearchResponse) String() string { return proto.CompactTextString(m) }
func (*SearchResponse) ProtoMessage() {}
var extRange_SearchResponse = []proto.ExtensionRange{
{1000, 9999},
}
func (*SearchResponse) ExtensionRangeArray() []proto.ExtensionRange {
return extRange_SearchResponse
}
func (m *SearchResponse) ExtensionMap() map[int32]proto.Extension {
if m.XXX_extensions == nil {
m.XXX_extensions = make(map[int32]proto.Extension)
}
return m.XXX_extensions
}
func (m *SearchResponse) GetResult() []*SearchResult {
if m != nil {
return m.Result
}
return nil
}
func (m *SearchResponse) GetMatchedCount() int64 {
if m != nil && m.MatchedCount != nil {
return *m.MatchedCount
}
return 0
}
func (m *SearchResponse) GetStatus() *RequestStatus {
if m != nil {
return m.Status
}
return nil
}
func (m *SearchResponse) GetCursor() string {
if m != nil && m.Cursor != nil {
return *m.Cursor
}
return ""
}
func (m *SearchResponse) GetFacetResult() []*FacetResult {
if m != nil {
return m.FacetResult
}
return nil
}
func init() {
}
================================================
FILE: vendor/google.golang.org/appengine/internal/search/search.proto
================================================
syntax = "proto2";
option go_package = "search";
package search;
message Scope {
enum Type {
USER_BY_CANONICAL_ID = 1;
USER_BY_EMAIL = 2;
GROUP_BY_CANONICAL_ID = 3;
GROUP_BY_EMAIL = 4;
GROUP_BY_DOMAIN = 5;
ALL_USERS = 6;
ALL_AUTHENTICATED_USERS = 7;
}
optional Type type = 1;
optional string value = 2;
}
message Entry {
enum Permission {
READ = 1;
WRITE = 2;
FULL_CONTROL = 3;
}
optional Scope scope = 1;
optional Permission permission = 2;
optional string display_name = 3;
}
message AccessControlList {
optional string owner = 1;
repeated Entry entries = 2;
}
message FieldValue {
enum ContentType {
TEXT = 0;
HTML = 1;
ATOM = 2;
DATE = 3;
NUMBER = 4;
GEO = 5;
}
optional ContentType type = 1 [default = TEXT];
optional string language = 2 [default = "en"];
optional string string_value = 3;
optional group Geo = 4 {
required double lat = 5;
required double lng = 6;
}
}
message Field {
required string name = 1;
required FieldValue value = 2;
}
message FieldTypes {
required string name = 1;
repeated FieldValue.ContentType type = 2;
}
message IndexShardSettings {
repeated int32 prev_num_shards = 1;
required int32 num_shards = 2 [default=1];
repeated int32 prev_num_shards_search_false = 3;
optional string local_replica = 4 [default = ""];
}
message FacetValue {
enum ContentType {
ATOM = 2;
NUMBER = 4;
}
optional ContentType type = 1 [default = ATOM];
optional string string_value = 3;
}
message Facet {
required string name = 1;
required FacetValue value = 2;
}
message DocumentMetadata {
optional int64 version = 1;
optional int64 committed_st_version = 2;
}
message Document {
optional string id = 1;
optional string language = 2 [default = "en"];
repeated Field field = 3;
optional int32 order_id = 4;
enum Storage {
DISK = 0;
}
optional Storage storage = 5 [default = DISK];
repeated Facet facet = 8;
}
message SearchServiceError {
enum ErrorCode {
OK = 0;
INVALID_REQUEST = 1;
TRANSIENT_ERROR = 2;
INTERNAL_ERROR = 3;
PERMISSION_DENIED = 4;
TIMEOUT = 5;
CONCURRENT_TRANSACTION = 6;
}
}
message RequestStatus {
required SearchServiceError.ErrorCode code = 1;
optional string error_detail = 2;
optional int32 canonical_code = 3;
}
message IndexSpec {
required string name = 1;
enum Consistency {
GLOBAL = 0;
PER_DOCUMENT = 1;
}
optional Consistency consistency = 2 [default = PER_DOCUMENT];
optional string namespace = 3;
optional int32 version = 4;
enum Source {
SEARCH = 0;
DATASTORE = 1;
CLOUD_STORAGE = 2;
}
optional Source source = 5 [default = SEARCH];
enum Mode {
PRIORITY = 0;
BACKGROUND = 1;
}
optional Mode mode = 6 [default = PRIORITY];
}
message IndexMetadata {
required IndexSpec index_spec = 1;
repeated FieldTypes field = 2;
message Storage {
optional int64 amount_used = 1;
optional int64 limit = 2;
}
optional Storage storage = 3;
}
message IndexDocumentParams {
repeated Document document = 1;
enum Freshness {
SYNCHRONOUSLY = 0;
WHEN_CONVENIENT = 1;
}
optional Freshness freshness = 2 [default = SYNCHRONOUSLY, deprecated=true];
required IndexSpec index_spec = 3;
}
message IndexDocumentRequest {
required IndexDocumentParams params = 1;
optional bytes app_id = 3;
}
message IndexDocumentResponse {
repeated RequestStatus status = 1;
repeated string doc_id = 2;
}
message DeleteDocumentParams {
repeated string doc_id = 1;
required IndexSpec index_spec = 2;
}
message DeleteDocumentRequest {
required DeleteDocumentParams params = 1;
optional bytes app_id = 3;
}
message DeleteDocumentResponse {
repeated RequestStatus status = 1;
}
message ListDocumentsParams {
required IndexSpec index_spec = 1;
optional string start_doc_id = 2;
optional bool include_start_doc = 3 [default = true];
optional int32 limit = 4 [default = 100];
optional bool keys_only = 5;
}
message ListDocumentsRequest {
required ListDocumentsParams params = 1;
optional bytes app_id = 2;
}
message ListDocumentsResponse {
required RequestStatus status = 1;
repeated Document document = 2;
}
message ListIndexesParams {
optional bool fetch_schema = 1;
optional int32 limit = 2 [default = 20];
optional string namespace = 3;
optional string start_index_name = 4;
optional bool include_start_index = 5 [default = true];
optional string index_name_prefix = 6;
optional int32 offset = 7;
optional IndexSpec.Source source = 8 [default = SEARCH];
}
message ListIndexesRequest {
required ListIndexesParams params = 1;
optional bytes app_id = 3;
}
message ListIndexesResponse {
required RequestStatus status = 1;
repeated IndexMetadata index_metadata = 2;
}
message DeleteSchemaParams {
optional IndexSpec.Source source = 1 [default = SEARCH];
repeated IndexSpec index_spec = 2;
}
message DeleteSchemaRequest {
required DeleteSchemaParams params = 1;
optional bytes app_id = 3;
}
message DeleteSchemaResponse {
repeated RequestStatus status = 1;
}
message SortSpec {
required string sort_expression = 1;
optional bool sort_descending = 2 [default = true];
optional string default_value_text = 4;
optional double default_value_numeric = 5;
}
message ScorerSpec {
enum Scorer {
RESCORING_MATCH_SCORER = 0;
MATCH_SCORER = 2;
}
optional Scorer scorer = 1 [default = MATCH_SCORER];
optional int32 limit = 2 [default = 1000];
optional string match_scorer_parameters = 9;
}
message FieldSpec {
repeated string name = 1;
repeated group Expression = 2 {
required string name = 3;
required string expression = 4;
}
}
message FacetRange {
optional string name = 1;
optional string start = 2;
optional string end = 3;
}
message FacetRequestParam {
optional int32 value_limit = 1;
repeated FacetRange range = 2;
repeated string value_constraint = 3;
}
message FacetAutoDetectParam {
optional int32 value_limit = 1 [default = 10];
}
message FacetRequest {
required string name = 1;
optional FacetRequestParam params = 2;
}
message FacetRefinement {
required string name = 1;
optional string value = 2;
message Range {
optional string start = 1;
optional string end = 2;
}
optional Range range = 3;
}
message SearchParams {
required IndexSpec index_spec = 1;
required string query = 2;
optional string cursor = 4;
optional int32 offset = 11;
enum CursorType {
NONE = 0;
SINGLE = 1;
PER_RESULT = 2;
}
optional CursorType cursor_type = 5 [default = NONE];
optional int32 limit = 6 [default = 20];
optional int32 matched_count_accuracy = 7;
repeated SortSpec sort_spec = 8;
optional ScorerSpec scorer_spec = 9;
optional FieldSpec field_spec = 10;
optional bool keys_only = 12;
enum ParsingMode {
STRICT = 0;
RELAXED = 1;
}
optional ParsingMode parsing_mode = 13 [default = STRICT];
optional int32 auto_discover_facet_count = 15 [default = 0];
repeated FacetRequest include_facet = 16;
repeated FacetRefinement facet_refinement = 17;
optional FacetAutoDetectParam facet_auto_detect_param = 18;
optional int32 facet_depth = 19 [default=1000];
}
message SearchRequest {
required SearchParams params = 1;
optional bytes app_id = 3;
}
message FacetResultValue {
required string name = 1;
required int32 count = 2;
required FacetRefinement refinement = 3;
}
message FacetResult {
required string name = 1;
repeated FacetResultValue value = 2;
}
message SearchResult {
required Document document = 1;
repeated Field expression = 4;
repeated double score = 2;
optional string cursor = 3;
}
message SearchResponse {
repeated SearchResult result = 1;
required int64 matched_count = 2;
required RequestStatus status = 3;
optional string cursor = 4;
repeated FacetResult facet_result = 5;
extensions 1000 to 9999;
}
================================================
FILE: vendor/google.golang.org/appengine/internal/socket/socket_service.pb.go
================================================
// Code generated by protoc-gen-go.
// source: google.golang.org/appengine/internal/socket/socket_service.proto
// DO NOT EDIT!
/*
Package socket is a generated protocol buffer package.
It is generated from these files:
google.golang.org/appengine/internal/socket/socket_service.proto
It has these top-level messages:
RemoteSocketServiceError
AddressPort
CreateSocketRequest
CreateSocketReply
BindRequest
BindReply
GetSocketNameRequest
GetSocketNameReply
GetPeerNameRequest
GetPeerNameReply
SocketOption
SetSocketOptionsRequest
SetSocketOptionsReply
GetSocketOptionsRequest
GetSocketOptionsReply
ConnectRequest
ConnectReply
ListenRequest
ListenReply
AcceptRequest
AcceptReply
ShutDownRequest
ShutDownReply
CloseRequest
CloseReply
SendRequest
SendReply
ReceiveRequest
ReceiveReply
PollEvent
PollRequest
PollReply
ResolveRequest
ResolveReply
*/
package socket
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type RemoteSocketServiceError_ErrorCode int32
const (
RemoteSocketServiceError_SYSTEM_ERROR RemoteSocketServiceError_ErrorCode = 1
RemoteSocketServiceError_GAI_ERROR RemoteSocketServiceError_ErrorCode = 2
RemoteSocketServiceError_FAILURE RemoteSocketServiceError_ErrorCode = 4
RemoteSocketServiceError_PERMISSION_DENIED RemoteSocketServiceError_ErrorCode = 5
RemoteSocketServiceError_INVALID_REQUEST RemoteSocketServiceError_ErrorCode = 6
RemoteSocketServiceError_SOCKET_CLOSED RemoteSocketServiceError_ErrorCode = 7
)
var RemoteSocketServiceError_ErrorCode_name = map[int32]string{
1: "SYSTEM_ERROR",
2: "GAI_ERROR",
4: "FAILURE",
5: "PERMISSION_DENIED",
6: "INVALID_REQUEST",
7: "SOCKET_CLOSED",
}
var RemoteSocketServiceError_ErrorCode_value = map[string]int32{
"SYSTEM_ERROR": 1,
"GAI_ERROR": 2,
"FAILURE": 4,
"PERMISSION_DENIED": 5,
"INVALID_REQUEST": 6,
"SOCKET_CLOSED": 7,
}
func (x RemoteSocketServiceError_ErrorCode) Enum() *RemoteSocketServiceError_ErrorCode {
p := new(RemoteSocketServiceError_ErrorCode)
*p = x
return p
}
func (x RemoteSocketServiceError_ErrorCode) String() string {
return proto.EnumName(RemoteSocketServiceError_ErrorCode_name, int32(x))
}
func (x *RemoteSocketServiceError_ErrorCode) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(RemoteSocketServiceError_ErrorCode_value, data, "RemoteSocketServiceError_ErrorCode")
if err != nil {
return err
}
*x = RemoteSocketServiceError_ErrorCode(value)
return nil
}
type RemoteSocketServiceError_SystemError int32
const (
RemoteSocketServiceError_SYS_SUCCESS RemoteSocketServiceError_SystemError = 0
RemoteSocketServiceError_SYS_EPERM RemoteSocketServiceError_SystemError = 1
RemoteSocketServiceError_SYS_ENOENT RemoteSocketServiceError_SystemError = 2
RemoteSocketServiceError_SYS_ESRCH RemoteSocketServiceError_SystemError = 3
RemoteSocketServiceError_SYS_EINTR RemoteSocketServiceError_SystemError = 4
RemoteSocketServiceError_SYS_EIO RemoteSocketServiceError_SystemError = 5
RemoteSocketServiceError_SYS_ENXIO RemoteSocketServiceError_SystemError = 6
RemoteSocketServiceError_SYS_E2BIG RemoteSocketServiceError_SystemError = 7
RemoteSocketServiceError_SYS_ENOEXEC RemoteSocketServiceError_SystemError = 8
RemoteSocketServiceError_SYS_EBADF RemoteSocketServiceError_SystemError = 9
RemoteSocketServiceError_SYS_ECHILD RemoteSocketServiceError_SystemError = 10
RemoteSocketServiceError_SYS_EAGAIN RemoteSocketServiceError_SystemError = 11
RemoteSocketServiceError_SYS_EWOULDBLOCK RemoteSocketServiceError_SystemError = 11
RemoteSocketServiceError_SYS_ENOMEM RemoteSocketServiceError_SystemError = 12
RemoteSocketServiceError_SYS_EACCES RemoteSocketServiceError_SystemError = 13
RemoteSocketServiceError_SYS_EFAULT RemoteSocketServiceError_SystemError = 14
RemoteSocketServiceError_SYS_ENOTBLK RemoteSocketServiceError_SystemError = 15
RemoteSocketServiceError_SYS_EBUSY RemoteSocketServiceError_SystemError = 16
RemoteSocketServiceError_SYS_EEXIST RemoteSocketServiceError_SystemError = 17
RemoteSocketServiceError_SYS_EXDEV RemoteSocketServiceError_SystemError = 18
RemoteSocketServiceError_SYS_ENODEV RemoteSocketServiceError_SystemError = 19
RemoteSocketServiceError_SYS_ENOTDIR RemoteSocketServiceError_SystemError = 20
RemoteSocketServiceError_SYS_EISDIR RemoteSocketServiceError_SystemError = 21
RemoteSocketServiceError_SYS_EINVAL RemoteSocketServiceError_SystemError = 22
RemoteSocketServiceError_SYS_ENFILE RemoteSocketServiceError_SystemError = 23
RemoteSocketServiceError_SYS_EMFILE RemoteSocketServiceError_SystemError = 24
RemoteSocketServiceError_SYS_ENOTTY RemoteSocketServiceError_SystemError = 25
RemoteSocketServiceError_SYS_ETXTBSY RemoteSocketServiceError_SystemError = 26
RemoteSocketServiceError_SYS_EFBIG RemoteSocketServiceError_SystemError = 27
RemoteSocketServiceError_SYS_ENOSPC RemoteSocketServiceError_SystemError = 28
RemoteSocketServiceError_SYS_ESPIPE RemoteSocketServiceError_SystemError = 29
RemoteSocketServiceError_SYS_EROFS RemoteSocketServiceError_SystemError = 30
RemoteSocketServiceError_SYS_EMLINK RemoteSocketServiceError_SystemError = 31
RemoteSocketServiceError_SYS_EPIPE RemoteSocketServiceError_SystemError = 32
RemoteSocketServiceError_SYS_EDOM RemoteSocketServiceError_SystemError = 33
RemoteSocketServiceError_SYS_ERANGE RemoteSocketServiceError_SystemError = 34
RemoteSocketServiceError_SYS_EDEADLK RemoteSocketServiceError_SystemError = 35
RemoteSocketServiceError_SYS_EDEADLOCK RemoteSocketServiceError_SystemError = 35
RemoteSocketServiceError_SYS_ENAMETOOLONG RemoteSocketServiceError_SystemError = 36
RemoteSocketServiceError_SYS_ENOLCK RemoteSocketServiceError_SystemError = 37
RemoteSocketServiceError_SYS_ENOSYS RemoteSocketServiceError_SystemError = 38
RemoteSocketServiceError_SYS_ENOTEMPTY RemoteSocketServiceError_SystemError = 39
RemoteSocketServiceError_SYS_ELOOP RemoteSocketServiceError_SystemError = 40
RemoteSocketServiceError_SYS_ENOMSG RemoteSocketServiceError_SystemError = 42
RemoteSocketServiceError_SYS_EIDRM RemoteSocketServiceError_SystemError = 43
RemoteSocketServiceError_SYS_ECHRNG RemoteSocketServiceError_SystemError = 44
RemoteSocketServiceError_SYS_EL2NSYNC RemoteSocketServiceError_SystemError = 45
RemoteSocketServiceError_SYS_EL3HLT RemoteSocketServiceError_SystemError = 46
RemoteSocketServiceError_SYS_EL3RST RemoteSocketServiceError_SystemError = 47
RemoteSocketServiceError_SYS_ELNRNG RemoteSocketServiceError_SystemError = 48
RemoteSocketServiceError_SYS_EUNATCH RemoteSocketServiceError_SystemError = 49
RemoteSocketServiceError_SYS_ENOCSI RemoteSocketServiceError_SystemError = 50
RemoteSocketServiceError_SYS_EL2HLT RemoteSocketServiceError_SystemError = 51
RemoteSocketServiceError_SYS_EBADE RemoteSocketServiceError_SystemError = 52
RemoteSocketServiceError_SYS_EBADR RemoteSocketServiceError_SystemError = 53
RemoteSocketServiceError_SYS_EXFULL RemoteSocketServiceError_SystemError = 54
RemoteSocketServiceError_SYS_ENOANO RemoteSocketServiceError_SystemError = 55
RemoteSocketServiceError_SYS_EBADRQC RemoteSocketServiceError_SystemError = 56
RemoteSocketServiceError_SYS_EBADSLT RemoteSocketServiceError_SystemError = 57
RemoteSocketServiceError_SYS_EBFONT RemoteSocketServiceError_SystemError = 59
RemoteSocketServiceError_SYS_ENOSTR RemoteSocketServiceError_SystemError = 60
RemoteSocketServiceError_SYS_ENODATA RemoteSocketServiceError_SystemError = 61
RemoteSocketServiceError_SYS_ETIME RemoteSocketServiceError_SystemError = 62
RemoteSocketServiceError_SYS_ENOSR RemoteSocketServiceError_SystemError = 63
RemoteSocketServiceError_SYS_ENONET RemoteSocketServiceError_SystemError = 64
RemoteSocketServiceError_SYS_ENOPKG RemoteSocketServiceError_SystemError = 65
RemoteSocketServiceError_SYS_EREMOTE RemoteSocketServiceError_SystemError = 66
RemoteSocketServiceError_SYS_ENOLINK RemoteSocketServiceError_SystemError = 67
RemoteSocketServiceError_SYS_EADV RemoteSocketServiceError_SystemError = 68
RemoteSocketServiceError_SYS_ESRMNT RemoteSocketServiceError_SystemError = 69
RemoteSocketServiceError_SYS_ECOMM RemoteSocketServiceError_SystemError = 70
RemoteSocketServiceError_SYS_EPROTO RemoteSocketServiceError_SystemError = 71
RemoteSocketServiceError_SYS_EMULTIHOP RemoteSocketServiceError_SystemError = 72
RemoteSocketServiceError_SYS_EDOTDOT RemoteSocketServiceError_SystemError = 73
RemoteSocketServiceError_SYS_EBADMSG RemoteSocketServiceError_SystemError = 74
RemoteSocketServiceError_SYS_EOVERFLOW RemoteSocketServiceError_SystemError = 75
RemoteSocketServiceError_SYS_ENOTUNIQ RemoteSocketServiceError_SystemError = 76
RemoteSocketServiceError_SYS_EBADFD RemoteSocketServiceError_SystemError = 77
RemoteSocketServiceError_SYS_EREMCHG RemoteSocketServiceError_SystemError = 78
RemoteSocketServiceError_SYS_ELIBACC RemoteSocketServiceError_SystemError = 79
RemoteSocketServiceError_SYS_ELIBBAD RemoteSocketServiceError_SystemError = 80
RemoteSocketServiceError_SYS_ELIBSCN RemoteSocketServiceError_SystemError = 81
RemoteSocketServiceError_SYS_ELIBMAX RemoteSocketServiceError_SystemError = 82
RemoteSocketServiceError_SYS_ELIBEXEC RemoteSocketServiceError_SystemError = 83
RemoteSocketServiceError_SYS_EILSEQ RemoteSocketServiceError_SystemError = 84
RemoteSocketServiceError_SYS_ERESTART RemoteSocketServiceError_SystemError = 85
RemoteSocketServiceError_SYS_ESTRPIPE RemoteSocketServiceError_SystemError = 86
RemoteSocketServiceError_SYS_EUSERS RemoteSocketServiceError_SystemError = 87
RemoteSocketServiceError_SYS_ENOTSOCK RemoteSocketServiceError_SystemError = 88
RemoteSocketServiceError_SYS_EDESTADDRREQ RemoteSocketServiceError_SystemError = 89
RemoteSocketServiceError_SYS_EMSGSIZE RemoteSocketServiceError_SystemError = 90
RemoteSocketServiceError_SYS_EPROTOTYPE RemoteSocketServiceError_SystemError = 91
RemoteSocketServiceError_SYS_ENOPROTOOPT RemoteSocketServiceError_SystemError = 92
RemoteSocketServiceError_SYS_EPROTONOSUPPORT RemoteSocketServiceError_SystemError = 93
RemoteSocketServiceError_SYS_ESOCKTNOSUPPORT RemoteSocketServiceError_SystemError = 94
RemoteSocketServiceError_SYS_EOPNOTSUPP RemoteSocketServiceError_SystemError = 95
RemoteSocketServiceError_SYS_ENOTSUP RemoteSocketServiceError_SystemError = 95
RemoteSocketServiceError_SYS_EPFNOSUPPORT RemoteSocketServiceError_SystemError = 96
RemoteSocketServiceError_SYS_EAFNOSUPPORT RemoteSocketServiceError_SystemError = 97
RemoteSocketServiceError_SYS_EADDRINUSE RemoteSocketServiceError_SystemError = 98
RemoteSocketServiceError_SYS_EADDRNOTAVAIL RemoteSocketServiceError_SystemError = 99
RemoteSocketServiceError_SYS_ENETDOWN RemoteSocketServiceError_SystemError = 100
RemoteSocketServiceError_SYS_ENETUNREACH RemoteSocketServiceError_SystemError = 101
RemoteSocketServiceError_SYS_ENETRESET RemoteSocketServiceError_SystemError = 102
RemoteSocketServiceError_SYS_ECONNABORTED RemoteSocketServiceError_SystemError = 103
RemoteSocketServiceError_SYS_ECONNRESET RemoteSocketServiceError_SystemError = 104
RemoteSocketServiceError_SYS_ENOBUFS RemoteSocketServiceError_SystemError = 105
RemoteSocketServiceError_SYS_EISCONN RemoteSocketServiceError_SystemError = 106
RemoteSocketServiceError_SYS_ENOTCONN RemoteSocketServiceError_SystemError = 107
RemoteSocketServiceError_SYS_ESHUTDOWN RemoteSocketServiceError_SystemError = 108
RemoteSocketServiceError_SYS_ETOOMANYREFS RemoteSocketServiceError_SystemError = 109
RemoteSocketServiceError_SYS_ETIMEDOUT RemoteSocketServiceError_SystemError = 110
RemoteSocketServiceError_SYS_ECONNREFUSED RemoteSocketServiceError_SystemError = 111
RemoteSocketServiceError_SYS_EHOSTDOWN RemoteSocketServiceError_SystemError = 112
RemoteSocketServiceError_SYS_EHOSTUNREACH RemoteSocketServiceError_SystemError = 113
RemoteSocketServiceError_SYS_EALREADY RemoteSocketServiceError_SystemError = 114
RemoteSocketServiceError_SYS_EINPROGRESS RemoteSocketServiceError_SystemError = 115
RemoteSocketServiceError_SYS_ESTALE RemoteSocketServiceError_SystemError = 116
RemoteSocketServiceError_SYS_EUCLEAN RemoteSocketServiceError_SystemError = 117
RemoteSocketServiceError_SYS_ENOTNAM RemoteSocketServiceError_SystemError = 118
RemoteSocketServiceError_SYS_ENAVAIL RemoteSocketServiceError_SystemError = 119
RemoteSocketServiceError_SYS_EISNAM RemoteSocketServiceError_SystemError = 120
RemoteSocketServiceError_SYS_EREMOTEIO RemoteSocketServiceError_SystemError = 121
RemoteSocketServiceError_SYS_EDQUOT RemoteSocketServiceError_SystemError = 122
RemoteSocketServiceError_SYS_ENOMEDIUM RemoteSocketServiceError_SystemError = 123
RemoteSocketServiceError_SYS_EMEDIUMTYPE RemoteSocketServiceError_SystemError = 124
RemoteSocketServiceError_SYS_ECANCELED RemoteSocketServiceError_SystemError = 125
RemoteSocketServiceError_SYS_ENOKEY RemoteSocketServiceError_SystemError = 126
RemoteSocketServiceError_SYS_EKEYEXPIRED RemoteSocketServiceError_SystemError = 127
RemoteSocketServiceError_SYS_EKEYREVOKED RemoteSocketServiceError_SystemError = 128
RemoteSocketServiceError_SYS_EKEYREJECTED RemoteSocketServiceError_SystemError = 129
RemoteSocketServiceError_SYS_EOWNERDEAD RemoteSocketServiceError_SystemError = 130
RemoteSocketServiceError_SYS_ENOTRECOVERABLE RemoteSocketServiceError_SystemError = 131
RemoteSocketServiceError_SYS_ERFKILL RemoteSocketServiceError_SystemError = 132
)
var RemoteSocketServiceError_SystemError_name = map[int32]string{
0: "SYS_SUCCESS",
1: "SYS_EPERM",
2: "SYS_ENOENT",
3: "SYS_ESRCH",
4: "SYS_EINTR",
5: "SYS_EIO",
6: "SYS_ENXIO",
7: "SYS_E2BIG",
8: "SYS_ENOEXEC",
9: "SYS_EBADF",
10: "SYS_ECHILD",
11: "SYS_EAGAIN",
// Duplicate value: 11: "SYS_EWOULDBLOCK",
12: "SYS_ENOMEM",
13: "SYS_EACCES",
14: "SYS_EFAULT",
15: "SYS_ENOTBLK",
16: "SYS_EBUSY",
17: "SYS_EEXIST",
18: "SYS_EXDEV",
19: "SYS_ENODEV",
20: "SYS_ENOTDIR",
21: "SYS_EISDIR",
22: "SYS_EINVAL",
23: "SYS_ENFILE",
24: "SYS_EMFILE",
25: "SYS_ENOTTY",
26: "SYS_ETXTBSY",
27: "SYS_EFBIG",
28: "SYS_ENOSPC",
29: "SYS_ESPIPE",
30: "SYS_EROFS",
31: "SYS_EMLINK",
32: "SYS_EPIPE",
33: "SYS_EDOM",
34: "SYS_ERANGE",
35: "SYS_EDEADLK",
// Duplicate value: 35: "SYS_EDEADLOCK",
36: "SYS_ENAMETOOLONG",
37: "SYS_ENOLCK",
38: "SYS_ENOSYS",
39: "SYS_ENOTEMPTY",
40: "SYS_ELOOP",
42: "SYS_ENOMSG",
43: "SYS_EIDRM",
44: "SYS_ECHRNG",
45: "SYS_EL2NSYNC",
46: "SYS_EL3HLT",
47: "SYS_EL3RST",
48: "SYS_ELNRNG",
49: "SYS_EUNATCH",
50: "SYS_ENOCSI",
51: "SYS_EL2HLT",
52: "SYS_EBADE",
53: "SYS_EBADR",
54: "SYS_EXFULL",
55: "SYS_ENOANO",
56: "SYS_EBADRQC",
57: "SYS_EBADSLT",
59: "SYS_EBFONT",
60: "SYS_ENOSTR",
61: "SYS_ENODATA",
62: "SYS_ETIME",
63: "SYS_ENOSR",
64: "SYS_ENONET",
65: "SYS_ENOPKG",
66: "SYS_EREMOTE",
67: "SYS_ENOLINK",
68: "SYS_EADV",
69: "SYS_ESRMNT",
70: "SYS_ECOMM",
71: "SYS_EPROTO",
72: "SYS_EMULTIHOP",
73: "SYS_EDOTDOT",
74: "SYS_EBADMSG",
75: "SYS_EOVERFLOW",
76: "SYS_ENOTUNIQ",
77: "SYS_EBADFD",
78: "SYS_EREMCHG",
79: "SYS_ELIBACC",
80: "SYS_ELIBBAD",
81: "SYS_ELIBSCN",
82: "SYS_ELIBMAX",
83: "SYS_ELIBEXEC",
84: "SYS_EILSEQ",
85: "SYS_ERESTART",
86: "SYS_ESTRPIPE",
87: "SYS_EUSERS",
88: "SYS_ENOTSOCK",
89: "SYS_EDESTADDRREQ",
90: "SYS_EMSGSIZE",
91: "SYS_EPROTOTYPE",
92: "SYS_ENOPROTOOPT",
93: "SYS_EPROTONOSUPPORT",
94: "SYS_ESOCKTNOSUPPORT",
95: "SYS_EOPNOTSUPP",
// Duplicate value: 95: "SYS_ENOTSUP",
96: "SYS_EPFNOSUPPORT",
97: "SYS_EAFNOSUPPORT",
98: "SYS_EADDRINUSE",
99: "SYS_EADDRNOTAVAIL",
100: "SYS_ENETDOWN",
101: "SYS_ENETUNREACH",
102: "SYS_ENETRESET",
103: "SYS_ECONNABORTED",
104: "SYS_ECONNRESET",
105: "SYS_ENOBUFS",
106: "SYS_EISCONN",
107: "SYS_ENOTCONN",
108: "SYS_ESHUTDOWN",
109: "SYS_ETOOMANYREFS",
110: "SYS_ETIMEDOUT",
111: "SYS_ECONNREFUSED",
112: "SYS_EHOSTDOWN",
113: "SYS_EHOSTUNREACH",
114: "SYS_EALREADY",
115: "SYS_EINPROGRESS",
116: "SYS_ESTALE",
117: "SYS_EUCLEAN",
118: "SYS_ENOTNAM",
119: "SYS_ENAVAIL",
120: "SYS_EISNAM",
121: "SYS_EREMOTEIO",
122: "SYS_EDQUOT",
123: "SYS_ENOMEDIUM",
124: "SYS_EMEDIUMTYPE",
125: "SYS_ECANCELED",
126: "SYS_ENOKEY",
127: "SYS_EKEYEXPIRED",
128: "SYS_EKEYREVOKED",
129: "SYS_EKEYREJECTED",
130: "SYS_EOWNERDEAD",
131: "SYS_ENOTRECOVERABLE",
132: "SYS_ERFKILL",
}
var RemoteSocketServiceError_SystemError_value = map[string]int32{
"SYS_SUCCESS": 0,
"SYS_EPERM": 1,
"SYS_ENOENT": 2,
"SYS_ESRCH": 3,
"SYS_EINTR": 4,
"SYS_EIO": 5,
"SYS_ENXIO": 6,
"SYS_E2BIG": 7,
"SYS_ENOEXEC": 8,
"SYS_EBADF": 9,
"SYS_ECHILD": 10,
"SYS_EAGAIN": 11,
"SYS_EWOULDBLOCK": 11,
"SYS_ENOMEM": 12,
"SYS_EACCES": 13,
"SYS_EFAULT": 14,
"SYS_ENOTBLK": 15,
"SYS_EBUSY": 16,
"SYS_EEXIST": 17,
"SYS_EXDEV": 18,
"SYS_ENODEV": 19,
"SYS_ENOTDIR": 20,
"SYS_EISDIR": 21,
"SYS_EINVAL": 22,
"SYS_ENFILE": 23,
"SYS_EMFILE": 24,
"SYS_ENOTTY": 25,
"SYS_ETXTBSY": 26,
"SYS_EFBIG": 27,
"SYS_ENOSPC": 28,
"SYS_ESPIPE": 29,
"SYS_EROFS": 30,
"SYS_EMLINK": 31,
"SYS_EPIPE": 32,
"SYS_EDOM": 33,
"SYS_ERANGE": 34,
"SYS_EDEADLK": 35,
"SYS_EDEADLOCK": 35,
"SYS_ENAMETOOLONG": 36,
"SYS_ENOLCK": 37,
"SYS_ENOSYS": 38,
"SYS_ENOTEMPTY": 39,
"SYS_ELOOP": 40,
"SYS_ENOMSG": 42,
"SYS_EIDRM": 43,
"SYS_ECHRNG": 44,
"SYS_EL2NSYNC": 45,
"SYS_EL3HLT": 46,
"SYS_EL3RST": 47,
"SYS_ELNRNG": 48,
"SYS_EUNATCH": 49,
"SYS_ENOCSI": 50,
"SYS_EL2HLT": 51,
"SYS_EBADE": 52,
"SYS_EBADR": 53,
"SYS_EXFULL": 54,
"SYS_ENOANO": 55,
"SYS_EBADRQC": 56,
"SYS_EBADSLT": 57,
"SYS_EBFONT": 59,
"SYS_ENOSTR": 60,
"SYS_ENODATA": 61,
"SYS_ETIME": 62,
"SYS_ENOSR": 63,
"SYS_ENONET": 64,
"SYS_ENOPKG": 65,
"SYS_EREMOTE": 66,
"SYS_ENOLINK": 67,
"SYS_EADV": 68,
"SYS_ESRMNT": 69,
"SYS_ECOMM": 70,
"SYS_EPROTO": 71,
"SYS_EMULTIHOP": 72,
"SYS_EDOTDOT": 73,
"SYS_EBADMSG": 74,
"SYS_EOVERFLOW": 75,
"SYS_ENOTUNIQ": 76,
"SYS_EBADFD": 77,
"SYS_EREMCHG": 78,
"SYS_ELIBACC": 79,
"SYS_ELIBBAD": 80,
"SYS_ELIBSCN": 81,
"SYS_ELIBMAX": 82,
"SYS_ELIBEXEC": 83,
"SYS_EILSEQ": 84,
"SYS_ERESTART": 85,
"SYS_ESTRPIPE": 86,
"SYS_EUSERS": 87,
"SYS_ENOTSOCK": 88,
"SYS_EDESTADDRREQ": 89,
"SYS_EMSGSIZE": 90,
"SYS_EPROTOTYPE": 91,
"SYS_ENOPROTOOPT": 92,
"SYS_EPROTONOSUPPORT": 93,
"SYS_ESOCKTNOSUPPORT": 94,
"SYS_EOPNOTSUPP": 95,
"SYS_ENOTSUP": 95,
"SYS_EPFNOSUPPORT": 96,
"SYS_EAFNOSUPPORT": 97,
"SYS_EADDRINUSE": 98,
"SYS_EADDRNOTAVAIL": 99,
"SYS_ENETDOWN": 100,
"SYS_ENETUNREACH": 101,
"SYS_ENETRESET": 102,
"SYS_ECONNABORTED": 103,
"SYS_ECONNRESET": 104,
"SYS_ENOBUFS": 105,
"SYS_EISCONN": 106,
"SYS_ENOTCONN": 107,
"SYS_ESHUTDOWN": 108,
"SYS_ETOOMANYREFS": 109,
"SYS_ETIMEDOUT": 110,
"SYS_ECONNREFUSED": 111,
"SYS_EHOSTDOWN": 112,
"SYS_EHOSTUNREACH": 113,
"SYS_EALREADY": 114,
"SYS_EINPROGRESS": 115,
"SYS_ESTALE": 116,
"SYS_EUCLEAN": 117,
"SYS_ENOTNAM": 118,
"SYS_ENAVAIL": 119,
"SYS_EISNAM": 120,
"SYS_EREMOTEIO": 121,
"SYS_EDQUOT": 122,
"SYS_ENOMEDIUM": 123,
"SYS_EMEDIUMTYPE": 124,
"SYS_ECANCELED": 125,
"SYS_ENOKEY": 126,
"SYS_EKEYEXPIRED": 127,
"SYS_EKEYREVOKED": 128,
"SYS_EKEYREJECTED": 129,
"SYS_EOWNERDEAD": 130,
"SYS_ENOTRECOVERABLE": 131,
"SYS_ERFKILL": 132,
}
func (x RemoteSocketServiceError_SystemError) Enum() *RemoteSocketServiceError_SystemError {
p := new(RemoteSocketServiceError_SystemError)
*p = x
return p
}
func (x RemoteSocketServiceError_SystemError) String() string {
return proto.EnumName(RemoteSocketServiceError_SystemError_name, int32(x))
}
func (x *RemoteSocketServiceError_SystemError) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(RemoteSocketServiceError_SystemError_value, data, "RemoteSocketServiceError_SystemError")
if err != nil {
return err
}
*x = RemoteSocketServiceError_SystemError(value)
return nil
}
type CreateSocketRequest_SocketFamily int32
const (
CreateSocketRequest_IPv4 CreateSocketRequest_SocketFamily = 1
CreateSocketRequest_IPv6 CreateSocketRequest_SocketFamily = 2
)
var CreateSocketRequest_SocketFamily_name = map[int32]string{
1: "IPv4",
2: "IPv6",
}
var CreateSocketRequest_SocketFamily_value = map[string]int32{
"IPv4": 1,
"IPv6": 2,
}
func (x CreateSocketRequest_SocketFamily) Enum() *CreateSocketRequest_SocketFamily {
p := new(CreateSocketRequest_SocketFamily)
*p = x
return p
}
func (x CreateSocketRequest_SocketFamily) String() string {
return proto.EnumName(CreateSocketRequest_SocketFamily_name, int32(x))
}
func (x *CreateSocketRequest_SocketFamily) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(CreateSocketRequest_SocketFamily_value, data, "CreateSocketRequest_SocketFamily")
if err != nil {
return err
}
*x = CreateSocketRequest_SocketFamily(value)
return nil
}
type CreateSocketRequest_SocketProtocol int32
const (
CreateSocketRequest_TCP CreateSocketRequest_SocketProtocol = 1
CreateSocketRequest_UDP CreateSocketRequest_SocketProtocol = 2
)
var CreateSocketRequest_SocketProtocol_name = map[int32]string{
1: "TCP",
2: "UDP",
}
var CreateSocketRequest_SocketProtocol_value = map[string]int32{
"TCP": 1,
"UDP": 2,
}
func (x CreateSocketRequest_SocketProtocol) Enum() *CreateSocketRequest_SocketProtocol {
p := new(CreateSocketRequest_SocketProtocol)
*p = x
return p
}
func (x CreateSocketRequest_SocketProtocol) String() string {
return proto.EnumName(CreateSocketRequest_SocketProtocol_name, int32(x))
}
func (x *CreateSocketRequest_SocketProtocol) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(CreateSocketRequest_SocketProtocol_value, data, "CreateSocketRequest_SocketProtocol")
if err != nil {
return err
}
*x = CreateSocketRequest_SocketProtocol(value)
return nil
}
type SocketOption_SocketOptionLevel int32
const (
SocketOption_SOCKET_SOL_IP SocketOption_SocketOptionLevel = 0
SocketOption_SOCKET_SOL_SOCKET SocketOption_SocketOptionLevel = 1
SocketOption_SOCKET_SOL_TCP SocketOption_SocketOptionLevel = 6
SocketOption_SOCKET_SOL_UDP SocketOption_SocketOptionLevel = 17
)
var SocketOption_SocketOptionLevel_name = map[int32]string{
0: "SOCKET_SOL_IP",
1: "SOCKET_SOL_SOCKET",
6: "SOCKET_SOL_TCP",
17: "SOCKET_SOL_UDP",
}
var SocketOption_SocketOptionLevel_value = map[string]int32{
"SOCKET_SOL_IP": 0,
"SOCKET_SOL_SOCKET": 1,
"SOCKET_SOL_TCP": 6,
"SOCKET_SOL_UDP": 17,
}
func (x SocketOption_SocketOptionLevel) Enum() *SocketOption_SocketOptionLevel {
p := new(SocketOption_SocketOptionLevel)
*p = x
return p
}
func (x SocketOption_SocketOptionLevel) String() string {
return proto.EnumName(SocketOption_SocketOptionLevel_name, int32(x))
}
func (x *SocketOption_SocketOptionLevel) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(SocketOption_SocketOptionLevel_value, data, "SocketOption_SocketOptionLevel")
if err != nil {
return err
}
*x = SocketOption_SocketOptionLevel(value)
return nil
}
type SocketOption_SocketOptionName int32
const (
SocketOption_SOCKET_SO_DEBUG SocketOption_SocketOptionName = 1
SocketOption_SOCKET_SO_REUSEADDR SocketOption_SocketOptionName = 2
SocketOption_SOCKET_SO_TYPE SocketOption_SocketOptionName = 3
SocketOption_SOCKET_SO_ERROR SocketOption_SocketOptionName = 4
SocketOption_SOCKET_SO_DONTROUTE SocketOption_SocketOptionName = 5
SocketOption_SOCKET_SO_BROADCAST SocketOption_SocketOptionName = 6
SocketOption_SOCKET_SO_SNDBUF SocketOption_SocketOptionName = 7
SocketOption_SOCKET_SO_RCVBUF SocketOption_SocketOptionName = 8
SocketOption_SOCKET_SO_KEEPALIVE SocketOption_SocketOptionName = 9
SocketOption_SOCKET_SO_OOBINLINE SocketOption_SocketOptionName = 10
SocketOption_SOCKET_SO_LINGER SocketOption_SocketOptionName = 13
SocketOption_SOCKET_SO_RCVTIMEO SocketOption_SocketOptionName = 20
SocketOption_SOCKET_SO_SNDTIMEO SocketOption_SocketOptionName = 21
SocketOption_SOCKET_IP_TOS SocketOption_SocketOptionName = 1
SocketOption_SOCKET_IP_TTL SocketOption_SocketOptionName = 2
SocketOption_SOCKET_IP_HDRINCL SocketOption_SocketOptionName = 3
SocketOption_SOCKET_IP_OPTIONS SocketOption_SocketOptionName = 4
SocketOption_SOCKET_TCP_NODELAY SocketOption_SocketOptionName = 1
SocketOption_SOCKET_TCP_MAXSEG SocketOption_SocketOptionName = 2
SocketOption_SOCKET_TCP_CORK SocketOption_SocketOptionName = 3
SocketOption_SOCKET_TCP_KEEPIDLE SocketOption_SocketOptionName = 4
SocketOption_SOCKET_TCP_KEEPINTVL SocketOption_SocketOptionName = 5
SocketOption_SOCKET_TCP_KEEPCNT SocketOption_SocketOptionName = 6
SocketOption_SOCKET_TCP_SYNCNT SocketOption_SocketOptionName = 7
SocketOption_SOCKET_TCP_LINGER2 SocketOption_SocketOptionName = 8
SocketOption_SOCKET_TCP_DEFER_ACCEPT SocketOption_SocketOptionName = 9
SocketOption_SOCKET_TCP_WINDOW_CLAMP SocketOption_SocketOptionName = 10
SocketOption_SOCKET_TCP_INFO SocketOption_SocketOptionName = 11
SocketOption_SOCKET_TCP_QUICKACK SocketOption_SocketOptionName = 12
)
var SocketOption_SocketOptionName_name = map[int32]string{
1: "SOCKET_SO_DEBUG",
2: "SOCKET_SO_REUSEADDR",
3: "SOCKET_SO_TYPE",
4: "SOCKET_SO_ERROR",
5: "SOCKET_SO_DONTROUTE",
6: "SOCKET_SO_BROADCAST",
7: "SOCKET_SO_SNDBUF",
8: "SOCKET_SO_RCVBUF",
9: "SOCKET_SO_KEEPALIVE",
10: "SOCKET_SO_OOBINLINE",
13: "SOCKET_SO_LINGER",
20: "SOCKET_SO_RCVTIMEO",
21: "SOCKET_SO_SNDTIMEO",
// Duplicate value: 1: "SOCKET_IP_TOS",
// Duplicate value: 2: "SOCKET_IP_TTL",
// Duplicate value: 3: "SOCKET_IP_HDRINCL",
// Duplicate value: 4: "SOCKET_IP_OPTIONS",
// Duplicate value: 1: "SOCKET_TCP_NODELAY",
// Duplicate value: 2: "SOCKET_TCP_MAXSEG",
// Duplicate value: 3: "SOCKET_TCP_CORK",
// Duplicate value: 4: "SOCKET_TCP_KEEPIDLE",
// Duplicate value: 5: "SOCKET_TCP_KEEPINTVL",
// Duplicate value: 6: "SOCKET_TCP_KEEPCNT",
// Duplicate value: 7: "SOCKET_TCP_SYNCNT",
// Duplicate value: 8: "SOCKET_TCP_LINGER2",
// Duplicate value: 9: "SOCKET_TCP_DEFER_ACCEPT",
// Duplicate value: 10: "SOCKET_TCP_WINDOW_CLAMP",
11: "SOCKET_TCP_INFO",
12: "SOCKET_TCP_QUICKACK",
}
var SocketOption_SocketOptionName_value = map[string]int32{
"SOCKET_SO_DEBUG": 1,
"SOCKET_SO_REUSEADDR": 2,
"SOCKET_SO_TYPE": 3,
"SOCKET_SO_ERROR": 4,
"SOCKET_SO_DONTROUTE": 5,
"SOCKET_SO_BROADCAST": 6,
"SOCKET_SO_SNDBUF": 7,
"SOCKET_SO_RCVBUF": 8,
"SOCKET_SO_KEEPALIVE": 9,
"SOCKET_SO_OOBINLINE": 10,
"SOCKET_SO_LINGER": 13,
"SOCKET_SO_RCVTIMEO": 20,
"SOCKET_SO_SNDTIMEO": 21,
"SOCKET_IP_TOS": 1,
"SOCKET_IP_TTL": 2,
"SOCKET_IP_HDRINCL": 3,
"SOCKET_IP_OPTIONS": 4,
"SOCKET_TCP_NODELAY": 1,
"SOCKET_TCP_MAXSEG": 2,
"SOCKET_TCP_CORK": 3,
"SOCKET_TCP_KEEPIDLE": 4,
"SOCKET_TCP_KEEPINTVL": 5,
"SOCKET_TCP_KEEPCNT": 6,
"SOCKET_TCP_SYNCNT": 7,
"SOCKET_TCP_LINGER2": 8,
"SOCKET_TCP_DEFER_ACCEPT": 9,
"SOCKET_TCP_WINDOW_CLAMP": 10,
"SOCKET_TCP_INFO": 11,
"SOCKET_TCP_QUICKACK": 12,
}
func (x SocketOption_SocketOptionName) Enum() *SocketOption_SocketOptionName {
p := new(SocketOption_SocketOptionName)
*p = x
return p
}
func (x SocketOption_SocketOptionName) String() string {
return proto.EnumName(SocketOption_SocketOptionName_name, int32(x))
}
func (x *SocketOption_SocketOptionName) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(SocketOption_SocketOptionName_value, data, "SocketOption_SocketOptionName")
if err != nil {
return err
}
*x = SocketOption_SocketOptionName(value)
return nil
}
type ShutDownRequest_How int32
const (
ShutDownRequest_SOCKET_SHUT_RD ShutDownRequest_How = 1
ShutDownRequest_SOCKET_SHUT_WR ShutDownRequest_How = 2
ShutDownRequest_SOCKET_SHUT_RDWR ShutDownRequest_How = 3
)
var ShutDownRequest_How_name = map[int32]string{
1: "SOCKET_SHUT_RD",
2: "SOCKET_SHUT_WR",
3: "SOCKET_SHUT_RDWR",
}
var ShutDownRequest_How_value = map[string]int32{
"SOCKET_SHUT_RD": 1,
"SOCKET_SHUT_WR": 2,
"SOCKET_SHUT_RDWR": 3,
}
func (x ShutDownRequest_How) Enum() *ShutDownRequest_How {
p := new(ShutDownRequest_How)
*p = x
return p
}
func (x ShutDownRequest_How) String() string {
return proto.EnumName(ShutDownRequest_How_name, int32(x))
}
func (x *ShutDownRequest_How) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(ShutDownRequest_How_value, data, "ShutDownRequest_How")
if err != nil {
return err
}
*x = ShutDownRequest_How(value)
return nil
}
type ReceiveRequest_Flags int32
const (
ReceiveRequest_MSG_OOB ReceiveRequest_Flags = 1
ReceiveRequest_MSG_PEEK ReceiveRequest_Flags = 2
)
var ReceiveRequest_Flags_name = map[int32]string{
1: "MSG_OOB",
2: "MSG_PEEK",
}
var ReceiveRequest_Flags_value = map[string]int32{
"MSG_OOB": 1,
"MSG_PEEK": 2,
}
func (x ReceiveRequest_Flags) Enum() *ReceiveRequest_Flags {
p := new(ReceiveRequest_Flags)
*p = x
return p
}
func (x ReceiveRequest_Flags) String() string {
return proto.EnumName(ReceiveRequest_Flags_name, int32(x))
}
func (x *ReceiveRequest_Flags) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(ReceiveRequest_Flags_value, data, "ReceiveRequest_Flags")
if err != nil {
return err
}
*x = ReceiveRequest_Flags(value)
return nil
}
type PollEvent_PollEventFlag int32
const (
PollEvent_SOCKET_POLLNONE PollEvent_PollEventFlag = 0
PollEvent_SOCKET_POLLIN PollEvent_PollEventFlag = 1
PollEvent_SOCKET_POLLPRI PollEvent_PollEventFlag = 2
PollEvent_SOCKET_POLLOUT PollEvent_PollEventFlag = 4
PollEvent_SOCKET_POLLERR PollEvent_PollEventFlag = 8
PollEvent_SOCKET_POLLHUP PollEvent_PollEventFlag = 16
PollEvent_SOCKET_POLLNVAL PollEvent_PollEventFlag = 32
PollEvent_SOCKET_POLLRDNORM PollEvent_PollEventFlag = 64
PollEvent_SOCKET_POLLRDBAND PollEvent_PollEventFlag = 128
PollEvent_SOCKET_POLLWRNORM PollEvent_PollEventFlag = 256
PollEvent_SOCKET_POLLWRBAND PollEvent_PollEventFlag = 512
PollEvent_SOCKET_POLLMSG PollEvent_PollEventFlag = 1024
PollEvent_SOCKET_POLLREMOVE PollEvent_PollEventFlag = 4096
PollEvent_SOCKET_POLLRDHUP PollEvent_PollEventFlag = 8192
)
var PollEvent_PollEventFlag_name = map[int32]string{
0: "SOCKET_POLLNONE",
1: "SOCKET_POLLIN",
2: "SOCKET_POLLPRI",
4: "SOCKET_POLLOUT",
8: "SOCKET_POLLERR",
16: "SOCKET_POLLHUP",
32: "SOCKET_POLLNVAL",
64: "SOCKET_POLLRDNORM",
128: "SOCKET_POLLRDBAND",
256: "SOCKET_POLLWRNORM",
512: "SOCKET_POLLWRBAND",
1024: "SOCKET_POLLMSG",
4096: "SOCKET_POLLREMOVE",
8192: "SOCKET_POLLRDHUP",
}
var PollEvent_PollEventFlag_value = map[string]int32{
"SOCKET_POLLNONE": 0,
"SOCKET_POLLIN": 1,
"SOCKET_POLLPRI": 2,
"SOCKET_POLLOUT": 4,
"SOCKET_POLLERR": 8,
"SOCKET_POLLHUP": 16,
"SOCKET_POLLNVAL": 32,
"SOCKET_POLLRDNORM": 64,
"SOCKET_POLLRDBAND": 128,
"SOCKET_POLLWRNORM": 256,
"SOCKET_POLLWRBAND": 512,
"SOCKET_POLLMSG": 1024,
"SOCKET_POLLREMOVE": 4096,
"SOCKET_POLLRDHUP": 8192,
}
func (x PollEvent_PollEventFlag) Enum() *PollEvent_PollEventFlag {
p := new(PollEvent_PollEventFlag)
*p = x
return p
}
func (x PollEvent_PollEventFlag) String() string {
return proto.EnumName(PollEvent_PollEventFlag_name, int32(x))
}
func (x *PollEvent_PollEventFlag) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(PollEvent_PollEventFlag_value, data, "PollEvent_PollEventFlag")
if err != nil {
return err
}
*x = PollEvent_PollEventFlag(value)
return nil
}
type ResolveReply_ErrorCode int32
const (
ResolveReply_SOCKET_EAI_ADDRFAMILY ResolveReply_ErrorCode = 1
ResolveReply_SOCKET_EAI_AGAIN ResolveReply_ErrorCode = 2
ResolveReply_SOCKET_EAI_BADFLAGS ResolveReply_ErrorCode = 3
ResolveReply_SOCKET_EAI_FAIL ResolveReply_ErrorCode = 4
ResolveReply_SOCKET_EAI_FAMILY ResolveReply_ErrorCode = 5
ResolveReply_SOCKET_EAI_MEMORY ResolveReply_ErrorCode = 6
ResolveReply_SOCKET_EAI_NODATA ResolveReply_ErrorCode = 7
ResolveReply_SOCKET_EAI_NONAME ResolveReply_ErrorCode = 8
ResolveReply_SOCKET_EAI_SERVICE ResolveReply_ErrorCode = 9
ResolveReply_SOCKET_EAI_SOCKTYPE ResolveReply_ErrorCode = 10
ResolveReply_SOCKET_EAI_SYSTEM ResolveReply_ErrorCode = 11
ResolveReply_SOCKET_EAI_BADHINTS ResolveReply_ErrorCode = 12
ResolveReply_SOCKET_EAI_PROTOCOL ResolveReply_ErrorCode = 13
ResolveReply_SOCKET_EAI_OVERFLOW ResolveReply_ErrorCode = 14
ResolveReply_SOCKET_EAI_MAX ResolveReply_ErrorCode = 15
)
var ResolveReply_ErrorCode_name = map[int32]string{
1: "SOCKET_EAI_ADDRFAMILY",
2: "SOCKET_EAI_AGAIN",
3: "SOCKET_EAI_BADFLAGS",
4: "SOCKET_EAI_FAIL",
5: "SOCKET_EAI_FAMILY",
6: "SOCKET_EAI_MEMORY",
7: "SOCKET_EAI_NODATA",
8: "SOCKET_EAI_NONAME",
9: "SOCKET_EAI_SERVICE",
10: "SOCKET_EAI_SOCKTYPE",
11: "SOCKET_EAI_SYSTEM",
12: "SOCKET_EAI_BADHINTS",
13: "SOCKET_EAI_PROTOCOL",
14: "SOCKET_EAI_OVERFLOW",
15: "SOCKET_EAI_MAX",
}
var ResolveReply_ErrorCode_value = map[string]int32{
"SOCKET_EAI_ADDRFAMILY": 1,
"SOCKET_EAI_AGAIN": 2,
"SOCKET_EAI_BADFLAGS": 3,
"SOCKET_EAI_FAIL": 4,
"SOCKET_EAI_FAMILY": 5,
"SOCKET_EAI_MEMORY": 6,
"SOCKET_EAI_NODATA": 7,
"SOCKET_EAI_NONAME": 8,
"SOCKET_EAI_SERVICE": 9,
"SOCKET_EAI_SOCKTYPE": 10,
"SOCKET_EAI_SYSTEM": 11,
"SOCKET_EAI_BADHINTS": 12,
"SOCKET_EAI_PROTOCOL": 13,
"SOCKET_EAI_OVERFLOW": 14,
"SOCKET_EAI_MAX": 15,
}
func (x ResolveReply_ErrorCode) Enum() *ResolveReply_ErrorCode {
p := new(ResolveReply_ErrorCode)
*p = x
return p
}
func (x ResolveReply_ErrorCode) String() string {
return proto.EnumName(ResolveReply_ErrorCode_name, int32(x))
}
func (x *ResolveReply_ErrorCode) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(ResolveReply_ErrorCode_value, data, "ResolveReply_ErrorCode")
if err != nil {
return err
}
*x = ResolveReply_ErrorCode(value)
return nil
}
type RemoteSocketServiceError struct {
SystemError *int32 `protobuf:"varint,1,opt,name=system_error,def=0" json:"system_error,omitempty"`
ErrorDetail *string `protobuf:"bytes,2,opt,name=error_detail" json:"error_detail,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *RemoteSocketServiceError) Reset() { *m = RemoteSocketServiceError{} }
func (m *RemoteSocketServiceError) String() string { return proto.CompactTextString(m) }
func (*RemoteSocketServiceError) ProtoMessage() {}
const Default_RemoteSocketServiceError_SystemError int32 = 0
func (m *RemoteSocketServiceError) GetSystemError() int32 {
if m != nil && m.SystemError != nil {
return *m.SystemError
}
return Default_RemoteSocketServiceError_SystemError
}
func (m *RemoteSocketServiceError) GetErrorDetail() string {
if m != nil && m.ErrorDetail != nil {
return *m.ErrorDetail
}
return ""
}
type AddressPort struct {
Port *int32 `protobuf:"varint,1,req,name=port" json:"port,omitempty"`
PackedAddress []byte `protobuf:"bytes,2,opt,name=packed_address" json:"packed_address,omitempty"`
HostnameHint *string `protobuf:"bytes,3,opt,name=hostname_hint" json:"hostname_hint,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *AddressPort) Reset() { *m = AddressPort{} }
func (m *AddressPort) String() string { return proto.CompactTextString(m) }
func (*AddressPort) ProtoMessage() {}
func (m *AddressPort) GetPort() int32 {
if m != nil && m.Port != nil {
return *m.Port
}
return 0
}
func (m *AddressPort) GetPackedAddress() []byte {
if m != nil {
return m.PackedAddress
}
return nil
}
func (m *AddressPort) GetHostnameHint() string {
if m != nil && m.HostnameHint != nil {
return *m.HostnameHint
}
return ""
}
type CreateSocketRequest struct {
Family *CreateSocketRequest_SocketFamily `protobuf:"varint,1,req,name=family,enum=appengine.CreateSocketRequest_SocketFamily" json:"family,omitempty"`
Protocol *CreateSocketRequest_SocketProtocol `protobuf:"varint,2,req,name=protocol,enum=appengine.CreateSocketRequest_SocketProtocol" json:"protocol,omitempty"`
SocketOptions []*SocketOption `protobuf:"bytes,3,rep,name=socket_options" json:"socket_options,omitempty"`
ProxyExternalIp *AddressPort `protobuf:"bytes,4,opt,name=proxy_external_ip" json:"proxy_external_ip,omitempty"`
ListenBacklog *int32 `protobuf:"varint,5,opt,name=listen_backlog,def=0" json:"listen_backlog,omitempty"`
RemoteIp *AddressPort `protobuf:"bytes,6,opt,name=remote_ip" json:"remote_ip,omitempty"`
AppId *string `protobuf:"bytes,9,opt,name=app_id" json:"app_id,omitempty"`
ProjectId *int64 `protobuf:"varint,10,opt,name=project_id" json:"project_id,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CreateSocketRequest) Reset() { *m = CreateSocketRequest{} }
func (m *CreateSocketRequest) String() string { return proto.CompactTextString(m) }
func (*CreateSocketRequest) ProtoMessage() {}
const Default_CreateSocketRequest_ListenBacklog int32 = 0
func (m *CreateSocketRequest) GetFamily() CreateSocketRequest_SocketFamily {
if m != nil && m.Family != nil {
return *m.Family
}
return CreateSocketRequest_IPv4
}
func (m *CreateSocketRequest) GetProtocol() CreateSocketRequest_SocketProtocol {
if m != nil && m.Protocol != nil {
return *m.Protocol
}
return CreateSocketRequest_TCP
}
func (m *CreateSocketRequest) GetSocketOptions() []*SocketOption {
if m != nil {
return m.SocketOptions
}
return nil
}
func (m *CreateSocketRequest) GetProxyExternalIp() *AddressPort {
if m != nil {
return m.ProxyExternalIp
}
return nil
}
func (m *CreateSocketRequest) GetListenBacklog() int32 {
if m != nil && m.ListenBacklog != nil {
return *m.ListenBacklog
}
return Default_CreateSocketRequest_ListenBacklog
}
func (m *CreateSocketRequest) GetRemoteIp() *AddressPort {
if m != nil {
return m.RemoteIp
}
return nil
}
func (m *CreateSocketRequest) GetAppId() string {
if m != nil && m.AppId != nil {
return *m.AppId
}
return ""
}
func (m *CreateSocketRequest) GetProjectId() int64 {
if m != nil && m.ProjectId != nil {
return *m.ProjectId
}
return 0
}
type CreateSocketReply struct {
SocketDescriptor *string `protobuf:"bytes,1,opt,name=socket_descriptor" json:"socket_descriptor,omitempty"`
ServerAddress *AddressPort `protobuf:"bytes,3,opt,name=server_address" json:"server_address,omitempty"`
ProxyExternalIp *AddressPort `protobuf:"bytes,4,opt,name=proxy_external_ip" json:"proxy_external_ip,omitempty"`
XXX_extensions map[int32]proto.Extension `json:"-"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CreateSocketReply) Reset() { *m = CreateSocketReply{} }
func (m *CreateSocketReply) String() string { return proto.CompactTextString(m) }
func (*CreateSocketReply) ProtoMessage() {}
var extRange_CreateSocketReply = []proto.ExtensionRange{
{1000, 536870911},
}
func (*CreateSocketReply) ExtensionRangeArray() []proto.ExtensionRange {
return extRange_CreateSocketReply
}
func (m *CreateSocketReply) ExtensionMap() map[int32]proto.Extension {
if m.XXX_extensions == nil {
m.XXX_extensions = make(map[int32]proto.Extension)
}
return m.XXX_extensions
}
func (m *CreateSocketReply) GetSocketDescriptor() string {
if m != nil && m.SocketDescriptor != nil {
return *m.SocketDescriptor
}
return ""
}
func (m *CreateSocketReply) GetServerAddress() *AddressPort {
if m != nil {
return m.ServerAddress
}
return nil
}
func (m *CreateSocketReply) GetProxyExternalIp() *AddressPort {
if m != nil {
return m.ProxyExternalIp
}
return nil
}
type BindRequest struct {
SocketDescriptor *string `protobuf:"bytes,1,req,name=socket_descriptor" json:"socket_descriptor,omitempty"`
ProxyExternalIp *AddressPort `protobuf:"bytes,2,req,name=proxy_external_ip" json:"proxy_external_ip,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *BindRequest) Reset() { *m = BindRequest{} }
func (m *BindRequest) String() string { return proto.CompactTextString(m) }
func (*BindRequest) ProtoMessage() {}
func (m *BindRequest) GetSocketDescriptor() string {
if m != nil && m.SocketDescriptor != nil {
return *m.SocketDescriptor
}
return ""
}
func (m *BindRequest) GetProxyExternalIp() *AddressPort {
if m != nil {
return m.ProxyExternalIp
}
return nil
}
type BindReply struct {
ProxyExternalIp *AddressPort `protobuf:"bytes,1,opt,name=proxy_external_ip" json:"proxy_external_ip,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *BindReply) Reset() { *m = BindReply{} }
func (m *BindReply) String() string { return proto.CompactTextString(m) }
func (*BindReply) ProtoMessage() {}
func (m *BindReply) GetProxyExternalIp() *AddressPort {
if m != nil {
return m.ProxyExternalIp
}
return nil
}
type GetSocketNameRequest struct {
SocketDescriptor *string `protobuf:"bytes,1,req,name=socket_descriptor" json:"socket_descriptor,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetSocketNameRequest) Reset() { *m = GetSocketNameRequest{} }
func (m *GetSocketNameRequest) String() string { return proto.CompactTextString(m) }
func (*GetSocketNameRequest) ProtoMessage() {}
func (m *GetSocketNameRequest) GetSocketDescriptor() string {
if m != nil && m.SocketDescriptor != nil {
return *m.SocketDescriptor
}
return ""
}
type GetSocketNameReply struct {
ProxyExternalIp *AddressPort `protobuf:"bytes,2,opt,name=proxy_external_ip" json:"proxy_external_ip,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetSocketNameReply) Reset() { *m = GetSocketNameReply{} }
func (m *GetSocketNameReply) String() string { return proto.CompactTextString(m) }
func (*GetSocketNameReply) ProtoMessage() {}
func (m *GetSocketNameReply) GetProxyExternalIp() *AddressPort {
if m != nil {
return m.ProxyExternalIp
}
return nil
}
type GetPeerNameRequest struct {
SocketDescriptor *string `protobuf:"bytes,1,req,name=socket_descriptor" json:"socket_descriptor,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetPeerNameRequest) Reset() { *m = GetPeerNameRequest{} }
func (m *GetPeerNameRequest) String() string { return proto.CompactTextString(m) }
func (*GetPeerNameRequest) ProtoMessage() {}
func (m *GetPeerNameRequest) GetSocketDescriptor() string {
if m != nil && m.SocketDescriptor != nil {
return *m.SocketDescriptor
}
return ""
}
type GetPeerNameReply struct {
PeerIp *AddressPort `protobuf:"bytes,2,opt,name=peer_ip" json:"peer_ip,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetPeerNameReply) Reset() { *m = GetPeerNameReply{} }
func (m *GetPeerNameReply) String() string { return proto.CompactTextString(m) }
func (*GetPeerNameReply) ProtoMessage() {}
func (m *GetPeerNameReply) GetPeerIp() *AddressPort {
if m != nil {
return m.PeerIp
}
return nil
}
type SocketOption struct {
Level *SocketOption_SocketOptionLevel `protobuf:"varint,1,req,name=level,enum=appengine.SocketOption_SocketOptionLevel" json:"level,omitempty"`
Option *SocketOption_SocketOptionName `protobuf:"varint,2,req,name=option,enum=appengine.SocketOption_SocketOptionName" json:"option,omitempty"`
Value []byte `protobuf:"bytes,3,req,name=value" json:"value,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *SocketOption) Reset() { *m = SocketOption{} }
func (m *SocketOption) String() string { return proto.CompactTextString(m) }
func (*SocketOption) ProtoMessage() {}
func (m *SocketOption) GetLevel() SocketOption_SocketOptionLevel {
if m != nil && m.Level != nil {
return *m.Level
}
return SocketOption_SOCKET_SOL_IP
}
func (m *SocketOption) GetOption() SocketOption_SocketOptionName {
if m != nil && m.Option != nil {
return *m.Option
}
return SocketOption_SOCKET_SO_DEBUG
}
func (m *SocketOption) GetValue() []byte {
if m != nil {
return m.Value
}
return nil
}
type SetSocketOptionsRequest struct {
SocketDescriptor *string `protobuf:"bytes,1,req,name=socket_descriptor" json:"socket_descriptor,omitempty"`
Options []*SocketOption `protobuf:"bytes,2,rep,name=options" json:"options,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *SetSocketOptionsRequest) Reset() { *m = SetSocketOptionsRequest{} }
func (m *SetSocketOptionsRequest) String() string { return proto.CompactTextString(m) }
func (*SetSocketOptionsRequest) ProtoMessage() {}
func (m *SetSocketOptionsRequest) GetSocketDescriptor() string {
if m != nil && m.SocketDescriptor != nil {
return *m.SocketDescriptor
}
return ""
}
func (m *SetSocketOptionsRequest) GetOptions() []*SocketOption {
if m != nil {
return m.Options
}
return nil
}
type SetSocketOptionsReply struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *SetSocketOptionsReply) Reset() { *m = SetSocketOptionsReply{} }
func (m *SetSocketOptionsReply) String() string { return proto.CompactTextString(m) }
func (*SetSocketOptionsReply) ProtoMessage() {}
type GetSocketOptionsRequest struct {
SocketDescriptor *string `protobuf:"bytes,1,req,name=socket_descriptor" json:"socket_descriptor,omitempty"`
Options []*SocketOption `protobuf:"bytes,2,rep,name=options" json:"options,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetSocketOptionsRequest) Reset() { *m = GetSocketOptionsRequest{} }
func (m *GetSocketOptionsRequest) String() string { return proto.CompactTextString(m) }
func (*GetSocketOptionsRequest) ProtoMessage() {}
func (m *GetSocketOptionsRequest) GetSocketDescriptor() string {
if m != nil && m.SocketDescriptor != nil {
return *m.SocketDescriptor
}
return ""
}
func (m *GetSocketOptionsRequest) GetOptions() []*SocketOption {
if m != nil {
return m.Options
}
return nil
}
type GetSocketOptionsReply struct {
Options []*SocketOption `protobuf:"bytes,2,rep,name=options" json:"options,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetSocketOptionsReply) Reset() { *m = GetSocketOptionsReply{} }
func (m *GetSocketOptionsReply) String() string { return proto.CompactTextString(m) }
func (*GetSocketOptionsReply) ProtoMessage() {}
func (m *GetSocketOptionsReply) GetOptions() []*SocketOption {
if m != nil {
return m.Options
}
return nil
}
type ConnectRequest struct {
SocketDescriptor *string `protobuf:"bytes,1,req,name=socket_descriptor" json:"socket_descriptor,omitempty"`
RemoteIp *AddressPort `protobuf:"bytes,2,req,name=remote_ip" json:"remote_ip,omitempty"`
TimeoutSeconds *float64 `protobuf:"fixed64,3,opt,name=timeout_seconds,def=-1" json:"timeout_seconds,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ConnectRequest) Reset() { *m = ConnectRequest{} }
func (m *ConnectRequest) String() string { return proto.CompactTextString(m) }
func (*ConnectRequest) ProtoMessage() {}
const Default_ConnectRequest_TimeoutSeconds float64 = -1
func (m *ConnectRequest) GetSocketDescriptor() string {
if m != nil && m.SocketDescriptor != nil {
return *m.SocketDescriptor
}
return ""
}
func (m *ConnectRequest) GetRemoteIp() *AddressPort {
if m != nil {
return m.RemoteIp
}
return nil
}
func (m *ConnectRequest) GetTimeoutSeconds() float64 {
if m != nil && m.TimeoutSeconds != nil {
return *m.TimeoutSeconds
}
return Default_ConnectRequest_TimeoutSeconds
}
type ConnectReply struct {
ProxyExternalIp *AddressPort `protobuf:"bytes,1,opt,name=proxy_external_ip" json:"proxy_external_ip,omitempty"`
XXX_extensions map[int32]proto.Extension `json:"-"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ConnectReply) Reset() { *m = ConnectReply{} }
func (m *ConnectReply) String() string { return proto.CompactTextString(m) }
func (*ConnectReply) ProtoMessage() {}
var extRange_ConnectReply = []proto.ExtensionRange{
{1000, 536870911},
}
func (*ConnectReply) ExtensionRangeArray() []proto.ExtensionRange {
return extRange_ConnectReply
}
func (m *ConnectReply) ExtensionMap() map[int32]proto.Extension {
if m.XXX_extensions == nil {
m.XXX_extensions = make(map[int32]proto.Extension)
}
return m.XXX_extensions
}
func (m *ConnectReply) GetProxyExternalIp() *AddressPort {
if m != nil {
return m.ProxyExternalIp
}
return nil
}
type ListenRequest struct {
SocketDescriptor *string `protobuf:"bytes,1,req,name=socket_descriptor" json:"socket_descriptor,omitempty"`
Backlog *int32 `protobuf:"varint,2,req,name=backlog" json:"backlog,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ListenRequest) Reset() { *m = ListenRequest{} }
func (m *ListenRequest) String() string { return proto.CompactTextString(m) }
func (*ListenRequest) ProtoMessage() {}
func (m *ListenRequest) GetSocketDescriptor() string {
if m != nil && m.SocketDescriptor != nil {
return *m.SocketDescriptor
}
return ""
}
func (m *ListenRequest) GetBacklog() int32 {
if m != nil && m.Backlog != nil {
return *m.Backlog
}
return 0
}
type ListenReply struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *ListenReply) Reset() { *m = ListenReply{} }
func (m *ListenReply) String() string { return proto.CompactTextString(m) }
func (*ListenReply) ProtoMessage() {}
type AcceptRequest struct {
SocketDescriptor *string `protobuf:"bytes,1,req,name=socket_descriptor" json:"socket_descriptor,omitempty"`
TimeoutSeconds *float64 `protobuf:"fixed64,2,opt,name=timeout_seconds,def=-1" json:"timeout_seconds,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *AcceptRequest) Reset() { *m = AcceptRequest{} }
func (m *AcceptRequest) String() string { return proto.CompactTextString(m) }
func (*AcceptRequest) ProtoMessage() {}
const Default_AcceptRequest_TimeoutSeconds float64 = -1
func (m *AcceptRequest) GetSocketDescriptor() string {
if m != nil && m.SocketDescriptor != nil {
return *m.SocketDescriptor
}
return ""
}
func (m *AcceptRequest) GetTimeoutSeconds() float64 {
if m != nil && m.TimeoutSeconds != nil {
return *m.TimeoutSeconds
}
return Default_AcceptRequest_TimeoutSeconds
}
type AcceptReply struct {
NewSocketDescriptor []byte `protobuf:"bytes,2,opt,name=new_socket_descriptor" json:"new_socket_descriptor,omitempty"`
RemoteAddress *AddressPort `protobuf:"bytes,3,opt,name=remote_address" json:"remote_address,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *AcceptReply) Reset() { *m = AcceptReply{} }
func (m *AcceptReply) String() string { return proto.CompactTextString(m) }
func (*AcceptReply) ProtoMessage() {}
func (m *AcceptReply) GetNewSocketDescriptor() []byte {
if m != nil {
return m.NewSocketDescriptor
}
return nil
}
func (m *AcceptReply) GetRemoteAddress() *AddressPort {
if m != nil {
return m.RemoteAddress
}
return nil
}
type ShutDownRequest struct {
SocketDescriptor *string `protobuf:"bytes,1,req,name=socket_descriptor" json:"socket_descriptor,omitempty"`
How *ShutDownRequest_How `protobuf:"varint,2,req,name=how,enum=appengine.ShutDownRequest_How" json:"how,omitempty"`
SendOffset *int64 `protobuf:"varint,3,req,name=send_offset" json:"send_offset,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ShutDownRequest) Reset() { *m = ShutDownRequest{} }
func (m *ShutDownRequest) String() string { return proto.CompactTextString(m) }
func (*ShutDownRequest) ProtoMessage() {}
func (m *ShutDownRequest) GetSocketDescriptor() string {
if m != nil && m.SocketDescriptor != nil {
return *m.SocketDescriptor
}
return ""
}
func (m *ShutDownRequest) GetHow() ShutDownRequest_How {
if m != nil && m.How != nil {
return *m.How
}
return ShutDownRequest_SOCKET_SHUT_RD
}
func (m *ShutDownRequest) GetSendOffset() int64 {
if m != nil && m.SendOffset != nil {
return *m.SendOffset
}
return 0
}
type ShutDownReply struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *ShutDownReply) Reset() { *m = ShutDownReply{} }
func (m *ShutDownReply) String() string { return proto.CompactTextString(m) }
func (*ShutDownReply) ProtoMessage() {}
type CloseRequest struct {
SocketDescriptor *string `protobuf:"bytes,1,req,name=socket_descriptor" json:"socket_descriptor,omitempty"`
SendOffset *int64 `protobuf:"varint,2,opt,name=send_offset,def=-1" json:"send_offset,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CloseRequest) Reset() { *m = CloseRequest{} }
func (m *CloseRequest) String() string { return proto.CompactTextString(m) }
func (*CloseRequest) ProtoMessage() {}
const Default_CloseRequest_SendOffset int64 = -1
func (m *CloseRequest) GetSocketDescriptor() string {
if m != nil && m.SocketDescriptor != nil {
return *m.SocketDescriptor
}
return ""
}
func (m *CloseRequest) GetSendOffset() int64 {
if m != nil && m.SendOffset != nil {
return *m.SendOffset
}
return Default_CloseRequest_SendOffset
}
type CloseReply struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *CloseReply) Reset() { *m = CloseReply{} }
func (m *CloseReply) String() string { return proto.CompactTextString(m) }
func (*CloseReply) ProtoMessage() {}
type SendRequest struct {
SocketDescriptor *string `protobuf:"bytes,1,req,name=socket_descriptor" json:"socket_descriptor,omitempty"`
Data []byte `protobuf:"bytes,2,req,name=data" json:"data,omitempty"`
StreamOffset *int64 `protobuf:"varint,3,req,name=stream_offset" json:"stream_offset,omitempty"`
Flags *int32 `protobuf:"varint,4,opt,name=flags,def=0" json:"flags,omitempty"`
SendTo *AddressPort `protobuf:"bytes,5,opt,name=send_to" json:"send_to,omitempty"`
TimeoutSeconds *float64 `protobuf:"fixed64,6,opt,name=timeout_seconds,def=-1" json:"timeout_seconds,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *SendRequest) Reset() { *m = SendRequest{} }
func (m *SendRequest) String() string { return proto.CompactTextString(m) }
func (*SendRequest) ProtoMessage() {}
const Default_SendRequest_Flags int32 = 0
const Default_SendRequest_TimeoutSeconds float64 = -1
func (m *SendRequest) GetSocketDescriptor() string {
if m != nil && m.SocketDescriptor != nil {
return *m.SocketDescriptor
}
return ""
}
func (m *SendRequest) GetData() []byte {
if m != nil {
return m.Data
}
return nil
}
func (m *SendRequest) GetStreamOffset() int64 {
if m != nil && m.StreamOffset != nil {
return *m.StreamOffset
}
return 0
}
func (m *SendRequest) GetFlags() int32 {
if m != nil && m.Flags != nil {
return *m.Flags
}
return Default_SendRequest_Flags
}
func (m *SendRequest) GetSendTo() *AddressPort {
if m != nil {
return m.SendTo
}
return nil
}
func (m *SendRequest) GetTimeoutSeconds() float64 {
if m != nil && m.TimeoutSeconds != nil {
return *m.TimeoutSeconds
}
return Default_SendRequest_TimeoutSeconds
}
type SendReply struct {
DataSent *int32 `protobuf:"varint,1,opt,name=data_sent" json:"data_sent,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *SendReply) Reset() { *m = SendReply{} }
func (m *SendReply) String() string { return proto.CompactTextString(m) }
func (*SendReply) ProtoMessage() {}
func (m *SendReply) GetDataSent() int32 {
if m != nil && m.DataSent != nil {
return *m.DataSent
}
return 0
}
type ReceiveRequest struct {
SocketDescriptor *string `protobuf:"bytes,1,req,name=socket_descriptor" json:"socket_descriptor,omitempty"`
DataSize *int32 `protobuf:"varint,2,req,name=data_size" json:"data_size,omitempty"`
Flags *int32 `protobuf:"varint,3,opt,name=flags,def=0" json:"flags,omitempty"`
TimeoutSeconds *float64 `protobuf:"fixed64,5,opt,name=timeout_seconds,def=-1" json:"timeout_seconds,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ReceiveRequest) Reset() { *m = ReceiveRequest{} }
func (m *ReceiveRequest) String() string { return proto.CompactTextString(m) }
func (*ReceiveRequest) ProtoMessage() {}
const Default_ReceiveRequest_Flags int32 = 0
const Default_ReceiveRequest_TimeoutSeconds float64 = -1
func (m *ReceiveRequest) GetSocketDescriptor() string {
if m != nil && m.SocketDescriptor != nil {
return *m.SocketDescriptor
}
return ""
}
func (m *ReceiveRequest) GetDataSize() int32 {
if m != nil && m.DataSize != nil {
return *m.DataSize
}
return 0
}
func (m *ReceiveRequest) GetFlags() int32 {
if m != nil && m.Flags != nil {
return *m.Flags
}
return Default_ReceiveRequest_Flags
}
func (m *ReceiveRequest) GetTimeoutSeconds() float64 {
if m != nil && m.TimeoutSeconds != nil {
return *m.TimeoutSeconds
}
return Default_ReceiveRequest_TimeoutSeconds
}
type ReceiveReply struct {
StreamOffset *int64 `protobuf:"varint,2,opt,name=stream_offset" json:"stream_offset,omitempty"`
Data []byte `protobuf:"bytes,3,opt,name=data" json:"data,omitempty"`
ReceivedFrom *AddressPort `protobuf:"bytes,4,opt,name=received_from" json:"received_from,omitempty"`
BufferSize *int32 `protobuf:"varint,5,opt,name=buffer_size" json:"buffer_size,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ReceiveReply) Reset() { *m = ReceiveReply{} }
func (m *ReceiveReply) String() string { return proto.CompactTextString(m) }
func (*ReceiveReply) ProtoMessage() {}
func (m *ReceiveReply) GetStreamOffset() int64 {
if m != nil && m.StreamOffset != nil {
return *m.StreamOffset
}
return 0
}
func (m *ReceiveReply) GetData() []byte {
if m != nil {
return m.Data
}
return nil
}
func (m *ReceiveReply) GetReceivedFrom() *AddressPort {
if m != nil {
return m.ReceivedFrom
}
return nil
}
func (m *ReceiveReply) GetBufferSize() int32 {
if m != nil && m.BufferSize != nil {
return *m.BufferSize
}
return 0
}
type PollEvent struct {
SocketDescriptor *string `protobuf:"bytes,1,req,name=socket_descriptor" json:"socket_descriptor,omitempty"`
RequestedEvents *int32 `protobuf:"varint,2,req,name=requested_events" json:"requested_events,omitempty"`
ObservedEvents *int32 `protobuf:"varint,3,req,name=observed_events" json:"observed_events,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *PollEvent) Reset() { *m = PollEvent{} }
func (m *PollEvent) String() string { return proto.CompactTextString(m) }
func (*PollEvent) ProtoMessage() {}
func (m *PollEvent) GetSocketDescriptor() string {
if m != nil && m.SocketDescriptor != nil {
return *m.SocketDescriptor
}
return ""
}
func (m *PollEvent) GetRequestedEvents() int32 {
if m != nil && m.RequestedEvents != nil {
return *m.RequestedEvents
}
return 0
}
func (m *PollEvent) GetObservedEvents() int32 {
if m != nil && m.ObservedEvents != nil {
return *m.ObservedEvents
}
return 0
}
type PollRequest struct {
Events []*PollEvent `protobuf:"bytes,1,rep,name=events" json:"events,omitempty"`
TimeoutSeconds *float64 `protobuf:"fixed64,2,opt,name=timeout_seconds,def=-1" json:"timeout_seconds,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *PollRequest) Reset() { *m = PollRequest{} }
func (m *PollRequest) String() string { return proto.CompactTextString(m) }
func (*PollRequest) ProtoMessage() {}
const Default_PollRequest_TimeoutSeconds float64 = -1
func (m *PollRequest) GetEvents() []*PollEvent {
if m != nil {
return m.Events
}
return nil
}
func (m *PollRequest) GetTimeoutSeconds() float64 {
if m != nil && m.TimeoutSeconds != nil {
return *m.TimeoutSeconds
}
return Default_PollRequest_TimeoutSeconds
}
type PollReply struct {
Events []*PollEvent `protobuf:"bytes,2,rep,name=events" json:"events,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *PollReply) Reset() { *m = PollReply{} }
func (m *PollReply) String() string { return proto.CompactTextString(m) }
func (*PollReply) ProtoMessage() {}
func (m *PollReply) GetEvents() []*PollEvent {
if m != nil {
return m.Events
}
return nil
}
type ResolveRequest struct {
Name *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
AddressFamilies []CreateSocketRequest_SocketFamily `protobuf:"varint,2,rep,name=address_families,enum=appengine.CreateSocketRequest_SocketFamily" json:"address_families,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ResolveRequest) Reset() { *m = ResolveRequest{} }
func (m *ResolveRequest) String() string { return proto.CompactTextString(m) }
func (*ResolveRequest) ProtoMessage() {}
func (m *ResolveRequest) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *ResolveRequest) GetAddressFamilies() []CreateSocketRequest_SocketFamily {
if m != nil {
return m.AddressFamilies
}
return nil
}
type ResolveReply struct {
PackedAddress [][]byte `protobuf:"bytes,2,rep,name=packed_address" json:"packed_address,omitempty"`
CanonicalName *string `protobuf:"bytes,3,opt,name=canonical_name" json:"canonical_name,omitempty"`
Aliases []string `protobuf:"bytes,4,rep,name=aliases" json:"aliases,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ResolveReply) Reset() { *m = ResolveReply{} }
func (m *ResolveReply) String() string { return proto.CompactTextString(m) }
func (*ResolveReply) ProtoMessage() {}
func (m *ResolveReply) GetPackedAddress() [][]byte {
if m != nil {
return m.PackedAddress
}
return nil
}
func (m *ResolveReply) GetCanonicalName() string {
if m != nil && m.CanonicalName != nil {
return *m.CanonicalName
}
return ""
}
func (m *ResolveReply) GetAliases() []string {
if m != nil {
return m.Aliases
}
return nil
}
func init() {
}
================================================
FILE: vendor/google.golang.org/appengine/internal/socket/socket_service.proto
================================================
syntax = "proto2";
option go_package = "socket";
package appengine;
message RemoteSocketServiceError {
enum ErrorCode {
SYSTEM_ERROR = 1;
GAI_ERROR = 2;
FAILURE = 4;
PERMISSION_DENIED = 5;
INVALID_REQUEST = 6;
SOCKET_CLOSED = 7;
}
enum SystemError {
option allow_alias = true;
SYS_SUCCESS = 0;
SYS_EPERM = 1;
SYS_ENOENT = 2;
SYS_ESRCH = 3;
SYS_EINTR = 4;
SYS_EIO = 5;
SYS_ENXIO = 6;
SYS_E2BIG = 7;
SYS_ENOEXEC = 8;
SYS_EBADF = 9;
SYS_ECHILD = 10;
SYS_EAGAIN = 11;
SYS_EWOULDBLOCK = 11;
SYS_ENOMEM = 12;
SYS_EACCES = 13;
SYS_EFAULT = 14;
SYS_ENOTBLK = 15;
SYS_EBUSY = 16;
SYS_EEXIST = 17;
SYS_EXDEV = 18;
SYS_ENODEV = 19;
SYS_ENOTDIR = 20;
SYS_EISDIR = 21;
SYS_EINVAL = 22;
SYS_ENFILE = 23;
SYS_EMFILE = 24;
SYS_ENOTTY = 25;
SYS_ETXTBSY = 26;
SYS_EFBIG = 27;
SYS_ENOSPC = 28;
SYS_ESPIPE = 29;
SYS_EROFS = 30;
SYS_EMLINK = 31;
SYS_EPIPE = 32;
SYS_EDOM = 33;
SYS_ERANGE = 34;
SYS_EDEADLK = 35;
SYS_EDEADLOCK = 35;
SYS_ENAMETOOLONG = 36;
SYS_ENOLCK = 37;
SYS_ENOSYS = 38;
SYS_ENOTEMPTY = 39;
SYS_ELOOP = 40;
SYS_ENOMSG = 42;
SYS_EIDRM = 43;
SYS_ECHRNG = 44;
SYS_EL2NSYNC = 45;
SYS_EL3HLT = 46;
SYS_EL3RST = 47;
SYS_ELNRNG = 48;
SYS_EUNATCH = 49;
SYS_ENOCSI = 50;
SYS_EL2HLT = 51;
SYS_EBADE = 52;
SYS_EBADR = 53;
SYS_EXFULL = 54;
SYS_ENOANO = 55;
SYS_EBADRQC = 56;
SYS_EBADSLT = 57;
SYS_EBFONT = 59;
SYS_ENOSTR = 60;
SYS_ENODATA = 61;
SYS_ETIME = 62;
SYS_ENOSR = 63;
SYS_ENONET = 64;
SYS_ENOPKG = 65;
SYS_EREMOTE = 66;
SYS_ENOLINK = 67;
SYS_EADV = 68;
SYS_ESRMNT = 69;
SYS_ECOMM = 70;
SYS_EPROTO = 71;
SYS_EMULTIHOP = 72;
SYS_EDOTDOT = 73;
SYS_EBADMSG = 74;
SYS_EOVERFLOW = 75;
SYS_ENOTUNIQ = 76;
SYS_EBADFD = 77;
SYS_EREMCHG = 78;
SYS_ELIBACC = 79;
SYS_ELIBBAD = 80;
SYS_ELIBSCN = 81;
SYS_ELIBMAX = 82;
SYS_ELIBEXEC = 83;
SYS_EILSEQ = 84;
SYS_ERESTART = 85;
SYS_ESTRPIPE = 86;
SYS_EUSERS = 87;
SYS_ENOTSOCK = 88;
SYS_EDESTADDRREQ = 89;
SYS_EMSGSIZE = 90;
SYS_EPROTOTYPE = 91;
SYS_ENOPROTOOPT = 92;
SYS_EPROTONOSUPPORT = 93;
SYS_ESOCKTNOSUPPORT = 94;
SYS_EOPNOTSUPP = 95;
SYS_ENOTSUP = 95;
SYS_EPFNOSUPPORT = 96;
SYS_EAFNOSUPPORT = 97;
SYS_EADDRINUSE = 98;
SYS_EADDRNOTAVAIL = 99;
SYS_ENETDOWN = 100;
SYS_ENETUNREACH = 101;
SYS_ENETRESET = 102;
SYS_ECONNABORTED = 103;
SYS_ECONNRESET = 104;
SYS_ENOBUFS = 105;
SYS_EISCONN = 106;
SYS_ENOTCONN = 107;
SYS_ESHUTDOWN = 108;
SYS_ETOOMANYREFS = 109;
SYS_ETIMEDOUT = 110;
SYS_ECONNREFUSED = 111;
SYS_EHOSTDOWN = 112;
SYS_EHOSTUNREACH = 113;
SYS_EALREADY = 114;
SYS_EINPROGRESS = 115;
SYS_ESTALE = 116;
SYS_EUCLEAN = 117;
SYS_ENOTNAM = 118;
SYS_ENAVAIL = 119;
SYS_EISNAM = 120;
SYS_EREMOTEIO = 121;
SYS_EDQUOT = 122;
SYS_ENOMEDIUM = 123;
SYS_EMEDIUMTYPE = 124;
SYS_ECANCELED = 125;
SYS_ENOKEY = 126;
SYS_EKEYEXPIRED = 127;
SYS_EKEYREVOKED = 128;
SYS_EKEYREJECTED = 129;
SYS_EOWNERDEAD = 130;
SYS_ENOTRECOVERABLE = 131;
SYS_ERFKILL = 132;
}
optional int32 system_error = 1 [default=0];
optional string error_detail = 2;
}
message AddressPort {
required int32 port = 1;
optional bytes packed_address = 2;
optional string hostname_hint = 3;
}
message CreateSocketRequest {
enum SocketFamily {
IPv4 = 1;
IPv6 = 2;
}
enum SocketProtocol {
TCP = 1;
UDP = 2;
}
required SocketFamily family = 1;
required SocketProtocol protocol = 2;
repeated SocketOption socket_options = 3;
optional AddressPort proxy_external_ip = 4;
optional int32 listen_backlog = 5 [default=0];
optional AddressPort remote_ip = 6;
optional string app_id = 9;
optional int64 project_id = 10;
}
message CreateSocketReply {
optional string socket_descriptor = 1;
optional AddressPort server_address = 3;
optional AddressPort proxy_external_ip = 4;
extensions 1000 to max;
}
message BindRequest {
required string socket_descriptor = 1;
required AddressPort proxy_external_ip = 2;
}
message BindReply {
optional AddressPort proxy_external_ip = 1;
}
message GetSocketNameRequest {
required string socket_descriptor = 1;
}
message GetSocketNameReply {
optional AddressPort proxy_external_ip = 2;
}
message GetPeerNameRequest {
required string socket_descriptor = 1;
}
message GetPeerNameReply {
optional AddressPort peer_ip = 2;
}
message SocketOption {
enum SocketOptionLevel {
SOCKET_SOL_IP = 0;
SOCKET_SOL_SOCKET = 1;
SOCKET_SOL_TCP = 6;
SOCKET_SOL_UDP = 17;
}
enum SocketOptionName {
option allow_alias = true;
SOCKET_SO_DEBUG = 1;
SOCKET_SO_REUSEADDR = 2;
SOCKET_SO_TYPE = 3;
SOCKET_SO_ERROR = 4;
SOCKET_SO_DONTROUTE = 5;
SOCKET_SO_BROADCAST = 6;
SOCKET_SO_SNDBUF = 7;
SOCKET_SO_RCVBUF = 8;
SOCKET_SO_KEEPALIVE = 9;
SOCKET_SO_OOBINLINE = 10;
SOCKET_SO_LINGER = 13;
SOCKET_SO_RCVTIMEO = 20;
SOCKET_SO_SNDTIMEO = 21;
SOCKET_IP_TOS = 1;
SOCKET_IP_TTL = 2;
SOCKET_IP_HDRINCL = 3;
SOCKET_IP_OPTIONS = 4;
SOCKET_TCP_NODELAY = 1;
SOCKET_TCP_MAXSEG = 2;
SOCKET_TCP_CORK = 3;
SOCKET_TCP_KEEPIDLE = 4;
SOCKET_TCP_KEEPINTVL = 5;
SOCKET_TCP_KEEPCNT = 6;
SOCKET_TCP_SYNCNT = 7;
SOCKET_TCP_LINGER2 = 8;
SOCKET_TCP_DEFER_ACCEPT = 9;
SOCKET_TCP_WINDOW_CLAMP = 10;
SOCKET_TCP_INFO = 11;
SOCKET_TCP_QUICKACK = 12;
}
required SocketOptionLevel level = 1;
required SocketOptionName option = 2;
required bytes value = 3;
}
message SetSocketOptionsRequest {
required string socket_descriptor = 1;
repeated SocketOption options = 2;
}
message SetSocketOptionsReply {
}
message GetSocketOptionsRequest {
required string socket_descriptor = 1;
repeated SocketOption options = 2;
}
message GetSocketOptionsReply {
repeated SocketOption options = 2;
}
message ConnectRequest {
required string socket_descriptor = 1;
required AddressPort remote_ip = 2;
optional double timeout_seconds = 3 [default=-1];
}
message ConnectReply {
optional AddressPort proxy_external_ip = 1;
extensions 1000 to max;
}
message ListenRequest {
required string socket_descriptor = 1;
required int32 backlog = 2;
}
message ListenReply {
}
message AcceptRequest {
required string socket_descriptor = 1;
optional double timeout_seconds = 2 [default=-1];
}
message AcceptReply {
optional bytes new_socket_descriptor = 2;
optional AddressPort remote_address = 3;
}
message ShutDownRequest {
enum How {
SOCKET_SHUT_RD = 1;
SOCKET_SHUT_WR = 2;
SOCKET_SHUT_RDWR = 3;
}
required string socket_descriptor = 1;
required How how = 2;
required int64 send_offset = 3;
}
message ShutDownReply {
}
message CloseRequest {
required string socket_descriptor = 1;
optional int64 send_offset = 2 [default=-1];
}
message CloseReply {
}
message SendRequest {
required string socket_descriptor = 1;
required bytes data = 2 [ctype=CORD];
required int64 stream_offset = 3;
optional int32 flags = 4 [default=0];
optional AddressPort send_to = 5;
optional double timeout_seconds = 6 [default=-1];
}
message SendReply {
optional int32 data_sent = 1;
}
message ReceiveRequest {
enum Flags {
MSG_OOB = 1;
MSG_PEEK = 2;
}
required string socket_descriptor = 1;
required int32 data_size = 2;
optional int32 flags = 3 [default=0];
optional double timeout_seconds = 5 [default=-1];
}
message ReceiveReply {
optional int64 stream_offset = 2;
optional bytes data = 3 [ctype=CORD];
optional AddressPort received_from = 4;
optional int32 buffer_size = 5;
}
message PollEvent {
enum PollEventFlag {
SOCKET_POLLNONE = 0;
SOCKET_POLLIN = 1;
SOCKET_POLLPRI = 2;
SOCKET_POLLOUT = 4;
SOCKET_POLLERR = 8;
SOCKET_POLLHUP = 16;
SOCKET_POLLNVAL = 32;
SOCKET_POLLRDNORM = 64;
SOCKET_POLLRDBAND = 128;
SOCKET_POLLWRNORM = 256;
SOCKET_POLLWRBAND = 512;
SOCKET_POLLMSG = 1024;
SOCKET_POLLREMOVE = 4096;
SOCKET_POLLRDHUP = 8192;
};
required string socket_descriptor = 1;
required int32 requested_events = 2;
required int32 observed_events = 3;
}
message PollRequest {
repeated PollEvent events = 1;
optional double timeout_seconds = 2 [default=-1];
}
message PollReply {
repeated PollEvent events = 2;
}
message ResolveRequest {
required string name = 1;
repeated CreateSocketRequest.SocketFamily address_families = 2;
}
message ResolveReply {
enum ErrorCode {
SOCKET_EAI_ADDRFAMILY = 1;
SOCKET_EAI_AGAIN = 2;
SOCKET_EAI_BADFLAGS = 3;
SOCKET_EAI_FAIL = 4;
SOCKET_EAI_FAMILY = 5;
SOCKET_EAI_MEMORY = 6;
SOCKET_EAI_NODATA = 7;
SOCKET_EAI_NONAME = 8;
SOCKET_EAI_SERVICE = 9;
SOCKET_EAI_SOCKTYPE = 10;
SOCKET_EAI_SYSTEM = 11;
SOCKET_EAI_BADHINTS = 12;
SOCKET_EAI_PROTOCOL = 13;
SOCKET_EAI_OVERFLOW = 14;
SOCKET_EAI_MAX = 15;
};
repeated bytes packed_address = 2;
optional string canonical_name = 3;
repeated string aliases = 4;
}
================================================
FILE: vendor/google.golang.org/appengine/internal/system/system_service.pb.go
================================================
// Code generated by protoc-gen-go.
// source: google.golang.org/appengine/internal/system/system_service.proto
// DO NOT EDIT!
/*
Package system is a generated protocol buffer package.
It is generated from these files:
google.golang.org/appengine/internal/system/system_service.proto
It has these top-level messages:
SystemServiceError
SystemStat
GetSystemStatsRequest
GetSystemStatsResponse
StartBackgroundRequestRequest
StartBackgroundRequestResponse
*/
package system
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type SystemServiceError_ErrorCode int32
const (
SystemServiceError_OK SystemServiceError_ErrorCode = 0
SystemServiceError_INTERNAL_ERROR SystemServiceError_ErrorCode = 1
SystemServiceError_BACKEND_REQUIRED SystemServiceError_ErrorCode = 2
SystemServiceError_LIMIT_REACHED SystemServiceError_ErrorCode = 3
)
var SystemServiceError_ErrorCode_name = map[int32]string{
0: "OK",
1: "INTERNAL_ERROR",
2: "BACKEND_REQUIRED",
3: "LIMIT_REACHED",
}
var SystemServiceError_ErrorCode_value = map[string]int32{
"OK": 0,
"INTERNAL_ERROR": 1,
"BACKEND_REQUIRED": 2,
"LIMIT_REACHED": 3,
}
func (x SystemServiceError_ErrorCode) Enum() *SystemServiceError_ErrorCode {
p := new(SystemServiceError_ErrorCode)
*p = x
return p
}
func (x SystemServiceError_ErrorCode) String() string {
return proto.EnumName(SystemServiceError_ErrorCode_name, int32(x))
}
func (x *SystemServiceError_ErrorCode) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(SystemServiceError_ErrorCode_value, data, "SystemServiceError_ErrorCode")
if err != nil {
return err
}
*x = SystemServiceError_ErrorCode(value)
return nil
}
type SystemServiceError struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *SystemServiceError) Reset() { *m = SystemServiceError{} }
func (m *SystemServiceError) String() string { return proto.CompactTextString(m) }
func (*SystemServiceError) ProtoMessage() {}
type SystemStat struct {
// Instaneous value of this stat.
Current *float64 `protobuf:"fixed64,1,opt,name=current" json:"current,omitempty"`
// Average over time, if this stat has an instaneous value.
Average1M *float64 `protobuf:"fixed64,3,opt,name=average1m" json:"average1m,omitempty"`
Average10M *float64 `protobuf:"fixed64,4,opt,name=average10m" json:"average10m,omitempty"`
// Total value, if the stat accumulates over time.
Total *float64 `protobuf:"fixed64,2,opt,name=total" json:"total,omitempty"`
// Rate over time, if this stat accumulates.
Rate1M *float64 `protobuf:"fixed64,5,opt,name=rate1m" json:"rate1m,omitempty"`
Rate10M *float64 `protobuf:"fixed64,6,opt,name=rate10m" json:"rate10m,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *SystemStat) Reset() { *m = SystemStat{} }
func (m *SystemStat) String() string { return proto.CompactTextString(m) }
func (*SystemStat) ProtoMessage() {}
func (m *SystemStat) GetCurrent() float64 {
if m != nil && m.Current != nil {
return *m.Current
}
return 0
}
func (m *SystemStat) GetAverage1M() float64 {
if m != nil && m.Average1M != nil {
return *m.Average1M
}
return 0
}
func (m *SystemStat) GetAverage10M() float64 {
if m != nil && m.Average10M != nil {
return *m.Average10M
}
return 0
}
func (m *SystemStat) GetTotal() float64 {
if m != nil && m.Total != nil {
return *m.Total
}
return 0
}
func (m *SystemStat) GetRate1M() float64 {
if m != nil && m.Rate1M != nil {
return *m.Rate1M
}
return 0
}
func (m *SystemStat) GetRate10M() float64 {
if m != nil && m.Rate10M != nil {
return *m.Rate10M
}
return 0
}
type GetSystemStatsRequest struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *GetSystemStatsRequest) Reset() { *m = GetSystemStatsRequest{} }
func (m *GetSystemStatsRequest) String() string { return proto.CompactTextString(m) }
func (*GetSystemStatsRequest) ProtoMessage() {}
type GetSystemStatsResponse struct {
// CPU used by this instance, in mcycles.
Cpu *SystemStat `protobuf:"bytes,1,opt,name=cpu" json:"cpu,omitempty"`
// Physical memory (RAM) used by this instance, in megabytes.
Memory *SystemStat `protobuf:"bytes,2,opt,name=memory" json:"memory,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetSystemStatsResponse) Reset() { *m = GetSystemStatsResponse{} }
func (m *GetSystemStatsResponse) String() string { return proto.CompactTextString(m) }
func (*GetSystemStatsResponse) ProtoMessage() {}
func (m *GetSystemStatsResponse) GetCpu() *SystemStat {
if m != nil {
return m.Cpu
}
return nil
}
func (m *GetSystemStatsResponse) GetMemory() *SystemStat {
if m != nil {
return m.Memory
}
return nil
}
type StartBackgroundRequestRequest struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *StartBackgroundRequestRequest) Reset() { *m = StartBackgroundRequestRequest{} }
func (m *StartBackgroundRequestRequest) String() string { return proto.CompactTextString(m) }
func (*StartBackgroundRequestRequest) ProtoMessage() {}
type StartBackgroundRequestResponse struct {
// Every /_ah/background request will have an X-AppEngine-BackgroundRequest
// header, whose value will be equal to this parameter, the request_id.
RequestId *string `protobuf:"bytes,1,opt,name=request_id" json:"request_id,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *StartBackgroundRequestResponse) Reset() { *m = StartBackgroundRequestResponse{} }
func (m *StartBackgroundRequestResponse) String() string { return proto.CompactTextString(m) }
func (*StartBackgroundRequestResponse) ProtoMessage() {}
func (m *StartBackgroundRequestResponse) GetRequestId() string {
if m != nil && m.RequestId != nil {
return *m.RequestId
}
return ""
}
func init() {
}
================================================
FILE: vendor/google.golang.org/appengine/internal/system/system_service.proto
================================================
syntax = "proto2";
option go_package = "system";
package appengine;
message SystemServiceError {
enum ErrorCode {
OK = 0;
INTERNAL_ERROR = 1;
BACKEND_REQUIRED = 2;
LIMIT_REACHED = 3;
}
}
message SystemStat {
// Instaneous value of this stat.
optional double current = 1;
// Average over time, if this stat has an instaneous value.
optional double average1m = 3;
optional double average10m = 4;
// Total value, if the stat accumulates over time.
optional double total = 2;
// Rate over time, if this stat accumulates.
optional double rate1m = 5;
optional double rate10m = 6;
}
message GetSystemStatsRequest {
}
message GetSystemStatsResponse {
// CPU used by this instance, in mcycles.
optional SystemStat cpu = 1;
// Physical memory (RAM) used by this instance, in megabytes.
optional SystemStat memory = 2;
}
message StartBackgroundRequestRequest {
}
message StartBackgroundRequestResponse {
// Every /_ah/background request will have an X-AppEngine-BackgroundRequest
// header, whose value will be equal to this parameter, the request_id.
optional string request_id = 1;
}
================================================
FILE: vendor/google.golang.org/appengine/internal/taskqueue/taskqueue_service.pb.go
================================================
// Code generated by protoc-gen-go.
// source: google.golang.org/appengine/internal/taskqueue/taskqueue_service.proto
// DO NOT EDIT!
/*
Package taskqueue is a generated protocol buffer package.
It is generated from these files:
google.golang.org/appengine/internal/taskqueue/taskqueue_service.proto
It has these top-level messages:
TaskQueueServiceError
TaskPayload
TaskQueueRetryParameters
TaskQueueAcl
TaskQueueHttpHeader
TaskQueueMode
TaskQueueAddRequest
TaskQueueAddResponse
TaskQueueBulkAddRequest
TaskQueueBulkAddResponse
TaskQueueDeleteRequest
TaskQueueDeleteResponse
TaskQueueForceRunRequest
TaskQueueForceRunResponse
TaskQueueUpdateQueueRequest
TaskQueueUpdateQueueResponse
TaskQueueFetchQueuesRequest
TaskQueueFetchQueuesResponse
TaskQueueFetchQueueStatsRequest
TaskQueueScannerQueueInfo
TaskQueueFetchQueueStatsResponse
TaskQueuePauseQueueRequest
TaskQueuePauseQueueResponse
TaskQueuePurgeQueueRequest
TaskQueuePurgeQueueResponse
TaskQueueDeleteQueueRequest
TaskQueueDeleteQueueResponse
TaskQueueDeleteGroupRequest
TaskQueueDeleteGroupResponse
TaskQueueQueryTasksRequest
TaskQueueQueryTasksResponse
TaskQueueFetchTaskRequest
TaskQueueFetchTaskResponse
TaskQueueUpdateStorageLimitRequest
TaskQueueUpdateStorageLimitResponse
TaskQueueQueryAndOwnTasksRequest
TaskQueueQueryAndOwnTasksResponse
TaskQueueModifyTaskLeaseRequest
TaskQueueModifyTaskLeaseResponse
*/
package taskqueue
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
import appengine "google.golang.org/appengine/internal/datastore"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type TaskQueueServiceError_ErrorCode int32
const (
TaskQueueServiceError_OK TaskQueueServiceError_ErrorCode = 0
TaskQueueServiceError_UNKNOWN_QUEUE TaskQueueServiceError_ErrorCode = 1
TaskQueueServiceError_TRANSIENT_ERROR TaskQueueServiceError_ErrorCode = 2
TaskQueueServiceError_INTERNAL_ERROR TaskQueueServiceError_ErrorCode = 3
TaskQueueServiceError_TASK_TOO_LARGE TaskQueueServiceError_ErrorCode = 4
TaskQueueServiceError_INVALID_TASK_NAME TaskQueueServiceError_ErrorCode = 5
TaskQueueServiceError_INVALID_QUEUE_NAME TaskQueueServiceError_ErrorCode = 6
TaskQueueServiceError_INVALID_URL TaskQueueServiceError_ErrorCode = 7
TaskQueueServiceError_INVALID_QUEUE_RATE TaskQueueServiceError_ErrorCode = 8
TaskQueueServiceError_PERMISSION_DENIED TaskQueueServiceError_ErrorCode = 9
TaskQueueServiceError_TASK_ALREADY_EXISTS TaskQueueServiceError_ErrorCode = 10
TaskQueueServiceError_TOMBSTONED_TASK TaskQueueServiceError_ErrorCode = 11
TaskQueueServiceError_INVALID_ETA TaskQueueServiceError_ErrorCode = 12
TaskQueueServiceError_INVALID_REQUEST TaskQueueServiceError_ErrorCode = 13
TaskQueueServiceError_UNKNOWN_TASK TaskQueueServiceError_ErrorCode = 14
TaskQueueServiceError_TOMBSTONED_QUEUE TaskQueueServiceError_ErrorCode = 15
TaskQueueServiceError_DUPLICATE_TASK_NAME TaskQueueServiceError_ErrorCode = 16
TaskQueueServiceError_SKIPPED TaskQueueServiceError_ErrorCode = 17
TaskQueueServiceError_TOO_MANY_TASKS TaskQueueServiceError_ErrorCode = 18
TaskQueueServiceError_INVALID_PAYLOAD TaskQueueServiceError_ErrorCode = 19
TaskQueueServiceError_INVALID_RETRY_PARAMETERS TaskQueueServiceError_ErrorCode = 20
TaskQueueServiceError_INVALID_QUEUE_MODE TaskQueueServiceError_ErrorCode = 21
TaskQueueServiceError_ACL_LOOKUP_ERROR TaskQueueServiceError_ErrorCode = 22
TaskQueueServiceError_TRANSACTIONAL_REQUEST_TOO_LARGE TaskQueueServiceError_ErrorCode = 23
TaskQueueServiceError_INCORRECT_CREATOR_NAME TaskQueueServiceError_ErrorCode = 24
TaskQueueServiceError_TASK_LEASE_EXPIRED TaskQueueServiceError_ErrorCode = 25
TaskQueueServiceError_QUEUE_PAUSED TaskQueueServiceError_ErrorCode = 26
TaskQueueServiceError_INVALID_TAG TaskQueueServiceError_ErrorCode = 27
// Reserved range for the Datastore error codes.
// Original Datastore error code is shifted by DATASTORE_ERROR offset.
TaskQueueServiceError_DATASTORE_ERROR TaskQueueServiceError_ErrorCode = 10000
)
var TaskQueueServiceError_ErrorCode_name = map[int32]string{
0: "OK",
1: "UNKNOWN_QUEUE",
2: "TRANSIENT_ERROR",
3: "INTERNAL_ERROR",
4: "TASK_TOO_LARGE",
5: "INVALID_TASK_NAME",
6: "INVALID_QUEUE_NAME",
7: "INVALID_URL",
8: "INVALID_QUEUE_RATE",
9: "PERMISSION_DENIED",
10: "TASK_ALREADY_EXISTS",
11: "TOMBSTONED_TASK",
12: "INVALID_ETA",
13: "INVALID_REQUEST",
14: "UNKNOWN_TASK",
15: "TOMBSTONED_QUEUE",
16: "DUPLICATE_TASK_NAME",
17: "SKIPPED",
18: "TOO_MANY_TASKS",
19: "INVALID_PAYLOAD",
20: "INVALID_RETRY_PARAMETERS",
21: "INVALID_QUEUE_MODE",
22: "ACL_LOOKUP_ERROR",
23: "TRANSACTIONAL_REQUEST_TOO_LARGE",
24: "INCORRECT_CREATOR_NAME",
25: "TASK_LEASE_EXPIRED",
26: "QUEUE_PAUSED",
27: "INVALID_TAG",
10000: "DATASTORE_ERROR",
}
var TaskQueueServiceError_ErrorCode_value = map[string]int32{
"OK": 0,
"UNKNOWN_QUEUE": 1,
"TRANSIENT_ERROR": 2,
"INTERNAL_ERROR": 3,
"TASK_TOO_LARGE": 4,
"INVALID_TASK_NAME": 5,
"INVALID_QUEUE_NAME": 6,
"INVALID_URL": 7,
"INVALID_QUEUE_RATE": 8,
"PERMISSION_DENIED": 9,
"TASK_ALREADY_EXISTS": 10,
"TOMBSTONED_TASK": 11,
"INVALID_ETA": 12,
"INVALID_REQUEST": 13,
"UNKNOWN_TASK": 14,
"TOMBSTONED_QUEUE": 15,
"DUPLICATE_TASK_NAME": 16,
"SKIPPED": 17,
"TOO_MANY_TASKS": 18,
"INVALID_PAYLOAD": 19,
"INVALID_RETRY_PARAMETERS": 20,
"INVALID_QUEUE_MODE": 21,
"ACL_LOOKUP_ERROR": 22,
"TRANSACTIONAL_REQUEST_TOO_LARGE": 23,
"INCORRECT_CREATOR_NAME": 24,
"TASK_LEASE_EXPIRED": 25,
"QUEUE_PAUSED": 26,
"INVALID_TAG": 27,
"DATASTORE_ERROR": 10000,
}
func (x TaskQueueServiceError_ErrorCode) Enum() *TaskQueueServiceError_ErrorCode {
p := new(TaskQueueServiceError_ErrorCode)
*p = x
return p
}
func (x TaskQueueServiceError_ErrorCode) String() string {
return proto.EnumName(TaskQueueServiceError_ErrorCode_name, int32(x))
}
func (x *TaskQueueServiceError_ErrorCode) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(TaskQueueServiceError_ErrorCode_value, data, "TaskQueueServiceError_ErrorCode")
if err != nil {
return err
}
*x = TaskQueueServiceError_ErrorCode(value)
return nil
}
type TaskQueueMode_Mode int32
const (
TaskQueueMode_PUSH TaskQueueMode_Mode = 0
TaskQueueMode_PULL TaskQueueMode_Mode = 1
)
var TaskQueueMode_Mode_name = map[int32]string{
0: "PUSH",
1: "PULL",
}
var TaskQueueMode_Mode_value = map[string]int32{
"PUSH": 0,
"PULL": 1,
}
func (x TaskQueueMode_Mode) Enum() *TaskQueueMode_Mode {
p := new(TaskQueueMode_Mode)
*p = x
return p
}
func (x TaskQueueMode_Mode) String() string {
return proto.EnumName(TaskQueueMode_Mode_name, int32(x))
}
func (x *TaskQueueMode_Mode) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(TaskQueueMode_Mode_value, data, "TaskQueueMode_Mode")
if err != nil {
return err
}
*x = TaskQueueMode_Mode(value)
return nil
}
type TaskQueueAddRequest_RequestMethod int32
const (
TaskQueueAddRequest_GET TaskQueueAddRequest_RequestMethod = 1
TaskQueueAddRequest_POST TaskQueueAddRequest_RequestMethod = 2
TaskQueueAddRequest_HEAD TaskQueueAddRequest_RequestMethod = 3
TaskQueueAddRequest_PUT TaskQueueAddRequest_RequestMethod = 4
TaskQueueAddRequest_DELETE TaskQueueAddRequest_RequestMethod = 5
)
var TaskQueueAddRequest_RequestMethod_name = map[int32]string{
1: "GET",
2: "POST",
3: "HEAD",
4: "PUT",
5: "DELETE",
}
var TaskQueueAddRequest_RequestMethod_value = map[string]int32{
"GET": 1,
"POST": 2,
"HEAD": 3,
"PUT": 4,
"DELETE": 5,
}
func (x TaskQueueAddRequest_RequestMethod) Enum() *TaskQueueAddRequest_RequestMethod {
p := new(TaskQueueAddRequest_RequestMethod)
*p = x
return p
}
func (x TaskQueueAddRequest_RequestMethod) String() string {
return proto.EnumName(TaskQueueAddRequest_RequestMethod_name, int32(x))
}
func (x *TaskQueueAddRequest_RequestMethod) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(TaskQueueAddRequest_RequestMethod_value, data, "TaskQueueAddRequest_RequestMethod")
if err != nil {
return err
}
*x = TaskQueueAddRequest_RequestMethod(value)
return nil
}
type TaskQueueQueryTasksResponse_Task_RequestMethod int32
const (
TaskQueueQueryTasksResponse_Task_GET TaskQueueQueryTasksResponse_Task_RequestMethod = 1
TaskQueueQueryTasksResponse_Task_POST TaskQueueQueryTasksResponse_Task_RequestMethod = 2
TaskQueueQueryTasksResponse_Task_HEAD TaskQueueQueryTasksResponse_Task_RequestMethod = 3
TaskQueueQueryTasksResponse_Task_PUT TaskQueueQueryTasksResponse_Task_RequestMethod = 4
TaskQueueQueryTasksResponse_Task_DELETE TaskQueueQueryTasksResponse_Task_RequestMethod = 5
)
var TaskQueueQueryTasksResponse_Task_RequestMethod_name = map[int32]string{
1: "GET",
2: "POST",
3: "HEAD",
4: "PUT",
5: "DELETE",
}
var TaskQueueQueryTasksResponse_Task_RequestMethod_value = map[string]int32{
"GET": 1,
"POST": 2,
"HEAD": 3,
"PUT": 4,
"DELETE": 5,
}
func (x TaskQueueQueryTasksResponse_Task_RequestMethod) Enum() *TaskQueueQueryTasksResponse_Task_RequestMethod {
p := new(TaskQueueQueryTasksResponse_Task_RequestMethod)
*p = x
return p
}
func (x TaskQueueQueryTasksResponse_Task_RequestMethod) String() string {
return proto.EnumName(TaskQueueQueryTasksResponse_Task_RequestMethod_name, int32(x))
}
func (x *TaskQueueQueryTasksResponse_Task_RequestMethod) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(TaskQueueQueryTasksResponse_Task_RequestMethod_value, data, "TaskQueueQueryTasksResponse_Task_RequestMethod")
if err != nil {
return err
}
*x = TaskQueueQueryTasksResponse_Task_RequestMethod(value)
return nil
}
type TaskQueueServiceError struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueServiceError) Reset() { *m = TaskQueueServiceError{} }
func (m *TaskQueueServiceError) String() string { return proto.CompactTextString(m) }
func (*TaskQueueServiceError) ProtoMessage() {}
type TaskPayload struct {
XXX_extensions map[int32]proto.Extension `json:"-"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskPayload) Reset() { *m = TaskPayload{} }
func (m *TaskPayload) String() string { return proto.CompactTextString(m) }
func (*TaskPayload) ProtoMessage() {}
func (m *TaskPayload) Marshal() ([]byte, error) {
return proto.MarshalMessageSet(m.ExtensionMap())
}
func (m *TaskPayload) Unmarshal(buf []byte) error {
return proto.UnmarshalMessageSet(buf, m.ExtensionMap())
}
func (m *TaskPayload) MarshalJSON() ([]byte, error) {
return proto.MarshalMessageSetJSON(m.XXX_extensions)
}
func (m *TaskPayload) UnmarshalJSON(buf []byte) error {
return proto.UnmarshalMessageSetJSON(buf, m.XXX_extensions)
}
// ensure TaskPayload satisfies proto.Marshaler and proto.Unmarshaler
var _ proto.Marshaler = (*TaskPayload)(nil)
var _ proto.Unmarshaler = (*TaskPayload)(nil)
var extRange_TaskPayload = []proto.ExtensionRange{
{10, 2147483646},
}
func (*TaskPayload) ExtensionRangeArray() []proto.ExtensionRange {
return extRange_TaskPayload
}
func (m *TaskPayload) ExtensionMap() map[int32]proto.Extension {
if m.XXX_extensions == nil {
m.XXX_extensions = make(map[int32]proto.Extension)
}
return m.XXX_extensions
}
type TaskQueueRetryParameters struct {
RetryLimit *int32 `protobuf:"varint,1,opt,name=retry_limit" json:"retry_limit,omitempty"`
AgeLimitSec *int64 `protobuf:"varint,2,opt,name=age_limit_sec" json:"age_limit_sec,omitempty"`
MinBackoffSec *float64 `protobuf:"fixed64,3,opt,name=min_backoff_sec,def=0.1" json:"min_backoff_sec,omitempty"`
MaxBackoffSec *float64 `protobuf:"fixed64,4,opt,name=max_backoff_sec,def=3600" json:"max_backoff_sec,omitempty"`
MaxDoublings *int32 `protobuf:"varint,5,opt,name=max_doublings,def=16" json:"max_doublings,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueRetryParameters) Reset() { *m = TaskQueueRetryParameters{} }
func (m *TaskQueueRetryParameters) String() string { return proto.CompactTextString(m) }
func (*TaskQueueRetryParameters) ProtoMessage() {}
const Default_TaskQueueRetryParameters_MinBackoffSec float64 = 0.1
const Default_TaskQueueRetryParameters_MaxBackoffSec float64 = 3600
const Default_TaskQueueRetryParameters_MaxDoublings int32 = 16
func (m *TaskQueueRetryParameters) GetRetryLimit() int32 {
if m != nil && m.RetryLimit != nil {
return *m.RetryLimit
}
return 0
}
func (m *TaskQueueRetryParameters) GetAgeLimitSec() int64 {
if m != nil && m.AgeLimitSec != nil {
return *m.AgeLimitSec
}
return 0
}
func (m *TaskQueueRetryParameters) GetMinBackoffSec() float64 {
if m != nil && m.MinBackoffSec != nil {
return *m.MinBackoffSec
}
return Default_TaskQueueRetryParameters_MinBackoffSec
}
func (m *TaskQueueRetryParameters) GetMaxBackoffSec() float64 {
if m != nil && m.MaxBackoffSec != nil {
return *m.MaxBackoffSec
}
return Default_TaskQueueRetryParameters_MaxBackoffSec
}
func (m *TaskQueueRetryParameters) GetMaxDoublings() int32 {
if m != nil && m.MaxDoublings != nil {
return *m.MaxDoublings
}
return Default_TaskQueueRetryParameters_MaxDoublings
}
type TaskQueueAcl struct {
UserEmail [][]byte `protobuf:"bytes,1,rep,name=user_email" json:"user_email,omitempty"`
WriterEmail [][]byte `protobuf:"bytes,2,rep,name=writer_email" json:"writer_email,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueAcl) Reset() { *m = TaskQueueAcl{} }
func (m *TaskQueueAcl) String() string { return proto.CompactTextString(m) }
func (*TaskQueueAcl) ProtoMessage() {}
func (m *TaskQueueAcl) GetUserEmail() [][]byte {
if m != nil {
return m.UserEmail
}
return nil
}
func (m *TaskQueueAcl) GetWriterEmail() [][]byte {
if m != nil {
return m.WriterEmail
}
return nil
}
type TaskQueueHttpHeader struct {
Key []byte `protobuf:"bytes,1,req,name=key" json:"key,omitempty"`
Value []byte `protobuf:"bytes,2,req,name=value" json:"value,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueHttpHeader) Reset() { *m = TaskQueueHttpHeader{} }
func (m *TaskQueueHttpHeader) String() string { return proto.CompactTextString(m) }
func (*TaskQueueHttpHeader) ProtoMessage() {}
func (m *TaskQueueHttpHeader) GetKey() []byte {
if m != nil {
return m.Key
}
return nil
}
func (m *TaskQueueHttpHeader) GetValue() []byte {
if m != nil {
return m.Value
}
return nil
}
type TaskQueueMode struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueMode) Reset() { *m = TaskQueueMode{} }
func (m *TaskQueueMode) String() string { return proto.CompactTextString(m) }
func (*TaskQueueMode) ProtoMessage() {}
type TaskQueueAddRequest struct {
QueueName []byte `protobuf:"bytes,1,req,name=queue_name" json:"queue_name,omitempty"`
TaskName []byte `protobuf:"bytes,2,req,name=task_name" json:"task_name,omitempty"`
EtaUsec *int64 `protobuf:"varint,3,req,name=eta_usec" json:"eta_usec,omitempty"`
Method *TaskQueueAddRequest_RequestMethod `protobuf:"varint,5,opt,name=method,enum=appengine.TaskQueueAddRequest_RequestMethod,def=2" json:"method,omitempty"`
Url []byte `protobuf:"bytes,4,opt,name=url" json:"url,omitempty"`
Header []*TaskQueueAddRequest_Header `protobuf:"group,6,rep,name=Header" json:"header,omitempty"`
Body []byte `protobuf:"bytes,9,opt,name=body" json:"body,omitempty"`
Transaction *appengine.Transaction `protobuf:"bytes,10,opt,name=transaction" json:"transaction,omitempty"`
AppId []byte `protobuf:"bytes,11,opt,name=app_id" json:"app_id,omitempty"`
Crontimetable *TaskQueueAddRequest_CronTimetable `protobuf:"group,12,opt,name=CronTimetable" json:"crontimetable,omitempty"`
Description []byte `protobuf:"bytes,15,opt,name=description" json:"description,omitempty"`
Payload *TaskPayload `protobuf:"bytes,16,opt,name=payload" json:"payload,omitempty"`
RetryParameters *TaskQueueRetryParameters `protobuf:"bytes,17,opt,name=retry_parameters" json:"retry_parameters,omitempty"`
Mode *TaskQueueMode_Mode `protobuf:"varint,18,opt,name=mode,enum=appengine.TaskQueueMode_Mode,def=0" json:"mode,omitempty"`
Tag []byte `protobuf:"bytes,19,opt,name=tag" json:"tag,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueAddRequest) Reset() { *m = TaskQueueAddRequest{} }
func (m *TaskQueueAddRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueueAddRequest) ProtoMessage() {}
const Default_TaskQueueAddRequest_Method TaskQueueAddRequest_RequestMethod = TaskQueueAddRequest_POST
const Default_TaskQueueAddRequest_Mode TaskQueueMode_Mode = TaskQueueMode_PUSH
func (m *TaskQueueAddRequest) GetQueueName() []byte {
if m != nil {
return m.QueueName
}
return nil
}
func (m *TaskQueueAddRequest) GetTaskName() []byte {
if m != nil {
return m.TaskName
}
return nil
}
func (m *TaskQueueAddRequest) GetEtaUsec() int64 {
if m != nil && m.EtaUsec != nil {
return *m.EtaUsec
}
return 0
}
func (m *TaskQueueAddRequest) GetMethod() TaskQueueAddRequest_RequestMethod {
if m != nil && m.Method != nil {
return *m.Method
}
return Default_TaskQueueAddRequest_Method
}
func (m *TaskQueueAddRequest) GetUrl() []byte {
if m != nil {
return m.Url
}
return nil
}
func (m *TaskQueueAddRequest) GetHeader() []*TaskQueueAddRequest_Header {
if m != nil {
return m.Header
}
return nil
}
func (m *TaskQueueAddRequest) GetBody() []byte {
if m != nil {
return m.Body
}
return nil
}
func (m *TaskQueueAddRequest) GetTransaction() *appengine.Transaction {
if m != nil {
return m.Transaction
}
return nil
}
func (m *TaskQueueAddRequest) GetAppId() []byte {
if m != nil {
return m.AppId
}
return nil
}
func (m *TaskQueueAddRequest) GetCrontimetable() *TaskQueueAddRequest_CronTimetable {
if m != nil {
return m.Crontimetable
}
return nil
}
func (m *TaskQueueAddRequest) GetDescription() []byte {
if m != nil {
return m.Description
}
return nil
}
func (m *TaskQueueAddRequest) GetPayload() *TaskPayload {
if m != nil {
return m.Payload
}
return nil
}
func (m *TaskQueueAddRequest) GetRetryParameters() *TaskQueueRetryParameters {
if m != nil {
return m.RetryParameters
}
return nil
}
func (m *TaskQueueAddRequest) GetMode() TaskQueueMode_Mode {
if m != nil && m.Mode != nil {
return *m.Mode
}
return Default_TaskQueueAddRequest_Mode
}
func (m *TaskQueueAddRequest) GetTag() []byte {
if m != nil {
return m.Tag
}
return nil
}
type TaskQueueAddRequest_Header struct {
Key []byte `protobuf:"bytes,7,req,name=key" json:"key,omitempty"`
Value []byte `protobuf:"bytes,8,req,name=value" json:"value,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueAddRequest_Header) Reset() { *m = TaskQueueAddRequest_Header{} }
func (m *TaskQueueAddRequest_Header) String() string { return proto.CompactTextString(m) }
func (*TaskQueueAddRequest_Header) ProtoMessage() {}
func (m *TaskQueueAddRequest_Header) GetKey() []byte {
if m != nil {
return m.Key
}
return nil
}
func (m *TaskQueueAddRequest_Header) GetValue() []byte {
if m != nil {
return m.Value
}
return nil
}
type TaskQueueAddRequest_CronTimetable struct {
Schedule []byte `protobuf:"bytes,13,req,name=schedule" json:"schedule,omitempty"`
Timezone []byte `protobuf:"bytes,14,req,name=timezone" json:"timezone,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueAddRequest_CronTimetable) Reset() { *m = TaskQueueAddRequest_CronTimetable{} }
func (m *TaskQueueAddRequest_CronTimetable) String() string { return proto.CompactTextString(m) }
func (*TaskQueueAddRequest_CronTimetable) ProtoMessage() {}
func (m *TaskQueueAddRequest_CronTimetable) GetSchedule() []byte {
if m != nil {
return m.Schedule
}
return nil
}
func (m *TaskQueueAddRequest_CronTimetable) GetTimezone() []byte {
if m != nil {
return m.Timezone
}
return nil
}
type TaskQueueAddResponse struct {
ChosenTaskName []byte `protobuf:"bytes,1,opt,name=chosen_task_name" json:"chosen_task_name,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueAddResponse) Reset() { *m = TaskQueueAddResponse{} }
func (m *TaskQueueAddResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueueAddResponse) ProtoMessage() {}
func (m *TaskQueueAddResponse) GetChosenTaskName() []byte {
if m != nil {
return m.ChosenTaskName
}
return nil
}
type TaskQueueBulkAddRequest struct {
AddRequest []*TaskQueueAddRequest `protobuf:"bytes,1,rep,name=add_request" json:"add_request,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueBulkAddRequest) Reset() { *m = TaskQueueBulkAddRequest{} }
func (m *TaskQueueBulkAddRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueueBulkAddRequest) ProtoMessage() {}
func (m *TaskQueueBulkAddRequest) GetAddRequest() []*TaskQueueAddRequest {
if m != nil {
return m.AddRequest
}
return nil
}
type TaskQueueBulkAddResponse struct {
Taskresult []*TaskQueueBulkAddResponse_TaskResult `protobuf:"group,1,rep,name=TaskResult" json:"taskresult,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueBulkAddResponse) Reset() { *m = TaskQueueBulkAddResponse{} }
func (m *TaskQueueBulkAddResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueueBulkAddResponse) ProtoMessage() {}
func (m *TaskQueueBulkAddResponse) GetTaskresult() []*TaskQueueBulkAddResponse_TaskResult {
if m != nil {
return m.Taskresult
}
return nil
}
type TaskQueueBulkAddResponse_TaskResult struct {
Result *TaskQueueServiceError_ErrorCode `protobuf:"varint,2,req,name=result,enum=appengine.TaskQueueServiceError_ErrorCode" json:"result,omitempty"`
ChosenTaskName []byte `protobuf:"bytes,3,opt,name=chosen_task_name" json:"chosen_task_name,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueBulkAddResponse_TaskResult) Reset() { *m = TaskQueueBulkAddResponse_TaskResult{} }
func (m *TaskQueueBulkAddResponse_TaskResult) String() string { return proto.CompactTextString(m) }
func (*TaskQueueBulkAddResponse_TaskResult) ProtoMessage() {}
func (m *TaskQueueBulkAddResponse_TaskResult) GetResult() TaskQueueServiceError_ErrorCode {
if m != nil && m.Result != nil {
return *m.Result
}
return TaskQueueServiceError_OK
}
func (m *TaskQueueBulkAddResponse_TaskResult) GetChosenTaskName() []byte {
if m != nil {
return m.ChosenTaskName
}
return nil
}
type TaskQueueDeleteRequest struct {
QueueName []byte `protobuf:"bytes,1,req,name=queue_name" json:"queue_name,omitempty"`
TaskName [][]byte `protobuf:"bytes,2,rep,name=task_name" json:"task_name,omitempty"`
AppId []byte `protobuf:"bytes,3,opt,name=app_id" json:"app_id,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueDeleteRequest) Reset() { *m = TaskQueueDeleteRequest{} }
func (m *TaskQueueDeleteRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueueDeleteRequest) ProtoMessage() {}
func (m *TaskQueueDeleteRequest) GetQueueName() []byte {
if m != nil {
return m.QueueName
}
return nil
}
func (m *TaskQueueDeleteRequest) GetTaskName() [][]byte {
if m != nil {
return m.TaskName
}
return nil
}
func (m *TaskQueueDeleteRequest) GetAppId() []byte {
if m != nil {
return m.AppId
}
return nil
}
type TaskQueueDeleteResponse struct {
Result []TaskQueueServiceError_ErrorCode `protobuf:"varint,3,rep,name=result,enum=appengine.TaskQueueServiceError_ErrorCode" json:"result,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueDeleteResponse) Reset() { *m = TaskQueueDeleteResponse{} }
func (m *TaskQueueDeleteResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueueDeleteResponse) ProtoMessage() {}
func (m *TaskQueueDeleteResponse) GetResult() []TaskQueueServiceError_ErrorCode {
if m != nil {
return m.Result
}
return nil
}
type TaskQueueForceRunRequest struct {
AppId []byte `protobuf:"bytes,1,opt,name=app_id" json:"app_id,omitempty"`
QueueName []byte `protobuf:"bytes,2,req,name=queue_name" json:"queue_name,omitempty"`
TaskName []byte `protobuf:"bytes,3,req,name=task_name" json:"task_name,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueForceRunRequest) Reset() { *m = TaskQueueForceRunRequest{} }
func (m *TaskQueueForceRunRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueueForceRunRequest) ProtoMessage() {}
func (m *TaskQueueForceRunRequest) GetAppId() []byte {
if m != nil {
return m.AppId
}
return nil
}
func (m *TaskQueueForceRunRequest) GetQueueName() []byte {
if m != nil {
return m.QueueName
}
return nil
}
func (m *TaskQueueForceRunRequest) GetTaskName() []byte {
if m != nil {
return m.TaskName
}
return nil
}
type TaskQueueForceRunResponse struct {
Result *TaskQueueServiceError_ErrorCode `protobuf:"varint,3,req,name=result,enum=appengine.TaskQueueServiceError_ErrorCode" json:"result,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueForceRunResponse) Reset() { *m = TaskQueueForceRunResponse{} }
func (m *TaskQueueForceRunResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueueForceRunResponse) ProtoMessage() {}
func (m *TaskQueueForceRunResponse) GetResult() TaskQueueServiceError_ErrorCode {
if m != nil && m.Result != nil {
return *m.Result
}
return TaskQueueServiceError_OK
}
type TaskQueueUpdateQueueRequest struct {
AppId []byte `protobuf:"bytes,1,opt,name=app_id" json:"app_id,omitempty"`
QueueName []byte `protobuf:"bytes,2,req,name=queue_name" json:"queue_name,omitempty"`
BucketRefillPerSecond *float64 `protobuf:"fixed64,3,req,name=bucket_refill_per_second" json:"bucket_refill_per_second,omitempty"`
BucketCapacity *int32 `protobuf:"varint,4,req,name=bucket_capacity" json:"bucket_capacity,omitempty"`
UserSpecifiedRate *string `protobuf:"bytes,5,opt,name=user_specified_rate" json:"user_specified_rate,omitempty"`
RetryParameters *TaskQueueRetryParameters `protobuf:"bytes,6,opt,name=retry_parameters" json:"retry_parameters,omitempty"`
MaxConcurrentRequests *int32 `protobuf:"varint,7,opt,name=max_concurrent_requests" json:"max_concurrent_requests,omitempty"`
Mode *TaskQueueMode_Mode `protobuf:"varint,8,opt,name=mode,enum=appengine.TaskQueueMode_Mode,def=0" json:"mode,omitempty"`
Acl *TaskQueueAcl `protobuf:"bytes,9,opt,name=acl" json:"acl,omitempty"`
HeaderOverride []*TaskQueueHttpHeader `protobuf:"bytes,10,rep,name=header_override" json:"header_override,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueUpdateQueueRequest) Reset() { *m = TaskQueueUpdateQueueRequest{} }
func (m *TaskQueueUpdateQueueRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueueUpdateQueueRequest) ProtoMessage() {}
const Default_TaskQueueUpdateQueueRequest_Mode TaskQueueMode_Mode = TaskQueueMode_PUSH
func (m *TaskQueueUpdateQueueRequest) GetAppId() []byte {
if m != nil {
return m.AppId
}
return nil
}
func (m *TaskQueueUpdateQueueRequest) GetQueueName() []byte {
if m != nil {
return m.QueueName
}
return nil
}
func (m *TaskQueueUpdateQueueRequest) GetBucketRefillPerSecond() float64 {
if m != nil && m.BucketRefillPerSecond != nil {
return *m.BucketRefillPerSecond
}
return 0
}
func (m *TaskQueueUpdateQueueRequest) GetBucketCapacity() int32 {
if m != nil && m.BucketCapacity != nil {
return *m.BucketCapacity
}
return 0
}
func (m *TaskQueueUpdateQueueRequest) GetUserSpecifiedRate() string {
if m != nil && m.UserSpecifiedRate != nil {
return *m.UserSpecifiedRate
}
return ""
}
func (m *TaskQueueUpdateQueueRequest) GetRetryParameters() *TaskQueueRetryParameters {
if m != nil {
return m.RetryParameters
}
return nil
}
func (m *TaskQueueUpdateQueueRequest) GetMaxConcurrentRequests() int32 {
if m != nil && m.MaxConcurrentRequests != nil {
return *m.MaxConcurrentRequests
}
return 0
}
func (m *TaskQueueUpdateQueueRequest) GetMode() TaskQueueMode_Mode {
if m != nil && m.Mode != nil {
return *m.Mode
}
return Default_TaskQueueUpdateQueueRequest_Mode
}
func (m *TaskQueueUpdateQueueRequest) GetAcl() *TaskQueueAcl {
if m != nil {
return m.Acl
}
return nil
}
func (m *TaskQueueUpdateQueueRequest) GetHeaderOverride() []*TaskQueueHttpHeader {
if m != nil {
return m.HeaderOverride
}
return nil
}
type TaskQueueUpdateQueueResponse struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueUpdateQueueResponse) Reset() { *m = TaskQueueUpdateQueueResponse{} }
func (m *TaskQueueUpdateQueueResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueueUpdateQueueResponse) ProtoMessage() {}
type TaskQueueFetchQueuesRequest struct {
AppId []byte `protobuf:"bytes,1,opt,name=app_id" json:"app_id,omitempty"`
MaxRows *int32 `protobuf:"varint,2,req,name=max_rows" json:"max_rows,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueFetchQueuesRequest) Reset() { *m = TaskQueueFetchQueuesRequest{} }
func (m *TaskQueueFetchQueuesRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueueFetchQueuesRequest) ProtoMessage() {}
func (m *TaskQueueFetchQueuesRequest) GetAppId() []byte {
if m != nil {
return m.AppId
}
return nil
}
func (m *TaskQueueFetchQueuesRequest) GetMaxRows() int32 {
if m != nil && m.MaxRows != nil {
return *m.MaxRows
}
return 0
}
type TaskQueueFetchQueuesResponse struct {
Queue []*TaskQueueFetchQueuesResponse_Queue `protobuf:"group,1,rep,name=Queue" json:"queue,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueFetchQueuesResponse) Reset() { *m = TaskQueueFetchQueuesResponse{} }
func (m *TaskQueueFetchQueuesResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueueFetchQueuesResponse) ProtoMessage() {}
func (m *TaskQueueFetchQueuesResponse) GetQueue() []*TaskQueueFetchQueuesResponse_Queue {
if m != nil {
return m.Queue
}
return nil
}
type TaskQueueFetchQueuesResponse_Queue struct {
QueueName []byte `protobuf:"bytes,2,req,name=queue_name" json:"queue_name,omitempty"`
BucketRefillPerSecond *float64 `protobuf:"fixed64,3,req,name=bucket_refill_per_second" json:"bucket_refill_per_second,omitempty"`
BucketCapacity *float64 `protobuf:"fixed64,4,req,name=bucket_capacity" json:"bucket_capacity,omitempty"`
UserSpecifiedRate *string `protobuf:"bytes,5,opt,name=user_specified_rate" json:"user_specified_rate,omitempty"`
Paused *bool `protobuf:"varint,6,req,name=paused,def=0" json:"paused,omitempty"`
RetryParameters *TaskQueueRetryParameters `protobuf:"bytes,7,opt,name=retry_parameters" json:"retry_parameters,omitempty"`
MaxConcurrentRequests *int32 `protobuf:"varint,8,opt,name=max_concurrent_requests" json:"max_concurrent_requests,omitempty"`
Mode *TaskQueueMode_Mode `protobuf:"varint,9,opt,name=mode,enum=appengine.TaskQueueMode_Mode,def=0" json:"mode,omitempty"`
Acl *TaskQueueAcl `protobuf:"bytes,10,opt,name=acl" json:"acl,omitempty"`
HeaderOverride []*TaskQueueHttpHeader `protobuf:"bytes,11,rep,name=header_override" json:"header_override,omitempty"`
CreatorName *string `protobuf:"bytes,12,opt,name=creator_name,def=apphosting" json:"creator_name,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueFetchQueuesResponse_Queue) Reset() { *m = TaskQueueFetchQueuesResponse_Queue{} }
func (m *TaskQueueFetchQueuesResponse_Queue) String() string { return proto.CompactTextString(m) }
func (*TaskQueueFetchQueuesResponse_Queue) ProtoMessage() {}
const Default_TaskQueueFetchQueuesResponse_Queue_Paused bool = false
const Default_TaskQueueFetchQueuesResponse_Queue_Mode TaskQueueMode_Mode = TaskQueueMode_PUSH
const Default_TaskQueueFetchQueuesResponse_Queue_CreatorName string = "apphosting"
func (m *TaskQueueFetchQueuesResponse_Queue) GetQueueName() []byte {
if m != nil {
return m.QueueName
}
return nil
}
func (m *TaskQueueFetchQueuesResponse_Queue) GetBucketRefillPerSecond() float64 {
if m != nil && m.BucketRefillPerSecond != nil {
return *m.BucketRefillPerSecond
}
return 0
}
func (m *TaskQueueFetchQueuesResponse_Queue) GetBucketCapacity() float64 {
if m != nil && m.BucketCapacity != nil {
return *m.BucketCapacity
}
return 0
}
func (m *TaskQueueFetchQueuesResponse_Queue) GetUserSpecifiedRate() string {
if m != nil && m.UserSpecifiedRate != nil {
return *m.UserSpecifiedRate
}
return ""
}
func (m *TaskQueueFetchQueuesResponse_Queue) GetPaused() bool {
if m != nil && m.Paused != nil {
return *m.Paused
}
return Default_TaskQueueFetchQueuesResponse_Queue_Paused
}
func (m *TaskQueueFetchQueuesResponse_Queue) GetRetryParameters() *TaskQueueRetryParameters {
if m != nil {
return m.RetryParameters
}
return nil
}
func (m *TaskQueueFetchQueuesResponse_Queue) GetMaxConcurrentRequests() int32 {
if m != nil && m.MaxConcurrentRequests != nil {
return *m.MaxConcurrentRequests
}
return 0
}
func (m *TaskQueueFetchQueuesResponse_Queue) GetMode() TaskQueueMode_Mode {
if m != nil && m.Mode != nil {
return *m.Mode
}
return Default_TaskQueueFetchQueuesResponse_Queue_Mode
}
func (m *TaskQueueFetchQueuesResponse_Queue) GetAcl() *TaskQueueAcl {
if m != nil {
return m.Acl
}
return nil
}
func (m *TaskQueueFetchQueuesResponse_Queue) GetHeaderOverride() []*TaskQueueHttpHeader {
if m != nil {
return m.HeaderOverride
}
return nil
}
func (m *TaskQueueFetchQueuesResponse_Queue) GetCreatorName() string {
if m != nil && m.CreatorName != nil {
return *m.CreatorName
}
return Default_TaskQueueFetchQueuesResponse_Queue_CreatorName
}
type TaskQueueFetchQueueStatsRequest struct {
AppId []byte `protobuf:"bytes,1,opt,name=app_id" json:"app_id,omitempty"`
QueueName [][]byte `protobuf:"bytes,2,rep,name=queue_name" json:"queue_name,omitempty"`
MaxNumTasks *int32 `protobuf:"varint,3,opt,name=max_num_tasks,def=0" json:"max_num_tasks,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueFetchQueueStatsRequest) Reset() { *m = TaskQueueFetchQueueStatsRequest{} }
func (m *TaskQueueFetchQueueStatsRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueueFetchQueueStatsRequest) ProtoMessage() {}
const Default_TaskQueueFetchQueueStatsRequest_MaxNumTasks int32 = 0
func (m *TaskQueueFetchQueueStatsRequest) GetAppId() []byte {
if m != nil {
return m.AppId
}
return nil
}
func (m *TaskQueueFetchQueueStatsRequest) GetQueueName() [][]byte {
if m != nil {
return m.QueueName
}
return nil
}
func (m *TaskQueueFetchQueueStatsRequest) GetMaxNumTasks() int32 {
if m != nil && m.MaxNumTasks != nil {
return *m.MaxNumTasks
}
return Default_TaskQueueFetchQueueStatsRequest_MaxNumTasks
}
type TaskQueueScannerQueueInfo struct {
ExecutedLastMinute *int64 `protobuf:"varint,1,req,name=executed_last_minute" json:"executed_last_minute,omitempty"`
ExecutedLastHour *int64 `protobuf:"varint,2,req,name=executed_last_hour" json:"executed_last_hour,omitempty"`
SamplingDurationSeconds *float64 `protobuf:"fixed64,3,req,name=sampling_duration_seconds" json:"sampling_duration_seconds,omitempty"`
RequestsInFlight *int32 `protobuf:"varint,4,opt,name=requests_in_flight" json:"requests_in_flight,omitempty"`
EnforcedRate *float64 `protobuf:"fixed64,5,opt,name=enforced_rate" json:"enforced_rate,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueScannerQueueInfo) Reset() { *m = TaskQueueScannerQueueInfo{} }
func (m *TaskQueueScannerQueueInfo) String() string { return proto.CompactTextString(m) }
func (*TaskQueueScannerQueueInfo) ProtoMessage() {}
func (m *TaskQueueScannerQueueInfo) GetExecutedLastMinute() int64 {
if m != nil && m.ExecutedLastMinute != nil {
return *m.ExecutedLastMinute
}
return 0
}
func (m *TaskQueueScannerQueueInfo) GetExecutedLastHour() int64 {
if m != nil && m.ExecutedLastHour != nil {
return *m.ExecutedLastHour
}
return 0
}
func (m *TaskQueueScannerQueueInfo) GetSamplingDurationSeconds() float64 {
if m != nil && m.SamplingDurationSeconds != nil {
return *m.SamplingDurationSeconds
}
return 0
}
func (m *TaskQueueScannerQueueInfo) GetRequestsInFlight() int32 {
if m != nil && m.RequestsInFlight != nil {
return *m.RequestsInFlight
}
return 0
}
func (m *TaskQueueScannerQueueInfo) GetEnforcedRate() float64 {
if m != nil && m.EnforcedRate != nil {
return *m.EnforcedRate
}
return 0
}
type TaskQueueFetchQueueStatsResponse struct {
Queuestats []*TaskQueueFetchQueueStatsResponse_QueueStats `protobuf:"group,1,rep,name=QueueStats" json:"queuestats,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueFetchQueueStatsResponse) Reset() { *m = TaskQueueFetchQueueStatsResponse{} }
func (m *TaskQueueFetchQueueStatsResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueueFetchQueueStatsResponse) ProtoMessage() {}
func (m *TaskQueueFetchQueueStatsResponse) GetQueuestats() []*TaskQueueFetchQueueStatsResponse_QueueStats {
if m != nil {
return m.Queuestats
}
return nil
}
type TaskQueueFetchQueueStatsResponse_QueueStats struct {
NumTasks *int32 `protobuf:"varint,2,req,name=num_tasks" json:"num_tasks,omitempty"`
OldestEtaUsec *int64 `protobuf:"varint,3,req,name=oldest_eta_usec" json:"oldest_eta_usec,omitempty"`
ScannerInfo *TaskQueueScannerQueueInfo `protobuf:"bytes,4,opt,name=scanner_info" json:"scanner_info,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueFetchQueueStatsResponse_QueueStats) Reset() {
*m = TaskQueueFetchQueueStatsResponse_QueueStats{}
}
func (m *TaskQueueFetchQueueStatsResponse_QueueStats) String() string {
return proto.CompactTextString(m)
}
func (*TaskQueueFetchQueueStatsResponse_QueueStats) ProtoMessage() {}
func (m *TaskQueueFetchQueueStatsResponse_QueueStats) GetNumTasks() int32 {
if m != nil && m.NumTasks != nil {
return *m.NumTasks
}
return 0
}
func (m *TaskQueueFetchQueueStatsResponse_QueueStats) GetOldestEtaUsec() int64 {
if m != nil && m.OldestEtaUsec != nil {
return *m.OldestEtaUsec
}
return 0
}
func (m *TaskQueueFetchQueueStatsResponse_QueueStats) GetScannerInfo() *TaskQueueScannerQueueInfo {
if m != nil {
return m.ScannerInfo
}
return nil
}
type TaskQueuePauseQueueRequest struct {
AppId []byte `protobuf:"bytes,1,req,name=app_id" json:"app_id,omitempty"`
QueueName []byte `protobuf:"bytes,2,req,name=queue_name" json:"queue_name,omitempty"`
Pause *bool `protobuf:"varint,3,req,name=pause" json:"pause,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueuePauseQueueRequest) Reset() { *m = TaskQueuePauseQueueRequest{} }
func (m *TaskQueuePauseQueueRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueuePauseQueueRequest) ProtoMessage() {}
func (m *TaskQueuePauseQueueRequest) GetAppId() []byte {
if m != nil {
return m.AppId
}
return nil
}
func (m *TaskQueuePauseQueueRequest) GetQueueName() []byte {
if m != nil {
return m.QueueName
}
return nil
}
func (m *TaskQueuePauseQueueRequest) GetPause() bool {
if m != nil && m.Pause != nil {
return *m.Pause
}
return false
}
type TaskQueuePauseQueueResponse struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueuePauseQueueResponse) Reset() { *m = TaskQueuePauseQueueResponse{} }
func (m *TaskQueuePauseQueueResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueuePauseQueueResponse) ProtoMessage() {}
type TaskQueuePurgeQueueRequest struct {
AppId []byte `protobuf:"bytes,1,opt,name=app_id" json:"app_id,omitempty"`
QueueName []byte `protobuf:"bytes,2,req,name=queue_name" json:"queue_name,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueuePurgeQueueRequest) Reset() { *m = TaskQueuePurgeQueueRequest{} }
func (m *TaskQueuePurgeQueueRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueuePurgeQueueRequest) ProtoMessage() {}
func (m *TaskQueuePurgeQueueRequest) GetAppId() []byte {
if m != nil {
return m.AppId
}
return nil
}
func (m *TaskQueuePurgeQueueRequest) GetQueueName() []byte {
if m != nil {
return m.QueueName
}
return nil
}
type TaskQueuePurgeQueueResponse struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueuePurgeQueueResponse) Reset() { *m = TaskQueuePurgeQueueResponse{} }
func (m *TaskQueuePurgeQueueResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueuePurgeQueueResponse) ProtoMessage() {}
type TaskQueueDeleteQueueRequest struct {
AppId []byte `protobuf:"bytes,1,req,name=app_id" json:"app_id,omitempty"`
QueueName []byte `protobuf:"bytes,2,req,name=queue_name" json:"queue_name,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueDeleteQueueRequest) Reset() { *m = TaskQueueDeleteQueueRequest{} }
func (m *TaskQueueDeleteQueueRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueueDeleteQueueRequest) ProtoMessage() {}
func (m *TaskQueueDeleteQueueRequest) GetAppId() []byte {
if m != nil {
return m.AppId
}
return nil
}
func (m *TaskQueueDeleteQueueRequest) GetQueueName() []byte {
if m != nil {
return m.QueueName
}
return nil
}
type TaskQueueDeleteQueueResponse struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueDeleteQueueResponse) Reset() { *m = TaskQueueDeleteQueueResponse{} }
func (m *TaskQueueDeleteQueueResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueueDeleteQueueResponse) ProtoMessage() {}
type TaskQueueDeleteGroupRequest struct {
AppId []byte `protobuf:"bytes,1,req,name=app_id" json:"app_id,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueDeleteGroupRequest) Reset() { *m = TaskQueueDeleteGroupRequest{} }
func (m *TaskQueueDeleteGroupRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueueDeleteGroupRequest) ProtoMessage() {}
func (m *TaskQueueDeleteGroupRequest) GetAppId() []byte {
if m != nil {
return m.AppId
}
return nil
}
type TaskQueueDeleteGroupResponse struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueDeleteGroupResponse) Reset() { *m = TaskQueueDeleteGroupResponse{} }
func (m *TaskQueueDeleteGroupResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueueDeleteGroupResponse) ProtoMessage() {}
type TaskQueueQueryTasksRequest struct {
AppId []byte `protobuf:"bytes,1,opt,name=app_id" json:"app_id,omitempty"`
QueueName []byte `protobuf:"bytes,2,req,name=queue_name" json:"queue_name,omitempty"`
StartTaskName []byte `protobuf:"bytes,3,opt,name=start_task_name" json:"start_task_name,omitempty"`
StartEtaUsec *int64 `protobuf:"varint,4,opt,name=start_eta_usec" json:"start_eta_usec,omitempty"`
StartTag []byte `protobuf:"bytes,6,opt,name=start_tag" json:"start_tag,omitempty"`
MaxRows *int32 `protobuf:"varint,5,opt,name=max_rows,def=1" json:"max_rows,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueQueryTasksRequest) Reset() { *m = TaskQueueQueryTasksRequest{} }
func (m *TaskQueueQueryTasksRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueueQueryTasksRequest) ProtoMessage() {}
const Default_TaskQueueQueryTasksRequest_MaxRows int32 = 1
func (m *TaskQueueQueryTasksRequest) GetAppId() []byte {
if m != nil {
return m.AppId
}
return nil
}
func (m *TaskQueueQueryTasksRequest) GetQueueName() []byte {
if m != nil {
return m.QueueName
}
return nil
}
func (m *TaskQueueQueryTasksRequest) GetStartTaskName() []byte {
if m != nil {
return m.StartTaskName
}
return nil
}
func (m *TaskQueueQueryTasksRequest) GetStartEtaUsec() int64 {
if m != nil && m.StartEtaUsec != nil {
return *m.StartEtaUsec
}
return 0
}
func (m *TaskQueueQueryTasksRequest) GetStartTag() []byte {
if m != nil {
return m.StartTag
}
return nil
}
func (m *TaskQueueQueryTasksRequest) GetMaxRows() int32 {
if m != nil && m.MaxRows != nil {
return *m.MaxRows
}
return Default_TaskQueueQueryTasksRequest_MaxRows
}
type TaskQueueQueryTasksResponse struct {
Task []*TaskQueueQueryTasksResponse_Task `protobuf:"group,1,rep,name=Task" json:"task,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueQueryTasksResponse) Reset() { *m = TaskQueueQueryTasksResponse{} }
func (m *TaskQueueQueryTasksResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueueQueryTasksResponse) ProtoMessage() {}
func (m *TaskQueueQueryTasksResponse) GetTask() []*TaskQueueQueryTasksResponse_Task {
if m != nil {
return m.Task
}
return nil
}
type TaskQueueQueryTasksResponse_Task struct {
TaskName []byte `protobuf:"bytes,2,req,name=task_name" json:"task_name,omitempty"`
EtaUsec *int64 `protobuf:"varint,3,req,name=eta_usec" json:"eta_usec,omitempty"`
Url []byte `protobuf:"bytes,4,opt,name=url" json:"url,omitempty"`
Method *TaskQueueQueryTasksResponse_Task_RequestMethod `protobuf:"varint,5,opt,name=method,enum=appengine.TaskQueueQueryTasksResponse_Task_RequestMethod" json:"method,omitempty"`
RetryCount *int32 `protobuf:"varint,6,opt,name=retry_count,def=0" json:"retry_count,omitempty"`
Header []*TaskQueueQueryTasksResponse_Task_Header `protobuf:"group,7,rep,name=Header" json:"header,omitempty"`
BodySize *int32 `protobuf:"varint,10,opt,name=body_size" json:"body_size,omitempty"`
Body []byte `protobuf:"bytes,11,opt,name=body" json:"body,omitempty"`
CreationTimeUsec *int64 `protobuf:"varint,12,req,name=creation_time_usec" json:"creation_time_usec,omitempty"`
Crontimetable *TaskQueueQueryTasksResponse_Task_CronTimetable `protobuf:"group,13,opt,name=CronTimetable" json:"crontimetable,omitempty"`
Runlog *TaskQueueQueryTasksResponse_Task_RunLog `protobuf:"group,16,opt,name=RunLog" json:"runlog,omitempty"`
Description []byte `protobuf:"bytes,21,opt,name=description" json:"description,omitempty"`
Payload *TaskPayload `protobuf:"bytes,22,opt,name=payload" json:"payload,omitempty"`
RetryParameters *TaskQueueRetryParameters `protobuf:"bytes,23,opt,name=retry_parameters" json:"retry_parameters,omitempty"`
FirstTryUsec *int64 `protobuf:"varint,24,opt,name=first_try_usec" json:"first_try_usec,omitempty"`
Tag []byte `protobuf:"bytes,25,opt,name=tag" json:"tag,omitempty"`
ExecutionCount *int32 `protobuf:"varint,26,opt,name=execution_count,def=0" json:"execution_count,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueQueryTasksResponse_Task) Reset() { *m = TaskQueueQueryTasksResponse_Task{} }
func (m *TaskQueueQueryTasksResponse_Task) String() string { return proto.CompactTextString(m) }
func (*TaskQueueQueryTasksResponse_Task) ProtoMessage() {}
const Default_TaskQueueQueryTasksResponse_Task_RetryCount int32 = 0
const Default_TaskQueueQueryTasksResponse_Task_ExecutionCount int32 = 0
func (m *TaskQueueQueryTasksResponse_Task) GetTaskName() []byte {
if m != nil {
return m.TaskName
}
return nil
}
func (m *TaskQueueQueryTasksResponse_Task) GetEtaUsec() int64 {
if m != nil && m.EtaUsec != nil {
return *m.EtaUsec
}
return 0
}
func (m *TaskQueueQueryTasksResponse_Task) GetUrl() []byte {
if m != nil {
return m.Url
}
return nil
}
func (m *TaskQueueQueryTasksResponse_Task) GetMethod() TaskQueueQueryTasksResponse_Task_RequestMethod {
if m != nil && m.Method != nil {
return *m.Method
}
return TaskQueueQueryTasksResponse_Task_GET
}
func (m *TaskQueueQueryTasksResponse_Task) GetRetryCount() int32 {
if m != nil && m.RetryCount != nil {
return *m.RetryCount
}
return Default_TaskQueueQueryTasksResponse_Task_RetryCount
}
func (m *TaskQueueQueryTasksResponse_Task) GetHeader() []*TaskQueueQueryTasksResponse_Task_Header {
if m != nil {
return m.Header
}
return nil
}
func (m *TaskQueueQueryTasksResponse_Task) GetBodySize() int32 {
if m != nil && m.BodySize != nil {
return *m.BodySize
}
return 0
}
func (m *TaskQueueQueryTasksResponse_Task) GetBody() []byte {
if m != nil {
return m.Body
}
return nil
}
func (m *TaskQueueQueryTasksResponse_Task) GetCreationTimeUsec() int64 {
if m != nil && m.CreationTimeUsec != nil {
return *m.CreationTimeUsec
}
return 0
}
func (m *TaskQueueQueryTasksResponse_Task) GetCrontimetable() *TaskQueueQueryTasksResponse_Task_CronTimetable {
if m != nil {
return m.Crontimetable
}
return nil
}
func (m *TaskQueueQueryTasksResponse_Task) GetRunlog() *TaskQueueQueryTasksResponse_Task_RunLog {
if m != nil {
return m.Runlog
}
return nil
}
func (m *TaskQueueQueryTasksResponse_Task) GetDescription() []byte {
if m != nil {
return m.Description
}
return nil
}
func (m *TaskQueueQueryTasksResponse_Task) GetPayload() *TaskPayload {
if m != nil {
return m.Payload
}
return nil
}
func (m *TaskQueueQueryTasksResponse_Task) GetRetryParameters() *TaskQueueRetryParameters {
if m != nil {
return m.RetryParameters
}
return nil
}
func (m *TaskQueueQueryTasksResponse_Task) GetFirstTryUsec() int64 {
if m != nil && m.FirstTryUsec != nil {
return *m.FirstTryUsec
}
return 0
}
func (m *TaskQueueQueryTasksResponse_Task) GetTag() []byte {
if m != nil {
return m.Tag
}
return nil
}
func (m *TaskQueueQueryTasksResponse_Task) GetExecutionCount() int32 {
if m != nil && m.ExecutionCount != nil {
return *m.ExecutionCount
}
return Default_TaskQueueQueryTasksResponse_Task_ExecutionCount
}
type TaskQueueQueryTasksResponse_Task_Header struct {
Key []byte `protobuf:"bytes,8,req,name=key" json:"key,omitempty"`
Value []byte `protobuf:"bytes,9,req,name=value" json:"value,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueQueryTasksResponse_Task_Header) Reset() {
*m = TaskQueueQueryTasksResponse_Task_Header{}
}
func (m *TaskQueueQueryTasksResponse_Task_Header) String() string { return proto.CompactTextString(m) }
func (*TaskQueueQueryTasksResponse_Task_Header) ProtoMessage() {}
func (m *TaskQueueQueryTasksResponse_Task_Header) GetKey() []byte {
if m != nil {
return m.Key
}
return nil
}
func (m *TaskQueueQueryTasksResponse_Task_Header) GetValue() []byte {
if m != nil {
return m.Value
}
return nil
}
type TaskQueueQueryTasksResponse_Task_CronTimetable struct {
Schedule []byte `protobuf:"bytes,14,req,name=schedule" json:"schedule,omitempty"`
Timezone []byte `protobuf:"bytes,15,req,name=timezone" json:"timezone,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueQueryTasksResponse_Task_CronTimetable) Reset() {
*m = TaskQueueQueryTasksResponse_Task_CronTimetable{}
}
func (m *TaskQueueQueryTasksResponse_Task_CronTimetable) String() string {
return proto.CompactTextString(m)
}
func (*TaskQueueQueryTasksResponse_Task_CronTimetable) ProtoMessage() {}
func (m *TaskQueueQueryTasksResponse_Task_CronTimetable) GetSchedule() []byte {
if m != nil {
return m.Schedule
}
return nil
}
func (m *TaskQueueQueryTasksResponse_Task_CronTimetable) GetTimezone() []byte {
if m != nil {
return m.Timezone
}
return nil
}
type TaskQueueQueryTasksResponse_Task_RunLog struct {
DispatchedUsec *int64 `protobuf:"varint,17,req,name=dispatched_usec" json:"dispatched_usec,omitempty"`
LagUsec *int64 `protobuf:"varint,18,req,name=lag_usec" json:"lag_usec,omitempty"`
ElapsedUsec *int64 `protobuf:"varint,19,req,name=elapsed_usec" json:"elapsed_usec,omitempty"`
ResponseCode *int64 `protobuf:"varint,20,opt,name=response_code" json:"response_code,omitempty"`
RetryReason *string `protobuf:"bytes,27,opt,name=retry_reason" json:"retry_reason,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueQueryTasksResponse_Task_RunLog) Reset() {
*m = TaskQueueQueryTasksResponse_Task_RunLog{}
}
func (m *TaskQueueQueryTasksResponse_Task_RunLog) String() string { return proto.CompactTextString(m) }
func (*TaskQueueQueryTasksResponse_Task_RunLog) ProtoMessage() {}
func (m *TaskQueueQueryTasksResponse_Task_RunLog) GetDispatchedUsec() int64 {
if m != nil && m.DispatchedUsec != nil {
return *m.DispatchedUsec
}
return 0
}
func (m *TaskQueueQueryTasksResponse_Task_RunLog) GetLagUsec() int64 {
if m != nil && m.LagUsec != nil {
return *m.LagUsec
}
return 0
}
func (m *TaskQueueQueryTasksResponse_Task_RunLog) GetElapsedUsec() int64 {
if m != nil && m.ElapsedUsec != nil {
return *m.ElapsedUsec
}
return 0
}
func (m *TaskQueueQueryTasksResponse_Task_RunLog) GetResponseCode() int64 {
if m != nil && m.ResponseCode != nil {
return *m.ResponseCode
}
return 0
}
func (m *TaskQueueQueryTasksResponse_Task_RunLog) GetRetryReason() string {
if m != nil && m.RetryReason != nil {
return *m.RetryReason
}
return ""
}
type TaskQueueFetchTaskRequest struct {
AppId []byte `protobuf:"bytes,1,opt,name=app_id" json:"app_id,omitempty"`
QueueName []byte `protobuf:"bytes,2,req,name=queue_name" json:"queue_name,omitempty"`
TaskName []byte `protobuf:"bytes,3,req,name=task_name" json:"task_name,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueFetchTaskRequest) Reset() { *m = TaskQueueFetchTaskRequest{} }
func (m *TaskQueueFetchTaskRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueueFetchTaskRequest) ProtoMessage() {}
func (m *TaskQueueFetchTaskRequest) GetAppId() []byte {
if m != nil {
return m.AppId
}
return nil
}
func (m *TaskQueueFetchTaskRequest) GetQueueName() []byte {
if m != nil {
return m.QueueName
}
return nil
}
func (m *TaskQueueFetchTaskRequest) GetTaskName() []byte {
if m != nil {
return m.TaskName
}
return nil
}
type TaskQueueFetchTaskResponse struct {
Task *TaskQueueQueryTasksResponse `protobuf:"bytes,1,req,name=task" json:"task,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueFetchTaskResponse) Reset() { *m = TaskQueueFetchTaskResponse{} }
func (m *TaskQueueFetchTaskResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueueFetchTaskResponse) ProtoMessage() {}
func (m *TaskQueueFetchTaskResponse) GetTask() *TaskQueueQueryTasksResponse {
if m != nil {
return m.Task
}
return nil
}
type TaskQueueUpdateStorageLimitRequest struct {
AppId []byte `protobuf:"bytes,1,req,name=app_id" json:"app_id,omitempty"`
Limit *int64 `protobuf:"varint,2,req,name=limit" json:"limit,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueUpdateStorageLimitRequest) Reset() { *m = TaskQueueUpdateStorageLimitRequest{} }
func (m *TaskQueueUpdateStorageLimitRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueueUpdateStorageLimitRequest) ProtoMessage() {}
func (m *TaskQueueUpdateStorageLimitRequest) GetAppId() []byte {
if m != nil {
return m.AppId
}
return nil
}
func (m *TaskQueueUpdateStorageLimitRequest) GetLimit() int64 {
if m != nil && m.Limit != nil {
return *m.Limit
}
return 0
}
type TaskQueueUpdateStorageLimitResponse struct {
NewLimit *int64 `protobuf:"varint,1,req,name=new_limit" json:"new_limit,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueUpdateStorageLimitResponse) Reset() { *m = TaskQueueUpdateStorageLimitResponse{} }
func (m *TaskQueueUpdateStorageLimitResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueueUpdateStorageLimitResponse) ProtoMessage() {}
func (m *TaskQueueUpdateStorageLimitResponse) GetNewLimit() int64 {
if m != nil && m.NewLimit != nil {
return *m.NewLimit
}
return 0
}
type TaskQueueQueryAndOwnTasksRequest struct {
QueueName []byte `protobuf:"bytes,1,req,name=queue_name" json:"queue_name,omitempty"`
LeaseSeconds *float64 `protobuf:"fixed64,2,req,name=lease_seconds" json:"lease_seconds,omitempty"`
MaxTasks *int64 `protobuf:"varint,3,req,name=max_tasks" json:"max_tasks,omitempty"`
GroupByTag *bool `protobuf:"varint,4,opt,name=group_by_tag,def=0" json:"group_by_tag,omitempty"`
Tag []byte `protobuf:"bytes,5,opt,name=tag" json:"tag,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueQueryAndOwnTasksRequest) Reset() { *m = TaskQueueQueryAndOwnTasksRequest{} }
func (m *TaskQueueQueryAndOwnTasksRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueueQueryAndOwnTasksRequest) ProtoMessage() {}
const Default_TaskQueueQueryAndOwnTasksRequest_GroupByTag bool = false
func (m *TaskQueueQueryAndOwnTasksRequest) GetQueueName() []byte {
if m != nil {
return m.QueueName
}
return nil
}
func (m *TaskQueueQueryAndOwnTasksRequest) GetLeaseSeconds() float64 {
if m != nil && m.LeaseSeconds != nil {
return *m.LeaseSeconds
}
return 0
}
func (m *TaskQueueQueryAndOwnTasksRequest) GetMaxTasks() int64 {
if m != nil && m.MaxTasks != nil {
return *m.MaxTasks
}
return 0
}
func (m *TaskQueueQueryAndOwnTasksRequest) GetGroupByTag() bool {
if m != nil && m.GroupByTag != nil {
return *m.GroupByTag
}
return Default_TaskQueueQueryAndOwnTasksRequest_GroupByTag
}
func (m *TaskQueueQueryAndOwnTasksRequest) GetTag() []byte {
if m != nil {
return m.Tag
}
return nil
}
type TaskQueueQueryAndOwnTasksResponse struct {
Task []*TaskQueueQueryAndOwnTasksResponse_Task `protobuf:"group,1,rep,name=Task" json:"task,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueQueryAndOwnTasksResponse) Reset() { *m = TaskQueueQueryAndOwnTasksResponse{} }
func (m *TaskQueueQueryAndOwnTasksResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueueQueryAndOwnTasksResponse) ProtoMessage() {}
func (m *TaskQueueQueryAndOwnTasksResponse) GetTask() []*TaskQueueQueryAndOwnTasksResponse_Task {
if m != nil {
return m.Task
}
return nil
}
type TaskQueueQueryAndOwnTasksResponse_Task struct {
TaskName []byte `protobuf:"bytes,2,req,name=task_name" json:"task_name,omitempty"`
EtaUsec *int64 `protobuf:"varint,3,req,name=eta_usec" json:"eta_usec,omitempty"`
RetryCount *int32 `protobuf:"varint,4,opt,name=retry_count,def=0" json:"retry_count,omitempty"`
Body []byte `protobuf:"bytes,5,opt,name=body" json:"body,omitempty"`
Tag []byte `protobuf:"bytes,6,opt,name=tag" json:"tag,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueQueryAndOwnTasksResponse_Task) Reset() {
*m = TaskQueueQueryAndOwnTasksResponse_Task{}
}
func (m *TaskQueueQueryAndOwnTasksResponse_Task) String() string { return proto.CompactTextString(m) }
func (*TaskQueueQueryAndOwnTasksResponse_Task) ProtoMessage() {}
const Default_TaskQueueQueryAndOwnTasksResponse_Task_RetryCount int32 = 0
func (m *TaskQueueQueryAndOwnTasksResponse_Task) GetTaskName() []byte {
if m != nil {
return m.TaskName
}
return nil
}
func (m *TaskQueueQueryAndOwnTasksResponse_Task) GetEtaUsec() int64 {
if m != nil && m.EtaUsec != nil {
return *m.EtaUsec
}
return 0
}
func (m *TaskQueueQueryAndOwnTasksResponse_Task) GetRetryCount() int32 {
if m != nil && m.RetryCount != nil {
return *m.RetryCount
}
return Default_TaskQueueQueryAndOwnTasksResponse_Task_RetryCount
}
func (m *TaskQueueQueryAndOwnTasksResponse_Task) GetBody() []byte {
if m != nil {
return m.Body
}
return nil
}
func (m *TaskQueueQueryAndOwnTasksResponse_Task) GetTag() []byte {
if m != nil {
return m.Tag
}
return nil
}
type TaskQueueModifyTaskLeaseRequest struct {
QueueName []byte `protobuf:"bytes,1,req,name=queue_name" json:"queue_name,omitempty"`
TaskName []byte `protobuf:"bytes,2,req,name=task_name" json:"task_name,omitempty"`
EtaUsec *int64 `protobuf:"varint,3,req,name=eta_usec" json:"eta_usec,omitempty"`
LeaseSeconds *float64 `protobuf:"fixed64,4,req,name=lease_seconds" json:"lease_seconds,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueModifyTaskLeaseRequest) Reset() { *m = TaskQueueModifyTaskLeaseRequest{} }
func (m *TaskQueueModifyTaskLeaseRequest) String() string { return proto.CompactTextString(m) }
func (*TaskQueueModifyTaskLeaseRequest) ProtoMessage() {}
func (m *TaskQueueModifyTaskLeaseRequest) GetQueueName() []byte {
if m != nil {
return m.QueueName
}
return nil
}
func (m *TaskQueueModifyTaskLeaseRequest) GetTaskName() []byte {
if m != nil {
return m.TaskName
}
return nil
}
func (m *TaskQueueModifyTaskLeaseRequest) GetEtaUsec() int64 {
if m != nil && m.EtaUsec != nil {
return *m.EtaUsec
}
return 0
}
func (m *TaskQueueModifyTaskLeaseRequest) GetLeaseSeconds() float64 {
if m != nil && m.LeaseSeconds != nil {
return *m.LeaseSeconds
}
return 0
}
type TaskQueueModifyTaskLeaseResponse struct {
UpdatedEtaUsec *int64 `protobuf:"varint,1,req,name=updated_eta_usec" json:"updated_eta_usec,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *TaskQueueModifyTaskLeaseResponse) Reset() { *m = TaskQueueModifyTaskLeaseResponse{} }
func (m *TaskQueueModifyTaskLeaseResponse) String() string { return proto.CompactTextString(m) }
func (*TaskQueueModifyTaskLeaseResponse) ProtoMessage() {}
func (m *TaskQueueModifyTaskLeaseResponse) GetUpdatedEtaUsec() int64 {
if m != nil && m.UpdatedEtaUsec != nil {
return *m.UpdatedEtaUsec
}
return 0
}
func init() {
}
================================================
FILE: vendor/google.golang.org/appengine/internal/taskqueue/taskqueue_service.proto
================================================
syntax = "proto2";
option go_package = "taskqueue";
import "google.golang.org/appengine/internal/datastore/datastore_v3.proto";
package appengine;
message TaskQueueServiceError {
enum ErrorCode {
OK = 0;
UNKNOWN_QUEUE = 1;
TRANSIENT_ERROR = 2;
INTERNAL_ERROR = 3;
TASK_TOO_LARGE = 4;
INVALID_TASK_NAME = 5;
INVALID_QUEUE_NAME = 6;
INVALID_URL = 7;
INVALID_QUEUE_RATE = 8;
PERMISSION_DENIED = 9;
TASK_ALREADY_EXISTS = 10;
TOMBSTONED_TASK = 11;
INVALID_ETA = 12;
INVALID_REQUEST = 13;
UNKNOWN_TASK = 14;
TOMBSTONED_QUEUE = 15;
DUPLICATE_TASK_NAME = 16;
SKIPPED = 17;
TOO_MANY_TASKS = 18;
INVALID_PAYLOAD = 19;
INVALID_RETRY_PARAMETERS = 20;
INVALID_QUEUE_MODE = 21;
ACL_LOOKUP_ERROR = 22;
TRANSACTIONAL_REQUEST_TOO_LARGE = 23;
INCORRECT_CREATOR_NAME = 24;
TASK_LEASE_EXPIRED = 25;
QUEUE_PAUSED = 26;
INVALID_TAG = 27;
// Reserved range for the Datastore error codes.
// Original Datastore error code is shifted by DATASTORE_ERROR offset.
DATASTORE_ERROR = 10000;
}
}
message TaskPayload {
extensions 10 to max;
option message_set_wire_format = true;
}
message TaskQueueRetryParameters {
optional int32 retry_limit = 1;
optional int64 age_limit_sec = 2;
optional double min_backoff_sec = 3 [default = 0.1];
optional double max_backoff_sec = 4 [default = 3600];
optional int32 max_doublings = 5 [default = 16];
}
message TaskQueueAcl {
repeated bytes user_email = 1;
repeated bytes writer_email = 2;
}
message TaskQueueHttpHeader {
required bytes key = 1;
required bytes value = 2;
}
message TaskQueueMode {
enum Mode {
PUSH = 0;
PULL = 1;
}
}
message TaskQueueAddRequest {
required bytes queue_name = 1;
required bytes task_name = 2;
required int64 eta_usec = 3;
enum RequestMethod {
GET = 1;
POST = 2;
HEAD = 3;
PUT = 4;
DELETE = 5;
}
optional RequestMethod method = 5 [default=POST];
optional bytes url = 4;
repeated group Header = 6 {
required bytes key = 7;
required bytes value = 8;
}
optional bytes body = 9 [ctype=CORD];
optional Transaction transaction = 10;
optional bytes app_id = 11;
optional group CronTimetable = 12 {
required bytes schedule = 13;
required bytes timezone = 14;
}
optional bytes description = 15;
optional TaskPayload payload = 16;
optional TaskQueueRetryParameters retry_parameters = 17;
optional TaskQueueMode.Mode mode = 18 [default=PUSH];
optional bytes tag = 19;
}
message TaskQueueAddResponse {
optional bytes chosen_task_name = 1;
}
message TaskQueueBulkAddRequest {
repeated TaskQueueAddRequest add_request = 1;
}
message TaskQueueBulkAddResponse {
repeated group TaskResult = 1 {
required TaskQueueServiceError.ErrorCode result = 2;
optional bytes chosen_task_name = 3;
}
}
message TaskQueueDeleteRequest {
required bytes queue_name = 1;
repeated bytes task_name = 2;
optional bytes app_id = 3;
}
message TaskQueueDeleteResponse {
repeated TaskQueueServiceError.ErrorCode result = 3;
}
message TaskQueueForceRunRequest {
optional bytes app_id = 1;
required bytes queue_name = 2;
required bytes task_name = 3;
}
message TaskQueueForceRunResponse {
required TaskQueueServiceError.ErrorCode result = 3;
}
message TaskQueueUpdateQueueRequest {
optional bytes app_id = 1;
required bytes queue_name = 2;
required double bucket_refill_per_second = 3;
required int32 bucket_capacity = 4;
optional string user_specified_rate = 5;
optional TaskQueueRetryParameters retry_parameters = 6;
optional int32 max_concurrent_requests = 7;
optional TaskQueueMode.Mode mode = 8 [default = PUSH];
optional TaskQueueAcl acl = 9;
repeated TaskQueueHttpHeader header_override = 10;
}
message TaskQueueUpdateQueueResponse {
}
message TaskQueueFetchQueuesRequest {
optional bytes app_id = 1;
required int32 max_rows = 2;
}
message TaskQueueFetchQueuesResponse {
repeated group Queue = 1 {
required bytes queue_name = 2;
required double bucket_refill_per_second = 3;
required double bucket_capacity = 4;
optional string user_specified_rate = 5;
required bool paused = 6 [default=false];
optional TaskQueueRetryParameters retry_parameters = 7;
optional int32 max_concurrent_requests = 8;
optional TaskQueueMode.Mode mode = 9 [default = PUSH];
optional TaskQueueAcl acl = 10;
repeated TaskQueueHttpHeader header_override = 11;
optional string creator_name = 12 [ctype=CORD, default="apphosting"];
}
}
message TaskQueueFetchQueueStatsRequest {
optional bytes app_id = 1;
repeated bytes queue_name = 2;
optional int32 max_num_tasks = 3 [default = 0];
}
message TaskQueueScannerQueueInfo {
required int64 executed_last_minute = 1;
required int64 executed_last_hour = 2;
required double sampling_duration_seconds = 3;
optional int32 requests_in_flight = 4;
optional double enforced_rate = 5;
}
message TaskQueueFetchQueueStatsResponse {
repeated group QueueStats = 1 {
required int32 num_tasks = 2;
required int64 oldest_eta_usec = 3;
optional TaskQueueScannerQueueInfo scanner_info = 4;
}
}
message TaskQueuePauseQueueRequest {
required bytes app_id = 1;
required bytes queue_name = 2;
required bool pause = 3;
}
message TaskQueuePauseQueueResponse {
}
message TaskQueuePurgeQueueRequest {
optional bytes app_id = 1;
required bytes queue_name = 2;
}
message TaskQueuePurgeQueueResponse {
}
message TaskQueueDeleteQueueRequest {
required bytes app_id = 1;
required bytes queue_name = 2;
}
message TaskQueueDeleteQueueResponse {
}
message TaskQueueDeleteGroupRequest {
required bytes app_id = 1;
}
message TaskQueueDeleteGroupResponse {
}
message TaskQueueQueryTasksRequest {
optional bytes app_id = 1;
required bytes queue_name = 2;
optional bytes start_task_name = 3;
optional int64 start_eta_usec = 4;
optional bytes start_tag = 6;
optional int32 max_rows = 5 [default = 1];
}
message TaskQueueQueryTasksResponse {
repeated group Task = 1 {
required bytes task_name = 2;
required int64 eta_usec = 3;
optional bytes url = 4;
enum RequestMethod {
GET = 1;
POST = 2;
HEAD = 3;
PUT = 4;
DELETE = 5;
}
optional RequestMethod method = 5;
optional int32 retry_count = 6 [default=0];
repeated group Header = 7 {
required bytes key = 8;
required bytes value = 9;
}
optional int32 body_size = 10;
optional bytes body = 11 [ctype=CORD];
required int64 creation_time_usec = 12;
optional group CronTimetable = 13 {
required bytes schedule = 14;
required bytes timezone = 15;
}
optional group RunLog = 16 {
required int64 dispatched_usec = 17;
required int64 lag_usec = 18;
required int64 elapsed_usec = 19;
optional int64 response_code = 20;
optional string retry_reason = 27;
}
optional bytes description = 21;
optional TaskPayload payload = 22;
optional TaskQueueRetryParameters retry_parameters = 23;
optional int64 first_try_usec = 24;
optional bytes tag = 25;
optional int32 execution_count = 26 [default=0];
}
}
message TaskQueueFetchTaskRequest {
optional bytes app_id = 1;
required bytes queue_name = 2;
required bytes task_name = 3;
}
message TaskQueueFetchTaskResponse {
required TaskQueueQueryTasksResponse task = 1;
}
message TaskQueueUpdateStorageLimitRequest {
required bytes app_id = 1;
required int64 limit = 2;
}
message TaskQueueUpdateStorageLimitResponse {
required int64 new_limit = 1;
}
message TaskQueueQueryAndOwnTasksRequest {
required bytes queue_name = 1;
required double lease_seconds = 2;
required int64 max_tasks = 3;
optional bool group_by_tag = 4 [default=false];
optional bytes tag = 5;
}
message TaskQueueQueryAndOwnTasksResponse {
repeated group Task = 1 {
required bytes task_name = 2;
required int64 eta_usec = 3;
optional int32 retry_count = 4 [default=0];
optional bytes body = 5 [ctype=CORD];
optional bytes tag = 6;
}
}
message TaskQueueModifyTaskLeaseRequest {
required bytes queue_name = 1;
required bytes task_name = 2;
required int64 eta_usec = 3;
required double lease_seconds = 4;
}
message TaskQueueModifyTaskLeaseResponse {
required int64 updated_eta_usec = 1;
}
================================================
FILE: vendor/google.golang.org/appengine/internal/transaction.go
================================================
// Copyright 2014 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
package internal
// This file implements hooks for applying datastore transactions.
import (
"errors"
"reflect"
"github.com/golang/protobuf/proto"
netcontext "golang.org/x/net/context"
basepb "google.golang.org/appengine/internal/base"
pb "google.golang.org/appengine/internal/datastore"
)
var transactionSetters = make(map[reflect.Type]reflect.Value)
// RegisterTransactionSetter registers a function that sets transaction information
// in a protocol buffer message. f should be a function with two arguments,
// the first being a protocol buffer type, and the second being *datastore.Transaction.
func RegisterTransactionSetter(f interface{}) {
v := reflect.ValueOf(f)
transactionSetters[v.Type().In(0)] = v
}
// applyTransaction applies the transaction t to message pb
// by using the relevant setter passed to RegisterTransactionSetter.
func applyTransaction(pb proto.Message, t *pb.Transaction) {
v := reflect.ValueOf(pb)
if f, ok := transactionSetters[v.Type()]; ok {
f.Call([]reflect.Value{v, reflect.ValueOf(t)})
}
}
var transactionKey = "used for *Transaction"
func transactionFromContext(ctx netcontext.Context) *transaction {
t, _ := ctx.Value(&transactionKey).(*transaction)
return t
}
func withTransaction(ctx netcontext.Context, t *transaction) netcontext.Context {
return netcontext.WithValue(ctx, &transactionKey, t)
}
type transaction struct {
transaction pb.Transaction
finished bool
}
var ErrConcurrentTransaction = errors.New("internal: concurrent transaction")
func RunTransactionOnce(c netcontext.Context, f func(netcontext.Context) error, xg bool) error {
if transactionFromContext(c) != nil {
return errors.New("nested transactions are not supported")
}
// Begin the transaction.
t := &transaction{}
req := &pb.BeginTransactionRequest{
App: proto.String(FullyQualifiedAppID(c)),
}
if xg {
req.AllowMultipleEg = proto.Bool(true)
}
if err := Call(c, "datastore_v3", "BeginTransaction", req, &t.transaction); err != nil {
return err
}
// Call f, rolling back the transaction if f returns a non-nil error, or panics.
// The panic is not recovered.
defer func() {
if t.finished {
return
}
t.finished = true
// Ignore the error return value, since we are already returning a non-nil
// error (or we're panicking).
Call(c, "datastore_v3", "Rollback", &t.transaction, &basepb.VoidProto{})
}()
if err := f(withTransaction(c, t)); err != nil {
return err
}
t.finished = true
// Commit the transaction.
res := &pb.CommitResponse{}
err := Call(c, "datastore_v3", "Commit", &t.transaction, res)
if ae, ok := err.(*APIError); ok {
/* TODO: restore this conditional
if appengine.IsDevAppServer() {
*/
// The Python Dev AppServer raises an ApplicationError with error code 2 (which is
// Error.CONCURRENT_TRANSACTION) and message "Concurrency exception.".
if ae.Code == int32(pb.Error_BAD_REQUEST) && ae.Detail == "ApplicationError: 2 Concurrency exception." {
return ErrConcurrentTransaction
}
if ae.Code == int32(pb.Error_CONCURRENT_TRANSACTION) {
return ErrConcurrentTransaction
}
}
return err
}
================================================
FILE: vendor/google.golang.org/appengine/internal/urlfetch/urlfetch_service.pb.go
================================================
// Code generated by protoc-gen-go.
// source: google.golang.org/appengine/internal/urlfetch/urlfetch_service.proto
// DO NOT EDIT!
/*
Package urlfetch is a generated protocol buffer package.
It is generated from these files:
google.golang.org/appengine/internal/urlfetch/urlfetch_service.proto
It has these top-level messages:
URLFetchServiceError
URLFetchRequest
URLFetchResponse
*/
package urlfetch
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type URLFetchServiceError_ErrorCode int32
const (
URLFetchServiceError_OK URLFetchServiceError_ErrorCode = 0
URLFetchServiceError_INVALID_URL URLFetchServiceError_ErrorCode = 1
URLFetchServiceError_FETCH_ERROR URLFetchServiceError_ErrorCode = 2
URLFetchServiceError_UNSPECIFIED_ERROR URLFetchServiceError_ErrorCode = 3
URLFetchServiceError_RESPONSE_TOO_LARGE URLFetchServiceError_ErrorCode = 4
URLFetchServiceError_DEADLINE_EXCEEDED URLFetchServiceError_ErrorCode = 5
URLFetchServiceError_SSL_CERTIFICATE_ERROR URLFetchServiceError_ErrorCode = 6
URLFetchServiceError_DNS_ERROR URLFetchServiceError_ErrorCode = 7
URLFetchServiceError_CLOSED URLFetchServiceError_ErrorCode = 8
URLFetchServiceError_INTERNAL_TRANSIENT_ERROR URLFetchServiceError_ErrorCode = 9
URLFetchServiceError_TOO_MANY_REDIRECTS URLFetchServiceError_ErrorCode = 10
URLFetchServiceError_MALFORMED_REPLY URLFetchServiceError_ErrorCode = 11
URLFetchServiceError_CONNECTION_ERROR URLFetchServiceError_ErrorCode = 12
)
var URLFetchServiceError_ErrorCode_name = map[int32]string{
0: "OK",
1: "INVALID_URL",
2: "FETCH_ERROR",
3: "UNSPECIFIED_ERROR",
4: "RESPONSE_TOO_LARGE",
5: "DEADLINE_EXCEEDED",
6: "SSL_CERTIFICATE_ERROR",
7: "DNS_ERROR",
8: "CLOSED",
9: "INTERNAL_TRANSIENT_ERROR",
10: "TOO_MANY_REDIRECTS",
11: "MALFORMED_REPLY",
12: "CONNECTION_ERROR",
}
var URLFetchServiceError_ErrorCode_value = map[string]int32{
"OK": 0,
"INVALID_URL": 1,
"FETCH_ERROR": 2,
"UNSPECIFIED_ERROR": 3,
"RESPONSE_TOO_LARGE": 4,
"DEADLINE_EXCEEDED": 5,
"SSL_CERTIFICATE_ERROR": 6,
"DNS_ERROR": 7,
"CLOSED": 8,
"INTERNAL_TRANSIENT_ERROR": 9,
"TOO_MANY_REDIRECTS": 10,
"MALFORMED_REPLY": 11,
"CONNECTION_ERROR": 12,
}
func (x URLFetchServiceError_ErrorCode) Enum() *URLFetchServiceError_ErrorCode {
p := new(URLFetchServiceError_ErrorCode)
*p = x
return p
}
func (x URLFetchServiceError_ErrorCode) String() string {
return proto.EnumName(URLFetchServiceError_ErrorCode_name, int32(x))
}
func (x *URLFetchServiceError_ErrorCode) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(URLFetchServiceError_ErrorCode_value, data, "URLFetchServiceError_ErrorCode")
if err != nil {
return err
}
*x = URLFetchServiceError_ErrorCode(value)
return nil
}
type URLFetchRequest_RequestMethod int32
const (
URLFetchRequest_GET URLFetchRequest_RequestMethod = 1
URLFetchRequest_POST URLFetchRequest_RequestMethod = 2
URLFetchRequest_HEAD URLFetchRequest_RequestMethod = 3
URLFetchRequest_PUT URLFetchRequest_RequestMethod = 4
URLFetchRequest_DELETE URLFetchRequest_RequestMethod = 5
URLFetchRequest_PATCH URLFetchRequest_RequestMethod = 6
)
var URLFetchRequest_RequestMethod_name = map[int32]string{
1: "GET",
2: "POST",
3: "HEAD",
4: "PUT",
5: "DELETE",
6: "PATCH",
}
var URLFetchRequest_RequestMethod_value = map[string]int32{
"GET": 1,
"POST": 2,
"HEAD": 3,
"PUT": 4,
"DELETE": 5,
"PATCH": 6,
}
func (x URLFetchRequest_RequestMethod) Enum() *URLFetchRequest_RequestMethod {
p := new(URLFetchRequest_RequestMethod)
*p = x
return p
}
func (x URLFetchRequest_RequestMethod) String() string {
return proto.EnumName(URLFetchRequest_RequestMethod_name, int32(x))
}
func (x *URLFetchRequest_RequestMethod) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(URLFetchRequest_RequestMethod_value, data, "URLFetchRequest_RequestMethod")
if err != nil {
return err
}
*x = URLFetchRequest_RequestMethod(value)
return nil
}
type URLFetchServiceError struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *URLFetchServiceError) Reset() { *m = URLFetchServiceError{} }
func (m *URLFetchServiceError) String() string { return proto.CompactTextString(m) }
func (*URLFetchServiceError) ProtoMessage() {}
type URLFetchRequest struct {
Method *URLFetchRequest_RequestMethod `protobuf:"varint,1,req,name=Method,enum=appengine.URLFetchRequest_RequestMethod" json:"Method,omitempty"`
Url *string `protobuf:"bytes,2,req,name=Url" json:"Url,omitempty"`
Header []*URLFetchRequest_Header `protobuf:"group,3,rep,name=Header" json:"header,omitempty"`
Payload []byte `protobuf:"bytes,6,opt,name=Payload" json:"Payload,omitempty"`
FollowRedirects *bool `protobuf:"varint,7,opt,name=FollowRedirects,def=1" json:"FollowRedirects,omitempty"`
Deadline *float64 `protobuf:"fixed64,8,opt,name=Deadline" json:"Deadline,omitempty"`
MustValidateServerCertificate *bool `protobuf:"varint,9,opt,name=MustValidateServerCertificate,def=1" json:"MustValidateServerCertificate,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *URLFetchRequest) Reset() { *m = URLFetchRequest{} }
func (m *URLFetchRequest) String() string { return proto.CompactTextString(m) }
func (*URLFetchRequest) ProtoMessage() {}
const Default_URLFetchRequest_FollowRedirects bool = true
const Default_URLFetchRequest_MustValidateServerCertificate bool = true
func (m *URLFetchRequest) GetMethod() URLFetchRequest_RequestMethod {
if m != nil && m.Method != nil {
return *m.Method
}
return URLFetchRequest_GET
}
func (m *URLFetchRequest) GetUrl() string {
if m != nil && m.Url != nil {
return *m.Url
}
return ""
}
func (m *URLFetchRequest) GetHeader() []*URLFetchRequest_Header {
if m != nil {
return m.Header
}
return nil
}
func (m *URLFetchRequest) GetPayload() []byte {
if m != nil {
return m.Payload
}
return nil
}
func (m *URLFetchRequest) GetFollowRedirects() bool {
if m != nil && m.FollowRedirects != nil {
return *m.FollowRedirects
}
return Default_URLFetchRequest_FollowRedirects
}
func (m *URLFetchRequest) GetDeadline() float64 {
if m != nil && m.Deadline != nil {
return *m.Deadline
}
return 0
}
func (m *URLFetchRequest) GetMustValidateServerCertificate() bool {
if m != nil && m.MustValidateServerCertificate != nil {
return *m.MustValidateServerCertificate
}
return Default_URLFetchRequest_MustValidateServerCertificate
}
type URLFetchRequest_Header struct {
Key *string `protobuf:"bytes,4,req,name=Key" json:"Key,omitempty"`
Value *string `protobuf:"bytes,5,req,name=Value" json:"Value,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *URLFetchRequest_Header) Reset() { *m = URLFetchRequest_Header{} }
func (m *URLFetchRequest_Header) String() string { return proto.CompactTextString(m) }
func (*URLFetchRequest_Header) ProtoMessage() {}
func (m *URLFetchRequest_Header) GetKey() string {
if m != nil && m.Key != nil {
return *m.Key
}
return ""
}
func (m *URLFetchRequest_Header) GetValue() string {
if m != nil && m.Value != nil {
return *m.Value
}
return ""
}
type URLFetchResponse struct {
Content []byte `protobuf:"bytes,1,opt,name=Content" json:"Content,omitempty"`
StatusCode *int32 `protobuf:"varint,2,req,name=StatusCode" json:"StatusCode,omitempty"`
Header []*URLFetchResponse_Header `protobuf:"group,3,rep,name=Header" json:"header,omitempty"`
ContentWasTruncated *bool `protobuf:"varint,6,opt,name=ContentWasTruncated,def=0" json:"ContentWasTruncated,omitempty"`
ExternalBytesSent *int64 `protobuf:"varint,7,opt,name=ExternalBytesSent" json:"ExternalBytesSent,omitempty"`
ExternalBytesReceived *int64 `protobuf:"varint,8,opt,name=ExternalBytesReceived" json:"ExternalBytesReceived,omitempty"`
FinalUrl *string `protobuf:"bytes,9,opt,name=FinalUrl" json:"FinalUrl,omitempty"`
ApiCpuMilliseconds *int64 `protobuf:"varint,10,opt,name=ApiCpuMilliseconds,def=0" json:"ApiCpuMilliseconds,omitempty"`
ApiBytesSent *int64 `protobuf:"varint,11,opt,name=ApiBytesSent,def=0" json:"ApiBytesSent,omitempty"`
ApiBytesReceived *int64 `protobuf:"varint,12,opt,name=ApiBytesReceived,def=0" json:"ApiBytesReceived,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *URLFetchResponse) Reset() { *m = URLFetchResponse{} }
func (m *URLFetchResponse) String() string { return proto.CompactTextString(m) }
func (*URLFetchResponse) ProtoMessage() {}
const Default_URLFetchResponse_ContentWasTruncated bool = false
const Default_URLFetchResponse_ApiCpuMilliseconds int64 = 0
const Default_URLFetchResponse_ApiBytesSent int64 = 0
const Default_URLFetchResponse_ApiBytesReceived int64 = 0
func (m *URLFetchResponse) GetContent() []byte {
if m != nil {
return m.Content
}
return nil
}
func (m *URLFetchResponse) GetStatusCode() int32 {
if m != nil && m.StatusCode != nil {
return *m.StatusCode
}
return 0
}
func (m *URLFetchResponse) GetHeader() []*URLFetchResponse_Header {
if m != nil {
return m.Header
}
return nil
}
func (m *URLFetchResponse) GetContentWasTruncated() bool {
if m != nil && m.ContentWasTruncated != nil {
return *m.ContentWasTruncated
}
return Default_URLFetchResponse_ContentWasTruncated
}
func (m *URLFetchResponse) GetExternalBytesSent() int64 {
if m != nil && m.ExternalBytesSent != nil {
return *m.ExternalBytesSent
}
return 0
}
func (m *URLFetchResponse) GetExternalBytesReceived() int64 {
if m != nil && m.ExternalBytesReceived != nil {
return *m.ExternalBytesReceived
}
return 0
}
func (m *URLFetchResponse) GetFinalUrl() string {
if m != nil && m.FinalUrl != nil {
return *m.FinalUrl
}
return ""
}
func (m *URLFetchResponse) GetApiCpuMilliseconds() int64 {
if m != nil && m.ApiCpuMilliseconds != nil {
return *m.ApiCpuMilliseconds
}
return Default_URLFetchResponse_ApiCpuMilliseconds
}
func (m *URLFetchResponse) GetApiBytesSent() int64 {
if m != nil && m.ApiBytesSent != nil {
return *m.ApiBytesSent
}
return Default_URLFetchResponse_ApiBytesSent
}
func (m *URLFetchResponse) GetApiBytesReceived() int64 {
if m != nil && m.ApiBytesReceived != nil {
return *m.ApiBytesReceived
}
return Default_URLFetchResponse_ApiBytesReceived
}
type URLFetchResponse_Header struct {
Key *string `protobuf:"bytes,4,req,name=Key" json:"Key,omitempty"`
Value *string `protobuf:"bytes,5,req,name=Value" json:"Value,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *URLFetchResponse_Header) Reset() { *m = URLFetchResponse_Header{} }
func (m *URLFetchResponse_Header) String() string { return proto.CompactTextString(m) }
func (*URLFetchResponse_Header) ProtoMessage() {}
func (m *URLFetchResponse_Header) GetKey() string {
if m != nil && m.Key != nil {
return *m.Key
}
return ""
}
func (m *URLFetchResponse_Header) GetValue() string {
if m != nil && m.Value != nil {
return *m.Value
}
return ""
}
func init() {
}
================================================
FILE: vendor/google.golang.org/appengine/internal/urlfetch/urlfetch_service.proto
================================================
syntax = "proto2";
option go_package = "urlfetch";
package appengine;
message URLFetchServiceError {
enum ErrorCode {
OK = 0;
INVALID_URL = 1;
FETCH_ERROR = 2;
UNSPECIFIED_ERROR = 3;
RESPONSE_TOO_LARGE = 4;
DEADLINE_EXCEEDED = 5;
SSL_CERTIFICATE_ERROR = 6;
DNS_ERROR = 7;
CLOSED = 8;
INTERNAL_TRANSIENT_ERROR = 9;
TOO_MANY_REDIRECTS = 10;
MALFORMED_REPLY = 11;
CONNECTION_ERROR = 12;
}
}
message URLFetchRequest {
enum RequestMethod {
GET = 1;
POST = 2;
HEAD = 3;
PUT = 4;
DELETE = 5;
PATCH = 6;
}
required RequestMethod Method = 1;
required string Url = 2;
repeated group Header = 3 {
required string Key = 4;
required string Value = 5;
}
optional bytes Payload = 6 [ctype=CORD];
optional bool FollowRedirects = 7 [default=true];
optional double Deadline = 8;
optional bool MustValidateServerCertificate = 9 [default=true];
}
message URLFetchResponse {
optional bytes Content = 1;
required int32 StatusCode = 2;
repeated group Header = 3 {
required string Key = 4;
required string Value = 5;
}
optional bool ContentWasTruncated = 6 [default=false];
optional int64 ExternalBytesSent = 7;
optional int64 ExternalBytesReceived = 8;
optional string FinalUrl = 9;
optional int64 ApiCpuMilliseconds = 10 [default=0];
optional int64 ApiBytesSent = 11 [default=0];
optional int64 ApiBytesReceived = 12 [default=0];
}
================================================
FILE: vendor/google.golang.org/appengine/internal/user/user_service.pb.go
================================================
// Code generated by protoc-gen-go.
// source: google.golang.org/appengine/internal/user/user_service.proto
// DO NOT EDIT!
/*
Package user is a generated protocol buffer package.
It is generated from these files:
google.golang.org/appengine/internal/user/user_service.proto
It has these top-level messages:
UserServiceError
CreateLoginURLRequest
CreateLoginURLResponse
CreateLogoutURLRequest
CreateLogoutURLResponse
GetOAuthUserRequest
GetOAuthUserResponse
CheckOAuthSignatureRequest
CheckOAuthSignatureResponse
*/
package user
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type UserServiceError_ErrorCode int32
const (
UserServiceError_OK UserServiceError_ErrorCode = 0
UserServiceError_REDIRECT_URL_TOO_LONG UserServiceError_ErrorCode = 1
UserServiceError_NOT_ALLOWED UserServiceError_ErrorCode = 2
UserServiceError_OAUTH_INVALID_TOKEN UserServiceError_ErrorCode = 3
UserServiceError_OAUTH_INVALID_REQUEST UserServiceError_ErrorCode = 4
UserServiceError_OAUTH_ERROR UserServiceError_ErrorCode = 5
)
var UserServiceError_ErrorCode_name = map[int32]string{
0: "OK",
1: "REDIRECT_URL_TOO_LONG",
2: "NOT_ALLOWED",
3: "OAUTH_INVALID_TOKEN",
4: "OAUTH_INVALID_REQUEST",
5: "OAUTH_ERROR",
}
var UserServiceError_ErrorCode_value = map[string]int32{
"OK": 0,
"REDIRECT_URL_TOO_LONG": 1,
"NOT_ALLOWED": 2,
"OAUTH_INVALID_TOKEN": 3,
"OAUTH_INVALID_REQUEST": 4,
"OAUTH_ERROR": 5,
}
func (x UserServiceError_ErrorCode) Enum() *UserServiceError_ErrorCode {
p := new(UserServiceError_ErrorCode)
*p = x
return p
}
func (x UserServiceError_ErrorCode) String() string {
return proto.EnumName(UserServiceError_ErrorCode_name, int32(x))
}
func (x *UserServiceError_ErrorCode) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(UserServiceError_ErrorCode_value, data, "UserServiceError_ErrorCode")
if err != nil {
return err
}
*x = UserServiceError_ErrorCode(value)
return nil
}
type UserServiceError struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *UserServiceError) Reset() { *m = UserServiceError{} }
func (m *UserServiceError) String() string { return proto.CompactTextString(m) }
func (*UserServiceError) ProtoMessage() {}
type CreateLoginURLRequest struct {
DestinationUrl *string `protobuf:"bytes,1,req,name=destination_url" json:"destination_url,omitempty"`
AuthDomain *string `protobuf:"bytes,2,opt,name=auth_domain" json:"auth_domain,omitempty"`
FederatedIdentity *string `protobuf:"bytes,3,opt,name=federated_identity,def=" json:"federated_identity,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CreateLoginURLRequest) Reset() { *m = CreateLoginURLRequest{} }
func (m *CreateLoginURLRequest) String() string { return proto.CompactTextString(m) }
func (*CreateLoginURLRequest) ProtoMessage() {}
func (m *CreateLoginURLRequest) GetDestinationUrl() string {
if m != nil && m.DestinationUrl != nil {
return *m.DestinationUrl
}
return ""
}
func (m *CreateLoginURLRequest) GetAuthDomain() string {
if m != nil && m.AuthDomain != nil {
return *m.AuthDomain
}
return ""
}
func (m *CreateLoginURLRequest) GetFederatedIdentity() string {
if m != nil && m.FederatedIdentity != nil {
return *m.FederatedIdentity
}
return ""
}
type CreateLoginURLResponse struct {
LoginUrl *string `protobuf:"bytes,1,req,name=login_url" json:"login_url,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CreateLoginURLResponse) Reset() { *m = CreateLoginURLResponse{} }
func (m *CreateLoginURLResponse) String() string { return proto.CompactTextString(m) }
func (*CreateLoginURLResponse) ProtoMessage() {}
func (m *CreateLoginURLResponse) GetLoginUrl() string {
if m != nil && m.LoginUrl != nil {
return *m.LoginUrl
}
return ""
}
type CreateLogoutURLRequest struct {
DestinationUrl *string `protobuf:"bytes,1,req,name=destination_url" json:"destination_url,omitempty"`
AuthDomain *string `protobuf:"bytes,2,opt,name=auth_domain" json:"auth_domain,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CreateLogoutURLRequest) Reset() { *m = CreateLogoutURLRequest{} }
func (m *CreateLogoutURLRequest) String() string { return proto.CompactTextString(m) }
func (*CreateLogoutURLRequest) ProtoMessage() {}
func (m *CreateLogoutURLRequest) GetDestinationUrl() string {
if m != nil && m.DestinationUrl != nil {
return *m.DestinationUrl
}
return ""
}
func (m *CreateLogoutURLRequest) GetAuthDomain() string {
if m != nil && m.AuthDomain != nil {
return *m.AuthDomain
}
return ""
}
type CreateLogoutURLResponse struct {
LogoutUrl *string `protobuf:"bytes,1,req,name=logout_url" json:"logout_url,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CreateLogoutURLResponse) Reset() { *m = CreateLogoutURLResponse{} }
func (m *CreateLogoutURLResponse) String() string { return proto.CompactTextString(m) }
func (*CreateLogoutURLResponse) ProtoMessage() {}
func (m *CreateLogoutURLResponse) GetLogoutUrl() string {
if m != nil && m.LogoutUrl != nil {
return *m.LogoutUrl
}
return ""
}
type GetOAuthUserRequest struct {
Scope *string `protobuf:"bytes,1,opt,name=scope" json:"scope,omitempty"`
Scopes []string `protobuf:"bytes,2,rep,name=scopes" json:"scopes,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetOAuthUserRequest) Reset() { *m = GetOAuthUserRequest{} }
func (m *GetOAuthUserRequest) String() string { return proto.CompactTextString(m) }
func (*GetOAuthUserRequest) ProtoMessage() {}
func (m *GetOAuthUserRequest) GetScope() string {
if m != nil && m.Scope != nil {
return *m.Scope
}
return ""
}
func (m *GetOAuthUserRequest) GetScopes() []string {
if m != nil {
return m.Scopes
}
return nil
}
type GetOAuthUserResponse struct {
Email *string `protobuf:"bytes,1,req,name=email" json:"email,omitempty"`
UserId *string `protobuf:"bytes,2,req,name=user_id" json:"user_id,omitempty"`
AuthDomain *string `protobuf:"bytes,3,req,name=auth_domain" json:"auth_domain,omitempty"`
UserOrganization *string `protobuf:"bytes,4,opt,name=user_organization,def=" json:"user_organization,omitempty"`
IsAdmin *bool `protobuf:"varint,5,opt,name=is_admin,def=0" json:"is_admin,omitempty"`
ClientId *string `protobuf:"bytes,6,opt,name=client_id,def=" json:"client_id,omitempty"`
Scopes []string `protobuf:"bytes,7,rep,name=scopes" json:"scopes,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GetOAuthUserResponse) Reset() { *m = GetOAuthUserResponse{} }
func (m *GetOAuthUserResponse) String() string { return proto.CompactTextString(m) }
func (*GetOAuthUserResponse) ProtoMessage() {}
const Default_GetOAuthUserResponse_IsAdmin bool = false
func (m *GetOAuthUserResponse) GetEmail() string {
if m != nil && m.Email != nil {
return *m.Email
}
return ""
}
func (m *GetOAuthUserResponse) GetUserId() string {
if m != nil && m.UserId != nil {
return *m.UserId
}
return ""
}
func (m *GetOAuthUserResponse) GetAuthDomain() string {
if m != nil && m.AuthDomain != nil {
return *m.AuthDomain
}
return ""
}
func (m *GetOAuthUserResponse) GetUserOrganization() string {
if m != nil && m.UserOrganization != nil {
return *m.UserOrganization
}
return ""
}
func (m *GetOAuthUserResponse) GetIsAdmin() bool {
if m != nil && m.IsAdmin != nil {
return *m.IsAdmin
}
return Default_GetOAuthUserResponse_IsAdmin
}
func (m *GetOAuthUserResponse) GetClientId() string {
if m != nil && m.ClientId != nil {
return *m.ClientId
}
return ""
}
func (m *GetOAuthUserResponse) GetScopes() []string {
if m != nil {
return m.Scopes
}
return nil
}
type CheckOAuthSignatureRequest struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *CheckOAuthSignatureRequest) Reset() { *m = CheckOAuthSignatureRequest{} }
func (m *CheckOAuthSignatureRequest) String() string { return proto.CompactTextString(m) }
func (*CheckOAuthSignatureRequest) ProtoMessage() {}
type CheckOAuthSignatureResponse struct {
OauthConsumerKey *string `protobuf:"bytes,1,req,name=oauth_consumer_key" json:"oauth_consumer_key,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CheckOAuthSignatureResponse) Reset() { *m = CheckOAuthSignatureResponse{} }
func (m *CheckOAuthSignatureResponse) String() string { return proto.CompactTextString(m) }
func (*CheckOAuthSignatureResponse) ProtoMessage() {}
func (m *CheckOAuthSignatureResponse) GetOauthConsumerKey() string {
if m != nil && m.OauthConsumerKey != nil {
return *m.OauthConsumerKey
}
return ""
}
func init() {
}
================================================
FILE: vendor/google.golang.org/appengine/internal/user/user_service.proto
================================================
syntax = "proto2";
option go_package = "user";
package appengine;
message UserServiceError {
enum ErrorCode {
OK = 0;
REDIRECT_URL_TOO_LONG = 1;
NOT_ALLOWED = 2;
OAUTH_INVALID_TOKEN = 3;
OAUTH_INVALID_REQUEST = 4;
OAUTH_ERROR = 5;
}
}
message CreateLoginURLRequest {
required string destination_url = 1;
optional string auth_domain = 2;
optional string federated_identity = 3 [default = ""];
}
message CreateLoginURLResponse {
required string login_url = 1;
}
message CreateLogoutURLRequest {
required string destination_url = 1;
optional string auth_domain = 2;
}
message CreateLogoutURLResponse {
required string logout_url = 1;
}
message GetOAuthUserRequest {
optional string scope = 1;
repeated string scopes = 2;
}
message GetOAuthUserResponse {
required string email = 1;
required string user_id = 2;
required string auth_domain = 3;
optional string user_organization = 4 [default = ""];
optional bool is_admin = 5 [default = false];
optional string client_id = 6 [default = ""];
repeated string scopes = 7;
}
message CheckOAuthSignatureRequest {
}
message CheckOAuthSignatureResponse {
required string oauth_consumer_key = 1;
}
================================================
FILE: vendor/google.golang.org/appengine/internal/xmpp/xmpp_service.pb.go
================================================
// Code generated by protoc-gen-go.
// source: google.golang.org/appengine/internal/xmpp/xmpp_service.proto
// DO NOT EDIT!
/*
Package xmpp is a generated protocol buffer package.
It is generated from these files:
google.golang.org/appengine/internal/xmpp/xmpp_service.proto
It has these top-level messages:
XmppServiceError
PresenceRequest
PresenceResponse
BulkPresenceRequest
BulkPresenceResponse
XmppMessageRequest
XmppMessageResponse
XmppSendPresenceRequest
XmppSendPresenceResponse
XmppInviteRequest
XmppInviteResponse
*/
package xmpp
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
type XmppServiceError_ErrorCode int32
const (
XmppServiceError_UNSPECIFIED_ERROR XmppServiceError_ErrorCode = 1
XmppServiceError_INVALID_JID XmppServiceError_ErrorCode = 2
XmppServiceError_NO_BODY XmppServiceError_ErrorCode = 3
XmppServiceError_INVALID_XML XmppServiceError_ErrorCode = 4
XmppServiceError_INVALID_TYPE XmppServiceError_ErrorCode = 5
XmppServiceError_INVALID_SHOW XmppServiceError_ErrorCode = 6
XmppServiceError_EXCEEDED_MAX_SIZE XmppServiceError_ErrorCode = 7
XmppServiceError_APPID_ALIAS_REQUIRED XmppServiceError_ErrorCode = 8
XmppServiceError_NONDEFAULT_MODULE XmppServiceError_ErrorCode = 9
)
var XmppServiceError_ErrorCode_name = map[int32]string{
1: "UNSPECIFIED_ERROR",
2: "INVALID_JID",
3: "NO_BODY",
4: "INVALID_XML",
5: "INVALID_TYPE",
6: "INVALID_SHOW",
7: "EXCEEDED_MAX_SIZE",
8: "APPID_ALIAS_REQUIRED",
9: "NONDEFAULT_MODULE",
}
var XmppServiceError_ErrorCode_value = map[string]int32{
"UNSPECIFIED_ERROR": 1,
"INVALID_JID": 2,
"NO_BODY": 3,
"INVALID_XML": 4,
"INVALID_TYPE": 5,
"INVALID_SHOW": 6,
"EXCEEDED_MAX_SIZE": 7,
"APPID_ALIAS_REQUIRED": 8,
"NONDEFAULT_MODULE": 9,
}
func (x XmppServiceError_ErrorCode) Enum() *XmppServiceError_ErrorCode {
p := new(XmppServiceError_ErrorCode)
*p = x
return p
}
func (x XmppServiceError_ErrorCode) String() string {
return proto.EnumName(XmppServiceError_ErrorCode_name, int32(x))
}
func (x *XmppServiceError_ErrorCode) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(XmppServiceError_ErrorCode_value, data, "XmppServiceError_ErrorCode")
if err != nil {
return err
}
*x = XmppServiceError_ErrorCode(value)
return nil
}
type PresenceResponse_SHOW int32
const (
PresenceResponse_NORMAL PresenceResponse_SHOW = 0
PresenceResponse_AWAY PresenceResponse_SHOW = 1
PresenceResponse_DO_NOT_DISTURB PresenceResponse_SHOW = 2
PresenceResponse_CHAT PresenceResponse_SHOW = 3
PresenceResponse_EXTENDED_AWAY PresenceResponse_SHOW = 4
)
var PresenceResponse_SHOW_name = map[int32]string{
0: "NORMAL",
1: "AWAY",
2: "DO_NOT_DISTURB",
3: "CHAT",
4: "EXTENDED_AWAY",
}
var PresenceResponse_SHOW_value = map[string]int32{
"NORMAL": 0,
"AWAY": 1,
"DO_NOT_DISTURB": 2,
"CHAT": 3,
"EXTENDED_AWAY": 4,
}
func (x PresenceResponse_SHOW) Enum() *PresenceResponse_SHOW {
p := new(PresenceResponse_SHOW)
*p = x
return p
}
func (x PresenceResponse_SHOW) String() string {
return proto.EnumName(PresenceResponse_SHOW_name, int32(x))
}
func (x *PresenceResponse_SHOW) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(PresenceResponse_SHOW_value, data, "PresenceResponse_SHOW")
if err != nil {
return err
}
*x = PresenceResponse_SHOW(value)
return nil
}
type XmppMessageResponse_XmppMessageStatus int32
const (
XmppMessageResponse_NO_ERROR XmppMessageResponse_XmppMessageStatus = 0
XmppMessageResponse_INVALID_JID XmppMessageResponse_XmppMessageStatus = 1
XmppMessageResponse_OTHER_ERROR XmppMessageResponse_XmppMessageStatus = 2
)
var XmppMessageResponse_XmppMessageStatus_name = map[int32]string{
0: "NO_ERROR",
1: "INVALID_JID",
2: "OTHER_ERROR",
}
var XmppMessageResponse_XmppMessageStatus_value = map[string]int32{
"NO_ERROR": 0,
"INVALID_JID": 1,
"OTHER_ERROR": 2,
}
func (x XmppMessageResponse_XmppMessageStatus) Enum() *XmppMessageResponse_XmppMessageStatus {
p := new(XmppMessageResponse_XmppMessageStatus)
*p = x
return p
}
func (x XmppMessageResponse_XmppMessageStatus) String() string {
return proto.EnumName(XmppMessageResponse_XmppMessageStatus_name, int32(x))
}
func (x *XmppMessageResponse_XmppMessageStatus) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(XmppMessageResponse_XmppMessageStatus_value, data, "XmppMessageResponse_XmppMessageStatus")
if err != nil {
return err
}
*x = XmppMessageResponse_XmppMessageStatus(value)
return nil
}
type XmppServiceError struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *XmppServiceError) Reset() { *m = XmppServiceError{} }
func (m *XmppServiceError) String() string { return proto.CompactTextString(m) }
func (*XmppServiceError) ProtoMessage() {}
type PresenceRequest struct {
Jid *string `protobuf:"bytes,1,req,name=jid" json:"jid,omitempty"`
FromJid *string `protobuf:"bytes,2,opt,name=from_jid" json:"from_jid,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *PresenceRequest) Reset() { *m = PresenceRequest{} }
func (m *PresenceRequest) String() string { return proto.CompactTextString(m) }
func (*PresenceRequest) ProtoMessage() {}
func (m *PresenceRequest) GetJid() string {
if m != nil && m.Jid != nil {
return *m.Jid
}
return ""
}
func (m *PresenceRequest) GetFromJid() string {
if m != nil && m.FromJid != nil {
return *m.FromJid
}
return ""
}
type PresenceResponse struct {
IsAvailable *bool `protobuf:"varint,1,req,name=is_available" json:"is_available,omitempty"`
Presence *PresenceResponse_SHOW `protobuf:"varint,2,opt,name=presence,enum=appengine.PresenceResponse_SHOW" json:"presence,omitempty"`
Valid *bool `protobuf:"varint,3,opt,name=valid" json:"valid,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *PresenceResponse) Reset() { *m = PresenceResponse{} }
func (m *PresenceResponse) String() string { return proto.CompactTextString(m) }
func (*PresenceResponse) ProtoMessage() {}
func (m *PresenceResponse) GetIsAvailable() bool {
if m != nil && m.IsAvailable != nil {
return *m.IsAvailable
}
return false
}
func (m *PresenceResponse) GetPresence() PresenceResponse_SHOW {
if m != nil && m.Presence != nil {
return *m.Presence
}
return PresenceResponse_NORMAL
}
func (m *PresenceResponse) GetValid() bool {
if m != nil && m.Valid != nil {
return *m.Valid
}
return false
}
type BulkPresenceRequest struct {
Jid []string `protobuf:"bytes,1,rep,name=jid" json:"jid,omitempty"`
FromJid *string `protobuf:"bytes,2,opt,name=from_jid" json:"from_jid,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *BulkPresenceRequest) Reset() { *m = BulkPresenceRequest{} }
func (m *BulkPresenceRequest) String() string { return proto.CompactTextString(m) }
func (*BulkPresenceRequest) ProtoMessage() {}
func (m *BulkPresenceRequest) GetJid() []string {
if m != nil {
return m.Jid
}
return nil
}
func (m *BulkPresenceRequest) GetFromJid() string {
if m != nil && m.FromJid != nil {
return *m.FromJid
}
return ""
}
type BulkPresenceResponse struct {
PresenceResponse []*PresenceResponse `protobuf:"bytes,1,rep,name=presence_response" json:"presence_response,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *BulkPresenceResponse) Reset() { *m = BulkPresenceResponse{} }
func (m *BulkPresenceResponse) String() string { return proto.CompactTextString(m) }
func (*BulkPresenceResponse) ProtoMessage() {}
func (m *BulkPresenceResponse) GetPresenceResponse() []*PresenceResponse {
if m != nil {
return m.PresenceResponse
}
return nil
}
type XmppMessageRequest struct {
Jid []string `protobuf:"bytes,1,rep,name=jid" json:"jid,omitempty"`
Body *string `protobuf:"bytes,2,req,name=body" json:"body,omitempty"`
RawXml *bool `protobuf:"varint,3,opt,name=raw_xml,def=0" json:"raw_xml,omitempty"`
Type *string `protobuf:"bytes,4,opt,name=type,def=chat" json:"type,omitempty"`
FromJid *string `protobuf:"bytes,5,opt,name=from_jid" json:"from_jid,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *XmppMessageRequest) Reset() { *m = XmppMessageRequest{} }
func (m *XmppMessageRequest) String() string { return proto.CompactTextString(m) }
func (*XmppMessageRequest) ProtoMessage() {}
const Default_XmppMessageRequest_RawXml bool = false
const Default_XmppMessageRequest_Type string = "chat"
func (m *XmppMessageRequest) GetJid() []string {
if m != nil {
return m.Jid
}
return nil
}
func (m *XmppMessageRequest) GetBody() string {
if m != nil && m.Body != nil {
return *m.Body
}
return ""
}
func (m *XmppMessageRequest) GetRawXml() bool {
if m != nil && m.RawXml != nil {
return *m.RawXml
}
return Default_XmppMessageRequest_RawXml
}
func (m *XmppMessageRequest) GetType() string {
if m != nil && m.Type != nil {
return *m.Type
}
return Default_XmppMessageRequest_Type
}
func (m *XmppMessageRequest) GetFromJid() string {
if m != nil && m.FromJid != nil {
return *m.FromJid
}
return ""
}
type XmppMessageResponse struct {
Status []XmppMessageResponse_XmppMessageStatus `protobuf:"varint,1,rep,name=status,enum=appengine.XmppMessageResponse_XmppMessageStatus" json:"status,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *XmppMessageResponse) Reset() { *m = XmppMessageResponse{} }
func (m *XmppMessageResponse) String() string { return proto.CompactTextString(m) }
func (*XmppMessageResponse) ProtoMessage() {}
func (m *XmppMessageResponse) GetStatus() []XmppMessageResponse_XmppMessageStatus {
if m != nil {
return m.Status
}
return nil
}
type XmppSendPresenceRequest struct {
Jid *string `protobuf:"bytes,1,req,name=jid" json:"jid,omitempty"`
Type *string `protobuf:"bytes,2,opt,name=type" json:"type,omitempty"`
Show *string `protobuf:"bytes,3,opt,name=show" json:"show,omitempty"`
Status *string `protobuf:"bytes,4,opt,name=status" json:"status,omitempty"`
FromJid *string `protobuf:"bytes,5,opt,name=from_jid" json:"from_jid,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *XmppSendPresenceRequest) Reset() { *m = XmppSendPresenceRequest{} }
func (m *XmppSendPresenceRequest) String() string { return proto.CompactTextString(m) }
func (*XmppSendPresenceRequest) ProtoMessage() {}
func (m *XmppSendPresenceRequest) GetJid() string {
if m != nil && m.Jid != nil {
return *m.Jid
}
return ""
}
func (m *XmppSendPresenceRequest) GetType() string {
if m != nil && m.Type != nil {
return *m.Type
}
return ""
}
func (m *XmppSendPresenceRequest) GetShow() string {
if m != nil && m.Show != nil {
return *m.Show
}
return ""
}
func (m *XmppSendPresenceRequest) GetStatus() string {
if m != nil && m.Status != nil {
return *m.Status
}
return ""
}
func (m *XmppSendPresenceRequest) GetFromJid() string {
if m != nil && m.FromJid != nil {
return *m.FromJid
}
return ""
}
type XmppSendPresenceResponse struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *XmppSendPresenceResponse) Reset() { *m = XmppSendPresenceResponse{} }
func (m *XmppSendPresenceResponse) String() string { return proto.CompactTextString(m) }
func (*XmppSendPresenceResponse) ProtoMessage() {}
type XmppInviteRequest struct {
Jid *string `protobuf:"bytes,1,req,name=jid" json:"jid,omitempty"`
FromJid *string `protobuf:"bytes,2,opt,name=from_jid" json:"from_jid,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *XmppInviteRequest) Reset() { *m = XmppInviteRequest{} }
func (m *XmppInviteRequest) String() string { return proto.CompactTextString(m) }
func (*XmppInviteRequest) ProtoMessage() {}
func (m *XmppInviteRequest) GetJid() string {
if m != nil && m.Jid != nil {
return *m.Jid
}
return ""
}
func (m *XmppInviteRequest) GetFromJid() string {
if m != nil && m.FromJid != nil {
return *m.FromJid
}
return ""
}
type XmppInviteResponse struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *XmppInviteResponse) Reset() { *m = XmppInviteResponse{} }
func (m *XmppInviteResponse) String() string { return proto.CompactTextString(m) }
func (*XmppInviteResponse) ProtoMessage() {}
func init() {
}
================================================
FILE: vendor/google.golang.org/appengine/internal/xmpp/xmpp_service.proto
================================================
syntax = "proto2";
option go_package = "xmpp";
package appengine;
message XmppServiceError {
enum ErrorCode {
UNSPECIFIED_ERROR = 1;
INVALID_JID = 2;
NO_BODY = 3;
INVALID_XML = 4;
INVALID_TYPE = 5;
INVALID_SHOW = 6;
EXCEEDED_MAX_SIZE = 7;
APPID_ALIAS_REQUIRED = 8;
NONDEFAULT_MODULE = 9;
}
}
message PresenceRequest {
required string jid = 1;
optional string from_jid = 2;
}
message PresenceResponse {
enum SHOW {
NORMAL = 0;
AWAY = 1;
DO_NOT_DISTURB = 2;
CHAT = 3;
EXTENDED_AWAY = 4;
}
required bool is_available = 1;
optional SHOW presence = 2;
optional bool valid = 3;
}
message BulkPresenceRequest {
repeated string jid = 1;
optional string from_jid = 2;
}
message BulkPresenceResponse {
repeated PresenceResponse presence_response = 1;
}
message XmppMessageRequest {
repeated string jid = 1;
required string body = 2;
optional bool raw_xml = 3 [ default = false ];
optional string type = 4 [ default = "chat" ];
optional string from_jid = 5;
}
message XmppMessageResponse {
enum XmppMessageStatus {
NO_ERROR = 0;
INVALID_JID = 1;
OTHER_ERROR = 2;
}
repeated XmppMessageStatus status = 1;
}
message XmppSendPresenceRequest {
required string jid = 1;
optional string type = 2;
optional string show = 3;
optional string status = 4;
optional string from_jid = 5;
}
message XmppSendPresenceResponse {
}
message XmppInviteRequest {
required string jid = 1;
optional string from_jid = 2;
}
message XmppInviteResponse {
}
================================================
FILE: vendor/google.golang.org/appengine/log/api.go
================================================
// Copyright 2015 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
package log
// This file implements the logging API.
import (
"golang.org/x/net/context"
"google.golang.org/appengine/internal"
)
// Debugf formats its arguments according to the format, analogous to fmt.Printf,
// and records the text as a log message at Debug level. The message will be associated
// with the request linked with the provided context.
func Debugf(ctx context.Context, format string, args ...interface{}) {
internal.Logf(ctx, 0, format, args...)
}
// Infof is like Debugf, but at Info level.
func Infof(ctx context.Context, format string, args ...interface{}) {
internal.Logf(ctx, 1, format, args...)
}
// Warningf is like Debugf, but at Warning level.
func Warningf(ctx context.Context, format string, args ...interface{}) {
internal.Logf(ctx, 2, format, args...)
}
// Errorf is like Debugf, but at Error level.
func Errorf(ctx context.Context, format string, args ...interface{}) {
internal.Logf(ctx, 3, format, args...)
}
// Criticalf is like Debugf, but at Critical level.
func Criticalf(ctx context.Context, format string, args ...interface{}) {
internal.Logf(ctx, 4, format, args...)
}
================================================
FILE: vendor/google.golang.org/appengine/log/log.go
================================================
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
/*
Package log provides the means of querying an application's logs from
within an App Engine application.
Example:
c := appengine.NewContext(r)
query := &log.Query{
AppLogs: true,
Versions: []string{"1"},
}
for results := query.Run(c); ; {
record, err := results.Next()
if err == log.Done {
log.Infof(c, "Done processing results")
break
}
if err != nil {
log.Errorf(c, "Failed to retrieve next log: %v", err)
break
}
log.Infof(c, "Saw record %v", record)
}
*/
package log
import (
"errors"
"fmt"
"strings"
"time"
"github.com/golang/protobuf/proto"
"golang.org/x/net/context"
"google.golang.org/appengine"
"google.golang.org/appengine/internal"
pb "google.golang.org/appengine/internal/log"
)
// Query defines a logs query.
type Query struct {
// Start time specifies the earliest log to return (inclusive).
StartTime time.Time
// End time specifies the latest log to return (exclusive).
EndTime time.Time
// Offset specifies a position within the log stream to resume reading from,
// and should come from a previously returned Record's field of the same name.
Offset []byte
// Incomplete controls whether active (incomplete) requests should be included.
Incomplete bool
// AppLogs indicates if application-level logs should be included.
AppLogs bool
// ApplyMinLevel indicates if MinLevel should be used to filter results.
ApplyMinLevel bool
// If ApplyMinLevel is true, only logs for requests with at least one
// application log of MinLevel or higher will be returned.
MinLevel int
// Versions is the major version IDs whose logs should be retrieved.
// Logs for specific modules can be retrieved by the specifying versions
// in the form "module:version"; the default module is used if no module
// is specified.
Versions []string
// A list of requests to search for instead of a time-based scan. Cannot be
// combined with filtering options such as StartTime, EndTime, Offset,
// Incomplete, ApplyMinLevel, or Versions.
RequestIDs []string
}
// AppLog represents a single application-level log.
type AppLog struct {
Time time.Time
Level int
Message string
}
// Record contains all the information for a single web request.
type Record struct {
AppID string
ModuleID string
VersionID string
RequestID []byte
IP string
Nickname string
AppEngineRelease string
// The time when this request started.
StartTime time.Time
// The time when this request finished.
EndTime time.Time
// Opaque cursor into the result stream.
Offset []byte
// The time required to process the request.
Latency time.Duration
MCycles int64
Method string
Resource string
HTTPVersion string
Status int32
// The size of the request sent back to the client, in bytes.
ResponseSize int64
Referrer string
UserAgent string
URLMapEntry string
Combined string
Host string
// The estimated cost of this request, in dollars.
Cost float64
TaskQueueName string
TaskName string
WasLoadingRequest bool
PendingTime time.Duration
Finished bool
AppLogs []AppLog
// Mostly-unique identifier for the instance that handled the request if available.
InstanceID string
}
// Result represents the result of a query.
type Result struct {
logs []*Record
context context.Context
request *pb.LogReadRequest
resultsSeen bool
err error
}
// Next returns the next log record,
func (qr *Result) Next() (*Record, error) {
if qr.err != nil {
return nil, qr.err
}
if len(qr.logs) > 0 {
lr := qr.logs[0]
qr.logs = qr.logs[1:]
return lr, nil
}
if qr.request.Offset == nil && qr.resultsSeen {
return nil, Done
}
if err := qr.run(); err != nil {
// Errors here may be retried, so don't store the error.
return nil, err
}
return qr.Next()
}
// Done is returned when a query iteration has completed.
var Done = errors.New("log: query has no more results")
// protoToAppLogs takes as input an array of pointers to LogLines, the internal
// Protocol Buffer representation of a single application-level log,
// and converts it to an array of AppLogs, the external representation
// of an application-level log.
func protoToAppLogs(logLines []*pb.LogLine) []AppLog {
appLogs := make([]AppLog, len(logLines))
for i, line := range logLines {
appLogs[i] = AppLog{
Time: time.Unix(0, *line.Time*1e3),
Level: int(*line.Level),
Message: *line.LogMessage,
}
}
return appLogs
}
// protoToRecord converts a RequestLog, the internal Protocol Buffer
// representation of a single request-level log, to a Record, its
// corresponding external representation.
func protoToRecord(rl *pb.RequestLog) *Record {
offset, err := proto.Marshal(rl.Offset)
if err != nil {
offset = nil
}
return &Record{
AppID: *rl.AppId,
ModuleID: rl.GetModuleId(),
VersionID: *rl.VersionId,
RequestID: rl.RequestId,
Offset: offset,
IP: *rl.Ip,
Nickname: rl.GetNickname(),
AppEngineRelease: string(rl.GetAppEngineRelease()),
StartTime: time.Unix(0, *rl.StartTime*1e3),
EndTime: time.Unix(0, *rl.EndTime*1e3),
Latency: time.Duration(*rl.Latency) * time.Microsecond,
MCycles: *rl.Mcycles,
Method: *rl.Method,
Resource: *rl.Resource,
HTTPVersion: *rl.HttpVersion,
Status: *rl.Status,
ResponseSize: *rl.ResponseSize,
Referrer: rl.GetReferrer(),
UserAgent: rl.GetUserAgent(),
URLMapEntry: *rl.UrlMapEntry,
Combined: *rl.Combined,
Host: rl.GetHost(),
Cost: rl.GetCost(),
TaskQueueName: rl.GetTaskQueueName(),
TaskName: rl.GetTaskName(),
WasLoadingRequest: rl.GetWasLoadingRequest(),
PendingTime: time.Duration(rl.GetPendingTime()) * time.Microsecond,
Finished: rl.GetFinished(),
AppLogs: protoToAppLogs(rl.Line),
InstanceID: string(rl.GetCloneKey()),
}
}
// Run starts a query for log records, which contain request and application
// level log information.
func (params *Query) Run(c context.Context) *Result {
req, err := makeRequest(params, internal.FullyQualifiedAppID(c), appengine.VersionID(c))
return &Result{
context: c,
request: req,
err: err,
}
}
func makeRequest(params *Query, appID, versionID string) (*pb.LogReadRequest, error) {
req := &pb.LogReadRequest{}
req.AppId = &appID
if !params.StartTime.IsZero() {
req.StartTime = proto.Int64(params.StartTime.UnixNano() / 1e3)
}
if !params.EndTime.IsZero() {
req.EndTime = proto.Int64(params.EndTime.UnixNano() / 1e3)
}
if len(params.Offset) > 0 {
var offset pb.LogOffset
if err := proto.Unmarshal(params.Offset, &offset); err != nil {
return nil, fmt.Errorf("bad Offset: %v", err)
}
req.Offset = &offset
}
if params.Incomplete {
req.IncludeIncomplete = ¶ms.Incomplete
}
if params.AppLogs {
req.IncludeAppLogs = ¶ms.AppLogs
}
if params.ApplyMinLevel {
req.MinimumLogLevel = proto.Int32(int32(params.MinLevel))
}
if params.Versions == nil {
// If no versions were specified, default to the default module at
// the major version being used by this module.
if i := strings.Index(versionID, "."); i >= 0 {
versionID = versionID[:i]
}
req.VersionId = []string{versionID}
} else {
req.ModuleVersion = make([]*pb.LogModuleVersion, 0, len(params.Versions))
for _, v := range params.Versions {
var m *string
if i := strings.Index(v, ":"); i >= 0 {
m, v = proto.String(v[:i]), v[i+1:]
}
req.ModuleVersion = append(req.ModuleVersion, &pb.LogModuleVersion{
ModuleId: m,
VersionId: proto.String(v),
})
}
}
if params.RequestIDs != nil {
ids := make([][]byte, len(params.RequestIDs))
for i, v := range params.RequestIDs {
ids[i] = []byte(v)
}
req.RequestId = ids
}
return req, nil
}
// run takes the query Result produced by a call to Run and updates it with
// more Records. The updated Result contains a new set of logs as well as an
// offset to where more logs can be found. We also convert the items in the
// response from their internal representations to external versions of the
// same structs.
func (r *Result) run() error {
res := &pb.LogReadResponse{}
if err := internal.Call(r.context, "logservice", "Read", r.request, res); err != nil {
return err
}
r.logs = make([]*Record, len(res.Log))
r.request.Offset = res.Offset
r.resultsSeen = true
for i, log := range res.Log {
r.logs[i] = protoToRecord(log)
}
return nil
}
func init() {
internal.RegisterErrorCodeMap("logservice", pb.LogServiceError_ErrorCode_name)
}
================================================
FILE: vendor/google.golang.org/appengine/mail/mail.go
================================================
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
/*
Package mail provides the means of sending email from an
App Engine application.
Example:
msg := &mail.Message{
Sender: "romeo@montague.com",
To: []string{"Juliet "},
Subject: "See you tonight",
Body: "Don't forget our plans. Hark, 'til later.",
}
if err := mail.Send(c, msg); err != nil {
log.Errorf(c, "Alas, my user, the email failed to sendeth: %v", err)
}
*/
package mail
import (
"net/mail"
"github.com/golang/protobuf/proto"
"golang.org/x/net/context"
"google.golang.org/appengine/internal"
bpb "google.golang.org/appengine/internal/base"
pb "google.golang.org/appengine/internal/mail"
)
// A Message represents an email message.
// Addresses may be of any form permitted by RFC 822.
type Message struct {
// Sender must be set, and must be either an application admin
// or the currently signed-in user.
Sender string
ReplyTo string // may be empty
// At least one of these slices must have a non-zero length,
// except when calling SendToAdmins.
To, Cc, Bcc []string
Subject string
// At least one of Body or HTMLBody must be non-empty.
Body string
HTMLBody string
Attachments []Attachment
// Extra mail headers.
// See https://cloud.google.com/appengine/docs/go/mail/
// for permissible headers.
Headers mail.Header
}
// An Attachment represents an email attachment.
type Attachment struct {
// Name must be set to a valid file name.
Name string
Data []byte
ContentID string
}
// Send sends an email message.
func Send(c context.Context, msg *Message) error {
return send(c, "Send", msg)
}
// SendToAdmins sends an email message to the application's administrators.
func SendToAdmins(c context.Context, msg *Message) error {
return send(c, "SendToAdmins", msg)
}
func send(c context.Context, method string, msg *Message) error {
req := &pb.MailMessage{
Sender: &msg.Sender,
To: msg.To,
Cc: msg.Cc,
Bcc: msg.Bcc,
Subject: &msg.Subject,
}
if msg.ReplyTo != "" {
req.ReplyTo = &msg.ReplyTo
}
if msg.Body != "" {
req.TextBody = &msg.Body
}
if msg.HTMLBody != "" {
req.HtmlBody = &msg.HTMLBody
}
if len(msg.Attachments) > 0 {
req.Attachment = make([]*pb.MailAttachment, len(msg.Attachments))
for i, att := range msg.Attachments {
req.Attachment[i] = &pb.MailAttachment{
FileName: proto.String(att.Name),
Data: att.Data,
}
if att.ContentID != "" {
req.Attachment[i].ContentID = proto.String(att.ContentID)
}
}
}
for key, vs := range msg.Headers {
for _, v := range vs {
req.Header = append(req.Header, &pb.MailHeader{
Name: proto.String(key),
Value: proto.String(v),
})
}
}
res := &bpb.VoidProto{}
if err := internal.Call(c, "mail", method, req, res); err != nil {
return err
}
return nil
}
func init() {
internal.RegisterErrorCodeMap("mail", pb.MailServiceError_ErrorCode_name)
}
================================================
FILE: vendor/google.golang.org/appengine/memcache/memcache.go
================================================
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
// Package memcache provides a client for App Engine's distributed in-memory
// key-value store for small chunks of arbitrary data.
//
// The fundamental operations get and set items, keyed by a string.
//
// item0, err := memcache.Get(c, "key")
// if err != nil && err != memcache.ErrCacheMiss {
// return err
// }
// if err == nil {
// fmt.Fprintf(w, "memcache hit: Key=%q Val=[% x]\n", item0.Key, item0.Value)
// } else {
// fmt.Fprintf(w, "memcache miss\n")
// }
//
// and
//
// item1 := &memcache.Item{
// Key: "foo",
// Value: []byte("bar"),
// }
// if err := memcache.Set(c, item1); err != nil {
// return err
// }
package memcache
import (
"bytes"
"encoding/gob"
"encoding/json"
"errors"
"time"
"github.com/golang/protobuf/proto"
"golang.org/x/net/context"
"google.golang.org/appengine"
"google.golang.org/appengine/internal"
pb "google.golang.org/appengine/internal/memcache"
)
var (
// ErrCacheMiss means that an operation failed
// because the item wasn't present.
ErrCacheMiss = errors.New("memcache: cache miss")
// ErrCASConflict means that a CompareAndSwap call failed due to the
// cached value being modified between the Get and the CompareAndSwap.
// If the cached value was simply evicted rather than replaced,
// ErrNotStored will be returned instead.
ErrCASConflict = errors.New("memcache: compare-and-swap conflict")
// ErrNoStats means that no statistics were available.
ErrNoStats = errors.New("memcache: no statistics available")
// ErrNotStored means that a conditional write operation (i.e. Add or
// CompareAndSwap) failed because the condition was not satisfied.
ErrNotStored = errors.New("memcache: item not stored")
// ErrServerError means that a server error occurred.
ErrServerError = errors.New("memcache: server error")
)
// Item is the unit of memcache gets and sets.
type Item struct {
// Key is the Item's key (250 bytes maximum).
Key string
// Value is the Item's value.
Value []byte
// Object is the Item's value for use with a Codec.
Object interface{}
// Flags are server-opaque flags whose semantics are entirely up to the
// App Engine app.
Flags uint32
// Expiration is the maximum duration that the item will stay
// in the cache.
// The zero value means the Item has no expiration time.
// Subsecond precision is ignored.
// This is not set when getting items.
Expiration time.Duration
// casID is a client-opaque value used for compare-and-swap operations.
// Zero means that compare-and-swap is not used.
casID uint64
}
const (
secondsIn30Years = 60 * 60 * 24 * 365 * 30 // from memcache server code
thirtyYears = time.Duration(secondsIn30Years) * time.Second
)
// protoToItem converts a protocol buffer item to a Go struct.
func protoToItem(p *pb.MemcacheGetResponse_Item) *Item {
return &Item{
Key: string(p.Key),
Value: p.Value,
Flags: p.GetFlags(),
casID: p.GetCasId(),
}
}
// If err is an appengine.MultiError, return its first element. Otherwise, return err.
func singleError(err error) error {
if me, ok := err.(appengine.MultiError); ok {
return me[0]
}
return err
}
// Get gets the item for the given key. ErrCacheMiss is returned for a memcache
// cache miss. The key must be at most 250 bytes in length.
func Get(c context.Context, key string) (*Item, error) {
m, err := GetMulti(c, []string{key})
if err != nil {
return nil, err
}
if _, ok := m[key]; !ok {
return nil, ErrCacheMiss
}
return m[key], nil
}
// GetMulti is a batch version of Get. The returned map from keys to items may
// have fewer elements than the input slice, due to memcache cache misses.
// Each key must be at most 250 bytes in length.
func GetMulti(c context.Context, key []string) (map[string]*Item, error) {
if len(key) == 0 {
return nil, nil
}
keyAsBytes := make([][]byte, len(key))
for i, k := range key {
keyAsBytes[i] = []byte(k)
}
req := &pb.MemcacheGetRequest{
Key: keyAsBytes,
ForCas: proto.Bool(true),
}
res := &pb.MemcacheGetResponse{}
if err := internal.Call(c, "memcache", "Get", req, res); err != nil {
return nil, err
}
m := make(map[string]*Item, len(res.Item))
for _, p := range res.Item {
t := protoToItem(p)
m[t.Key] = t
}
return m, nil
}
// Delete deletes the item for the given key.
// ErrCacheMiss is returned if the specified item can not be found.
// The key must be at most 250 bytes in length.
func Delete(c context.Context, key string) error {
return singleError(DeleteMulti(c, []string{key}))
}
// DeleteMulti is a batch version of Delete.
// If any keys cannot be found, an appengine.MultiError is returned.
// Each key must be at most 250 bytes in length.
func DeleteMulti(c context.Context, key []string) error {
if len(key) == 0 {
return nil
}
req := &pb.MemcacheDeleteRequest{
Item: make([]*pb.MemcacheDeleteRequest_Item, len(key)),
}
for i, k := range key {
req.Item[i] = &pb.MemcacheDeleteRequest_Item{Key: []byte(k)}
}
res := &pb.MemcacheDeleteResponse{}
if err := internal.Call(c, "memcache", "Delete", req, res); err != nil {
return err
}
if len(res.DeleteStatus) != len(key) {
return ErrServerError
}
me, any := make(appengine.MultiError, len(key)), false
for i, s := range res.DeleteStatus {
switch s {
case pb.MemcacheDeleteResponse_DELETED:
// OK
case pb.MemcacheDeleteResponse_NOT_FOUND:
me[i] = ErrCacheMiss
any = true
default:
me[i] = ErrServerError
any = true
}
}
if any {
return me
}
return nil
}
// Increment atomically increments the decimal value in the given key
// by delta and returns the new value. The value must fit in a uint64.
// Overflow wraps around, and underflow is capped to zero. The
// provided delta may be negative. If the key doesn't exist in
// memcache, the provided initial value is used to atomically
// populate it before the delta is applied.
// The key must be at most 250 bytes in length.
func Increment(c context.Context, key string, delta int64, initialValue uint64) (newValue uint64, err error) {
return incr(c, key, delta, &initialValue)
}
// IncrementExisting works like Increment but assumes that the key
// already exists in memcache and doesn't take an initial value.
// IncrementExisting can save work if calculating the initial value is
// expensive.
// An error is returned if the specified item can not be found.
func IncrementExisting(c context.Context, key string, delta int64) (newValue uint64, err error) {
return incr(c, key, delta, nil)
}
func incr(c context.Context, key string, delta int64, initialValue *uint64) (newValue uint64, err error) {
req := &pb.MemcacheIncrementRequest{
Key: []byte(key),
InitialValue: initialValue,
}
if delta >= 0 {
req.Delta = proto.Uint64(uint64(delta))
} else {
req.Delta = proto.Uint64(uint64(-delta))
req.Direction = pb.MemcacheIncrementRequest_DECREMENT.Enum()
}
res := &pb.MemcacheIncrementResponse{}
err = internal.Call(c, "memcache", "Increment", req, res)
if err != nil {
return
}
if res.NewValue == nil {
return 0, ErrCacheMiss
}
return *res.NewValue, nil
}
// set sets the given items using the given conflict resolution policy.
// appengine.MultiError may be returned.
func set(c context.Context, item []*Item, value [][]byte, policy pb.MemcacheSetRequest_SetPolicy) error {
if len(item) == 0 {
return nil
}
req := &pb.MemcacheSetRequest{
Item: make([]*pb.MemcacheSetRequest_Item, len(item)),
}
for i, t := range item {
p := &pb.MemcacheSetRequest_Item{
Key: []byte(t.Key),
}
if value == nil {
p.Value = t.Value
} else {
p.Value = value[i]
}
if t.Flags != 0 {
p.Flags = proto.Uint32(t.Flags)
}
if t.Expiration != 0 {
// In the .proto file, MemcacheSetRequest_Item uses a fixed32 (i.e. unsigned)
// for expiration time, while MemcacheGetRequest_Item uses int32 (i.e. signed).
// Throughout this .go file, we use int32.
// Also, in the proto, the expiration value is either a duration (in seconds)
// or an absolute Unix timestamp (in seconds), depending on whether the
// value is less than or greater than or equal to 30 years, respectively.
if t.Expiration < time.Second {
// Because an Expiration of 0 means no expiration, we take
// care here to translate an item with an expiration
// Duration between 0-1 seconds as immediately expiring
// (saying it expired a few seconds ago), rather than
// rounding it down to 0 and making it live forever.
p.ExpirationTime = proto.Uint32(uint32(time.Now().Unix()) - 5)
} else if t.Expiration >= thirtyYears {
p.ExpirationTime = proto.Uint32(uint32(time.Now().Unix()) + uint32(t.Expiration/time.Second))
} else {
p.ExpirationTime = proto.Uint32(uint32(t.Expiration / time.Second))
}
}
if t.casID != 0 {
p.CasId = proto.Uint64(t.casID)
p.ForCas = proto.Bool(true)
}
p.SetPolicy = policy.Enum()
req.Item[i] = p
}
res := &pb.MemcacheSetResponse{}
if err := internal.Call(c, "memcache", "Set", req, res); err != nil {
return err
}
if len(res.SetStatus) != len(item) {
return ErrServerError
}
me, any := make(appengine.MultiError, len(item)), false
for i, st := range res.SetStatus {
var err error
switch st {
case pb.MemcacheSetResponse_STORED:
// OK
case pb.MemcacheSetResponse_NOT_STORED:
err = ErrNotStored
case pb.MemcacheSetResponse_EXISTS:
err = ErrCASConflict
default:
err = ErrServerError
}
if err != nil {
me[i] = err
any = true
}
}
if any {
return me
}
return nil
}
// Set writes the given item, unconditionally.
func Set(c context.Context, item *Item) error {
return singleError(set(c, []*Item{item}, nil, pb.MemcacheSetRequest_SET))
}
// SetMulti is a batch version of Set.
// appengine.MultiError may be returned.
func SetMulti(c context.Context, item []*Item) error {
return set(c, item, nil, pb.MemcacheSetRequest_SET)
}
// Add writes the given item, if no value already exists for its key.
// ErrNotStored is returned if that condition is not met.
func Add(c context.Context, item *Item) error {
return singleError(set(c, []*Item{item}, nil, pb.MemcacheSetRequest_ADD))
}
// AddMulti is a batch version of Add.
// appengine.MultiError may be returned.
func AddMulti(c context.Context, item []*Item) error {
return set(c, item, nil, pb.MemcacheSetRequest_ADD)
}
// CompareAndSwap writes the given item that was previously returned by Get,
// if the value was neither modified or evicted between the Get and the
// CompareAndSwap calls. The item's Key should not change between calls but
// all other item fields may differ.
// ErrCASConflict is returned if the value was modified in between the calls.
// ErrNotStored is returned if the value was evicted in between the calls.
func CompareAndSwap(c context.Context, item *Item) error {
return singleError(set(c, []*Item{item}, nil, pb.MemcacheSetRequest_CAS))
}
// CompareAndSwapMulti is a batch version of CompareAndSwap.
// appengine.MultiError may be returned.
func CompareAndSwapMulti(c context.Context, item []*Item) error {
return set(c, item, nil, pb.MemcacheSetRequest_CAS)
}
// Codec represents a symmetric pair of functions that implement a codec.
// Items stored into or retrieved from memcache using a Codec have their
// values marshaled or unmarshaled.
//
// All the methods provided for Codec behave analogously to the package level
// function with same name.
type Codec struct {
Marshal func(interface{}) ([]byte, error)
Unmarshal func([]byte, interface{}) error
}
// Get gets the item for the given key and decodes the obtained value into v.
// ErrCacheMiss is returned for a memcache cache miss.
// The key must be at most 250 bytes in length.
func (cd Codec) Get(c context.Context, key string, v interface{}) (*Item, error) {
i, err := Get(c, key)
if err != nil {
return nil, err
}
if err := cd.Unmarshal(i.Value, v); err != nil {
return nil, err
}
return i, nil
}
func (cd Codec) set(c context.Context, items []*Item, policy pb.MemcacheSetRequest_SetPolicy) error {
var vs [][]byte
var me appengine.MultiError
for i, item := range items {
v, err := cd.Marshal(item.Object)
if err != nil {
if me == nil {
me = make(appengine.MultiError, len(items))
}
me[i] = err
continue
}
if me == nil {
vs = append(vs, v)
}
}
if me != nil {
return me
}
return set(c, items, vs, policy)
}
// Set writes the given item, unconditionally.
func (cd Codec) Set(c context.Context, item *Item) error {
return singleError(cd.set(c, []*Item{item}, pb.MemcacheSetRequest_SET))
}
// SetMulti is a batch version of Set.
// appengine.MultiError may be returned.
func (cd Codec) SetMulti(c context.Context, items []*Item) error {
return cd.set(c, items, pb.MemcacheSetRequest_SET)
}
// Add writes the given item, if no value already exists for its key.
// ErrNotStored is returned if that condition is not met.
func (cd Codec) Add(c context.Context, item *Item) error {
return singleError(cd.set(c, []*Item{item}, pb.MemcacheSetRequest_ADD))
}
// AddMulti is a batch version of Add.
// appengine.MultiError may be returned.
func (cd Codec) AddMulti(c context.Context, items []*Item) error {
return cd.set(c, items, pb.MemcacheSetRequest_ADD)
}
// CompareAndSwap writes the given item that was previously returned by Get,
// if the value was neither modified or evicted between the Get and the
// CompareAndSwap calls. The item's Key should not change between calls but
// all other item fields may differ.
// ErrCASConflict is returned if the value was modified in between the calls.
// ErrNotStored is returned if the value was evicted in between the calls.
func (cd Codec) CompareAndSwap(c context.Context, item *Item) error {
return singleError(cd.set(c, []*Item{item}, pb.MemcacheSetRequest_CAS))
}
// CompareAndSwapMulti is a batch version of CompareAndSwap.
// appengine.MultiError may be returned.
func (cd Codec) CompareAndSwapMulti(c context.Context, items []*Item) error {
return cd.set(c, items, pb.MemcacheSetRequest_CAS)
}
var (
// Gob is a Codec that uses the gob package.
Gob = Codec{gobMarshal, gobUnmarshal}
// JSON is a Codec that uses the json package.
JSON = Codec{json.Marshal, json.Unmarshal}
)
func gobMarshal(v interface{}) ([]byte, error) {
var buf bytes.Buffer
if err := gob.NewEncoder(&buf).Encode(v); err != nil {
return nil, err
}
return buf.Bytes(), nil
}
func gobUnmarshal(data []byte, v interface{}) error {
return gob.NewDecoder(bytes.NewBuffer(data)).Decode(v)
}
// Statistics represents a set of statistics about the memcache cache.
// This may include items that have expired but have not yet been removed from the cache.
type Statistics struct {
Hits uint64 // Counter of cache hits
Misses uint64 // Counter of cache misses
ByteHits uint64 // Counter of bytes transferred for gets
Items uint64 // Items currently in the cache
Bytes uint64 // Size of all items currently in the cache
Oldest int64 // Age of access of the oldest item, in seconds
}
// Stats retrieves the current memcache statistics.
func Stats(c context.Context) (*Statistics, error) {
req := &pb.MemcacheStatsRequest{}
res := &pb.MemcacheStatsResponse{}
if err := internal.Call(c, "memcache", "Stats", req, res); err != nil {
return nil, err
}
if res.Stats == nil {
return nil, ErrNoStats
}
return &Statistics{
Hits: *res.Stats.Hits,
Misses: *res.Stats.Misses,
ByteHits: *res.Stats.ByteHits,
Items: *res.Stats.Items,
Bytes: *res.Stats.Bytes,
Oldest: int64(*res.Stats.OldestItemAge),
}, nil
}
// Flush flushes all items from memcache.
func Flush(c context.Context) error {
req := &pb.MemcacheFlushRequest{}
res := &pb.MemcacheFlushResponse{}
return internal.Call(c, "memcache", "FlushAll", req, res)
}
func namespaceMod(m proto.Message, namespace string) {
switch m := m.(type) {
case *pb.MemcacheDeleteRequest:
if m.NameSpace == nil {
m.NameSpace = &namespace
}
case *pb.MemcacheGetRequest:
if m.NameSpace == nil {
m.NameSpace = &namespace
}
case *pb.MemcacheIncrementRequest:
if m.NameSpace == nil {
m.NameSpace = &namespace
}
case *pb.MemcacheSetRequest:
if m.NameSpace == nil {
m.NameSpace = &namespace
}
// MemcacheFlushRequest, MemcacheStatsRequest do not apply namespace.
}
}
func init() {
internal.RegisterErrorCodeMap("memcache", pb.MemcacheServiceError_ErrorCode_name)
internal.NamespaceMods["memcache"] = namespaceMod
}
================================================
FILE: vendor/google.golang.org/appengine/module/module.go
================================================
// Copyright 2013 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
/*
Package module provides functions for interacting with modules.
The appengine package contains functions that report the identity of the app,
including the module name.
*/
package module
import (
"github.com/golang/protobuf/proto"
"golang.org/x/net/context"
"google.golang.org/appengine/internal"
pb "google.golang.org/appengine/internal/modules"
)
// List returns the names of modules belonging to this application.
func List(c context.Context) ([]string, error) {
req := &pb.GetModulesRequest{}
res := &pb.GetModulesResponse{}
err := internal.Call(c, "modules", "GetModules", req, res)
return res.Module, err
}
// NumInstances returns the number of instances of the given module/version.
// If either argument is the empty string it means the default.
func NumInstances(c context.Context, module, version string) (int, error) {
req := &pb.GetNumInstancesRequest{}
if module != "" {
req.Module = &module
}
if version != "" {
req.Version = &version
}
res := &pb.GetNumInstancesResponse{}
if err := internal.Call(c, "modules", "GetNumInstances", req, res); err != nil {
return 0, err
}
return int(*res.Instances), nil
}
// SetNumInstances sets the number of instances of the given module.version to the
// specified value. If either module or version are the empty string it means the
// default.
func SetNumInstances(c context.Context, module, version string, instances int) error {
req := &pb.SetNumInstancesRequest{}
if module != "" {
req.Module = &module
}
if version != "" {
req.Version = &version
}
req.Instances = proto.Int64(int64(instances))
res := &pb.SetNumInstancesResponse{}
return internal.Call(c, "modules", "SetNumInstances", req, res)
}
// Versions returns the names of the versions that belong to the specified module.
// If module is the empty string, it means the default module.
func Versions(c context.Context, module string) ([]string, error) {
req := &pb.GetVersionsRequest{}
if module != "" {
req.Module = &module
}
res := &pb.GetVersionsResponse{}
err := internal.Call(c, "modules", "GetVersions", req, res)
return res.GetVersion(), err
}
// DefaultVersion returns the default version of the specified module.
// If module is the empty string, it means the default module.
func DefaultVersion(c context.Context, module string) (string, error) {
req := &pb.GetDefaultVersionRequest{}
if module != "" {
req.Module = &module
}
res := &pb.GetDefaultVersionResponse{}
err := internal.Call(c, "modules", "GetDefaultVersion", req, res)
return res.GetVersion(), err
}
// Start starts the specified version of the specified module.
// If either module or version are the empty string, it means the default.
func Start(c context.Context, module, version string) error {
req := &pb.StartModuleRequest{}
if module != "" {
req.Module = &module
}
if version != "" {
req.Version = &version
}
res := &pb.StartModuleResponse{}
return internal.Call(c, "modules", "StartModule", req, res)
}
// Stop stops the specified version of the specified module.
// If either module or version are the empty string, it means the default.
func Stop(c context.Context, module, version string) error {
req := &pb.StopModuleRequest{}
if module != "" {
req.Module = &module
}
if version != "" {
req.Version = &version
}
res := &pb.StopModuleResponse{}
return internal.Call(c, "modules", "StopModule", req, res)
}
================================================
FILE: vendor/google.golang.org/appengine/namespace.go
================================================
// Copyright 2012 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
package appengine
import (
"fmt"
"regexp"
"golang.org/x/net/context"
"google.golang.org/appengine/internal"
)
// Namespace returns a replacement context that operates within the given namespace.
func Namespace(c context.Context, namespace string) (context.Context, error) {
if !validNamespace.MatchString(namespace) {
return nil, fmt.Errorf("appengine: namespace %q does not match /%s/", namespace, validNamespace)
}
return internal.NamespacedContext(c, namespace), nil
}
// validNamespace matches valid namespace names.
var validNamespace = regexp.MustCompile(`^[0-9A-Za-z._-]{0,100}$`)
================================================
FILE: vendor/google.golang.org/appengine/remote_api/client.go
================================================
// Copyright 2013 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
package remote_api
// This file provides the client for connecting remotely to a user's production
// application.
import (
"bytes"
"fmt"
"io/ioutil"
"log"
"math/rand"
"net/http"
"net/url"
"regexp"
"strconv"
"strings"
"time"
"github.com/golang/protobuf/proto"
"golang.org/x/net/context"
"google.golang.org/appengine/internal"
pb "google.golang.org/appengine/internal/remote_api"
)
// NewRemoteContext returns a context that gives access to the production
// APIs for the application at the given host. All communication will be
// performed over SSL unless the host is localhost.
func NewRemoteContext(host string, client *http.Client) (context.Context, error) {
// Add an appcfg header to outgoing requests.
t := client.Transport
if t == nil {
t = http.DefaultTransport
}
client.Transport = &headerAddingRoundTripper{t}
url := url.URL{
Scheme: "https",
Host: host,
Path: "/_ah/remote_api",
}
if host == "localhost" || strings.HasPrefix(host, "localhost:") {
url.Scheme = "http"
}
u := url.String()
appID, err := getAppID(client, u)
if err != nil {
return nil, fmt.Errorf("unable to contact server: %v", err)
}
rc := &remoteContext{
client: client,
url: u,
}
ctx := internal.WithCallOverride(context.Background(), rc.call)
ctx = internal.WithLogOverride(ctx, rc.logf)
ctx = internal.WithAppIDOverride(ctx, appID)
return ctx, nil
}
type remoteContext struct {
client *http.Client
url string
}
var logLevels = map[int64]string{
0: "DEBUG",
1: "INFO",
2: "WARNING",
3: "ERROR",
4: "CRITICAL",
}
func (c *remoteContext) logf(level int64, format string, args ...interface{}) {
log.Printf(logLevels[level]+": "+format, args...)
}
func (c *remoteContext) call(ctx context.Context, service, method string, in, out proto.Message) error {
req, err := proto.Marshal(in)
if err != nil {
return fmt.Errorf("error marshalling request: %v", err)
}
remReq := &pb.Request{
ServiceName: proto.String(service),
Method: proto.String(method),
Request: req,
// NOTE(djd): RequestId is unused in the server.
}
req, err = proto.Marshal(remReq)
if err != nil {
return fmt.Errorf("proto.Marshal: %v", err)
}
// TODO(djd): Respect ctx.Deadline()?
resp, err := c.client.Post(c.url, "application/octet-stream", bytes.NewReader(req))
if err != nil {
return fmt.Errorf("error sending request: %v", err)
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if resp.StatusCode != http.StatusOK {
return fmt.Errorf("bad response %d; body: %q", resp.StatusCode, body)
}
if err != nil {
return fmt.Errorf("failed reading response: %v", err)
}
remResp := &pb.Response{}
if err := proto.Unmarshal(body, remResp); err != nil {
return fmt.Errorf("error unmarshalling response: %v", err)
}
if ae := remResp.GetApplicationError(); ae != nil {
return &internal.APIError{
Code: ae.GetCode(),
Detail: ae.GetDetail(),
Service: service,
}
}
if remResp.Response == nil {
return fmt.Errorf("unexpected response: %s", proto.MarshalTextString(remResp))
}
return proto.Unmarshal(remResp.Response, out)
}
// This is a forgiving regexp designed to parse the app ID from YAML.
var appIDRE = regexp.MustCompile(`app_id["']?\s*:\s*['"]?([-a-z0-9.:~]+)`)
func getAppID(client *http.Client, url string) (string, error) {
// Generate a pseudo-random token for handshaking.
token := strconv.Itoa(rand.New(rand.NewSource(time.Now().UnixNano())).Int())
resp, err := client.Get(fmt.Sprintf("%s?rtok=%s", url, token))
if err != nil {
return "", err
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if resp.StatusCode != http.StatusOK {
return "", fmt.Errorf("bad response %d; body: %q", resp.StatusCode, body)
}
if err != nil {
return "", fmt.Errorf("failed reading response: %v", err)
}
// Check the token is present in response.
if !bytes.Contains(body, []byte(token)) {
return "", fmt.Errorf("token not found: want %q; body %q", token, body)
}
match := appIDRE.FindSubmatch(body)
if match == nil {
return "", fmt.Errorf("app ID not found: body %q", body)
}
return string(match[1]), nil
}
type headerAddingRoundTripper struct {
Wrapped http.RoundTripper
}
func (t *headerAddingRoundTripper) RoundTrip(r *http.Request) (*http.Response, error) {
r.Header.Set("X-Appcfg-Api-Version", "1")
return t.Wrapped.RoundTrip(r)
}
================================================
FILE: vendor/google.golang.org/appengine/remote_api/remote_api.go
================================================
// Copyright 2012 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
/*
Package remote_api implements the /_ah/remote_api endpoint.
This endpoint is used by offline tools such as the bulk loader.
*/
package remote_api
import (
"fmt"
"io"
"io/ioutil"
"net/http"
"strconv"
"github.com/golang/protobuf/proto"
"google.golang.org/appengine"
"google.golang.org/appengine/internal"
pb "google.golang.org/appengine/internal/remote_api"
"google.golang.org/appengine/log"
"google.golang.org/appengine/user"
)
func init() {
http.HandleFunc("/_ah/remote_api", handle)
}
func handle(w http.ResponseWriter, req *http.Request) {
c := appengine.NewContext(req)
u := user.Current(c)
if u == nil {
u, _ = user.CurrentOAuth(c,
"https://www.googleapis.com/auth/cloud-platform",
"https://www.googleapis.com/auth/appengine.apis",
)
}
if u == nil || !u.Admin {
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
w.WriteHeader(http.StatusUnauthorized)
io.WriteString(w, "You must be logged in as an administrator to access this.\n")
return
}
if req.Header.Get("X-Appcfg-Api-Version") == "" {
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
w.WriteHeader(http.StatusForbidden)
io.WriteString(w, "This request did not contain a necessary header.\n")
return
}
if req.Method != "POST" {
// Response must be YAML.
rtok := req.FormValue("rtok")
if rtok == "" {
rtok = "0"
}
w.Header().Set("Content-Type", "text/yaml; charset=utf-8")
fmt.Fprintf(w, `{app_id: %q, rtok: %q}`, internal.FullyQualifiedAppID(c), rtok)
return
}
defer req.Body.Close()
body, err := ioutil.ReadAll(req.Body)
if err != nil {
w.WriteHeader(http.StatusBadRequest)
log.Errorf(c, "Failed reading body: %v", err)
return
}
remReq := &pb.Request{}
if err := proto.Unmarshal(body, remReq); err != nil {
w.WriteHeader(http.StatusBadRequest)
log.Errorf(c, "Bad body: %v", err)
return
}
service, method := *remReq.ServiceName, *remReq.Method
if !requestSupported(service, method) {
w.WriteHeader(http.StatusBadRequest)
log.Errorf(c, "Unsupported RPC /%s.%s", service, method)
return
}
rawReq := &rawMessage{remReq.Request}
rawRes := &rawMessage{}
err = internal.Call(c, service, method, rawReq, rawRes)
remRes := &pb.Response{}
if err == nil {
remRes.Response = rawRes.buf
} else if ae, ok := err.(*internal.APIError); ok {
remRes.ApplicationError = &pb.ApplicationError{
Code: &ae.Code,
Detail: &ae.Detail,
}
} else {
// This shouldn't normally happen.
log.Errorf(c, "appengine/remote_api: Unexpected error of type %T: %v", err, err)
remRes.ApplicationError = &pb.ApplicationError{
Code: proto.Int32(0),
Detail: proto.String(err.Error()),
}
}
out, err := proto.Marshal(remRes)
if err != nil {
// This should not be possible.
w.WriteHeader(500)
log.Errorf(c, "proto.Marshal: %v", err)
return
}
log.Infof(c, "Spooling %d bytes of response to /%s.%s", len(out), service, method)
w.Header().Set("Content-Type", "application/octet-stream")
w.Header().Set("Content-Length", strconv.Itoa(len(out)))
w.Write(out)
}
// rawMessage is a protocol buffer type that is already serialised.
// This allows the remote_api code here to handle messages
// without having to know the real type.
type rawMessage struct {
buf []byte
}
func (rm *rawMessage) Marshal() ([]byte, error) {
return rm.buf, nil
}
func (rm *rawMessage) Unmarshal(buf []byte) error {
rm.buf = make([]byte, len(buf))
copy(rm.buf, buf)
return nil
}
func requestSupported(service, method string) bool {
// This list of supported services is taken from SERVICE_PB_MAP in remote_api_services.py
switch service {
case "app_identity_service", "blobstore", "capability_service", "channel", "datastore_v3",
"datastore_v4", "file", "images", "logservice", "mail", "matcher", "memcache", "remote_datastore",
"remote_socket", "search", "modules", "system", "taskqueue", "urlfetch", "user", "xmpp":
return true
}
return false
}
// Methods to satisfy proto.Message.
func (rm *rawMessage) Reset() { rm.buf = nil }
func (rm *rawMessage) String() string { return strconv.Quote(string(rm.buf)) }
func (*rawMessage) ProtoMessage() {}
================================================
FILE: vendor/google.golang.org/appengine/runtime/runtime.go
================================================
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
/*
Package runtime exposes information about the resource usage of the application.
It also provides a way to run code in a new background context of a module.
This package does not work on Managed VMs.
*/
package runtime
import (
"net/http"
"golang.org/x/net/context"
"google.golang.org/appengine"
"google.golang.org/appengine/internal"
pb "google.golang.org/appengine/internal/system"
)
// Statistics represents the system's statistics.
type Statistics struct {
// CPU records the CPU consumed by this instance, in megacycles.
CPU struct {
Total float64
Rate1M float64 // consumption rate over one minute
Rate10M float64 // consumption rate over ten minutes
}
// RAM records the memory used by the instance, in megabytes.
RAM struct {
Current float64
Average1M float64 // average usage over one minute
Average10M float64 // average usage over ten minutes
}
}
func Stats(c context.Context) (*Statistics, error) {
req := &pb.GetSystemStatsRequest{}
res := &pb.GetSystemStatsResponse{}
if err := internal.Call(c, "system", "GetSystemStats", req, res); err != nil {
return nil, err
}
s := &Statistics{}
if res.Cpu != nil {
s.CPU.Total = res.Cpu.GetTotal()
s.CPU.Rate1M = res.Cpu.GetRate1M()
s.CPU.Rate10M = res.Cpu.GetRate10M()
}
if res.Memory != nil {
s.RAM.Current = res.Memory.GetCurrent()
s.RAM.Average1M = res.Memory.GetAverage1M()
s.RAM.Average10M = res.Memory.GetAverage10M()
}
return s, nil
}
/*
RunInBackground makes an API call that triggers an /_ah/background request.
There are two independent code paths that need to make contact:
the RunInBackground code, and the /_ah/background handler. The matchmaker
loop arranges for the two paths to meet. The RunInBackground code passes
a send to the matchmaker, the /_ah/background passes a recv to the matchmaker,
and the matchmaker hooks them up.
*/
func init() {
http.HandleFunc("/_ah/background", handleBackground)
sc := make(chan send)
rc := make(chan recv)
sendc, recvc = sc, rc
go matchmaker(sc, rc)
}
var (
sendc chan<- send // RunInBackground sends to this
recvc chan<- recv // handleBackground sends to this
)
type send struct {
id string
f func(context.Context)
}
type recv struct {
id string
ch chan<- func(context.Context)
}
func matchmaker(sendc <-chan send, recvc <-chan recv) {
// When one side of the match arrives before the other
// it is inserted in the corresponding map.
waitSend := make(map[string]send)
waitRecv := make(map[string]recv)
for {
select {
case s := <-sendc:
if r, ok := waitRecv[s.id]; ok {
// meet!
delete(waitRecv, s.id)
r.ch <- s.f
} else {
// waiting for r
waitSend[s.id] = s
}
case r := <-recvc:
if s, ok := waitSend[r.id]; ok {
// meet!
delete(waitSend, r.id)
r.ch <- s.f
} else {
// waiting for s
waitRecv[r.id] = r
}
}
}
}
var newContext = appengine.NewContext // for testing
func handleBackground(w http.ResponseWriter, req *http.Request) {
id := req.Header.Get("X-AppEngine-BackgroundRequest")
ch := make(chan func(context.Context))
recvc <- recv{id, ch}
(<-ch)(newContext(req))
}
// RunInBackground runs f in a background goroutine in this process.
// f is provided a context that may outlast the context provided to RunInBackground.
// This is only valid to invoke from a manually scaled module.
func RunInBackground(c context.Context, f func(c context.Context)) error {
req := &pb.StartBackgroundRequestRequest{}
res := &pb.StartBackgroundRequestResponse{}
if err := internal.Call(c, "system", "StartBackgroundRequest", req, res); err != nil {
return err
}
sendc <- send{res.GetRequestId(), f}
return nil
}
func init() {
internal.RegisterErrorCodeMap("system", pb.SystemServiceError_ErrorCode_name)
}
================================================
FILE: vendor/google.golang.org/appengine/search/doc.go
================================================
// Copyright 2015 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
/*
Package search provides a client for App Engine's search service.
Basic Operations
Indexes contain documents. Each index is identified by its name: a
human-readable ASCII string.
Within an index, documents are associated with an ID, which is also
a human-readable ASCII string. A document's contents are a mapping from
case-sensitive field names to values. Valid types for field values are:
- string,
- search.Atom,
- search.HTML,
- time.Time (stored with millisecond precision),
- float64 (value between -2,147,483,647 and 2,147,483,647 inclusive),
- appengine.GeoPoint.
The Get and Put methods on an Index load and save a document.
A document's contents are typically represented by a struct pointer.
Example code:
type Doc struct {
Author string
Comment string
Creation time.Time
}
index, err := search.Open("comments")
if err != nil {
return err
}
newID, err := index.Put(ctx, "", &Doc{
Author: "gopher",
Comment: "the truth of the matter",
Creation: time.Now(),
})
if err != nil {
return err
}
A single document can be retrieved by its ID. Pass a destination struct
to Get to hold the resulting document.
var doc Doc
err := index.Get(ctx, id, &doc)
if err != nil {
return err
}
Search and Listing Documents
Indexes have two methods for retrieving multiple documents at once: Search and
List.
Searching an index for a query will result in an iterator. As with an iterator
from package datastore, pass a destination struct to Next to decode the next
result. Next will return Done when the iterator is exhausted.
for t := index.Search(ctx, "Comment:truth", nil); ; {
var doc Doc
id, err := t.Next(&doc)
if err == search.Done {
break
}
if err != nil {
return err
}
fmt.Fprintf(w, "%s -> %#v\n", id, doc)
}
Search takes a string query to determine which documents to return. The query
can be simple, such as a single word to match, or complex. The query
language is described at
https://cloud.google.com/appengine/docs/go/search/query_strings
Search also takes an optional SearchOptions struct which gives much more
control over how results are calculated and returned.
Call List to iterate over all documents in an index.
for t := index.List(ctx, nil); ; {
var doc Doc
id, err := t.Next(&doc)
if err == search.Done {
break
}
if err != nil {
return err
}
fmt.Fprintf(w, "%s -> %#v\n", id, doc)
}
Fields and Facets
A document's contents can be represented by a variety of types. These are
typically struct pointers, but they can also be represented by any type
implementing the FieldLoadSaver interface. The FieldLoadSaver allows metadata
to be set for the document with the DocumentMetadata type. Struct pointers are
more strongly typed and are easier to use; FieldLoadSavers are more flexible.
A document's contents can be expressed in two ways: fields and facets.
Fields are the most common way of providing content for documents. Fields can
store data in multiple types and can be matched in searches using query
strings.
Facets provide a way to attach categorical information to a document. The only
valid types for facets are search.Atom and float64. Facets allow search
results to contain summaries of the categories matched in a search, and to
restrict searches to only match against specific categories.
By default, for struct pointers, all of the struct fields are used as document
fields, and the field name used is the same as on the struct (and hence must
start with an upper case letter). Struct fields may have a
`search:"name,options"` tag. The name must start with a letter and be
composed only of word characters. If options is "facet" then the struct
field will be used as a document facet. If options is "" then the comma
may be omitted. There are no other recognized options.
Example code:
// A and B are renamed to a and b.
// A, C and I are facets.
// D's tag is equivalent to having no tag at all (E).
// I has tag information for both the search and json packages.
type TaggedStruct struct {
A float64 `search:"a,facet"`
B float64 `search:"b"`
C float64 `search:",facet"`
D float64 `search:""`
E float64
I float64 `search:",facet" json:"i"`
}
The FieldLoadSaver Interface
A document's contents can also be represented by any type that implements the
FieldLoadSaver interface. This type may be a struct pointer, but it
does not have to be. The search package will call Load when loading the
document's contents, and Save when saving them. In addition to a slice of
Fields, the Load and Save methods also use the DocumentMetadata type to
provide additional information about a document (such as its Rank, or set of
Facets). Possible uses for this interface include deriving non-stored fields,
verifying fields or setting specific languages for string and HTML fields.
Example code:
type CustomFieldsExample struct {
// Item's title and which language it is in.
Title string
Lang string
// Mass, in grams.
Mass int
}
func (x *CustomFieldsExample) Load(fields []search.Field, meta *search.DocumentMetadata) error {
// Load the title field, failing if any other field is found.
for _, f := range fields {
if f.Name != "title" {
return fmt.Errorf("unknown field %q", f.Name)
}
s, ok := f.Value.(string)
if !ok {
return fmt.Errorf("unsupported type %T for field %q", f.Value, f.Name)
}
x.Title = s
x.Lang = f.Language
}
// Load the mass facet, failing if any other facet is found.
for _, f := range meta.Facets {
if f.Name != "mass" {
return fmt.Errorf("unknown facet %q", f.Name)
}
m, ok := f.Value.(float64)
if !ok {
return fmt.Errorf("unsupported type %T for facet %q", f.Value, f.Name)
}
x.Mass = int(m)
}
return nil
}
func (x *CustomFieldsExample) Save() ([]search.Field, *search.DocumentMetadata, error) {
fields := []search.Field{
{Name: "title", Value: x.Title, Language: x.Lang},
}
meta := &search.DocumentMetadata{
Facets: {
{Name: "mass", Value: float64(x.Mass)},
},
}
return fields, meta, nil
}
*/
package search
================================================
FILE: vendor/google.golang.org/appengine/search/field.go
================================================
// Copyright 2014 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
package search
// Field is a name/value pair. A search index's document can be loaded and
// saved as a sequence of Fields.
type Field struct {
// Name is the field name. A valid field name matches /[A-Za-z][A-Za-z0-9_]*/.
Name string
// Value is the field value. The valid types are:
// - string,
// - search.Atom,
// - search.HTML,
// - time.Time (stored with millisecond precision),
// - float64,
// - GeoPoint.
Value interface{}
// Language is a two-letter ISO 639-1 code for the field's language,
// defaulting to "en" if nothing is specified. It may only be specified for
// fields of type string and search.HTML.
Language string
// Derived marks fields that were calculated as a result of a
// FieldExpression provided to Search. This field is ignored when saving a
// document.
Derived bool
}
// Facet is a name/value pair which is used to add categorical information to a
// document.
type Facet struct {
// Name is the facet name. A valid facet name matches /[A-Za-z][A-Za-z0-9_]*/.
// A facet name cannot be longer than 500 characters.
Name string
// Value is the facet value.
//
// When being used in documents (for example, in
// DocumentMetadata.Facets), the valid types are:
// - search.Atom,
// - float64.
//
// When being used in SearchOptions.Refinements or being returned
// in FacetResult, the valid types are:
// - search.Atom,
// - search.Range.
Value interface{}
}
// DocumentMetadata is a struct containing information describing a given document.
type DocumentMetadata struct {
// Rank is an integer specifying the order the document will be returned in
// search results. If zero, the rank will be set to the number of seconds since
// 2011-01-01 00:00:00 UTC when being Put into an index.
Rank int
// Facets is the set of facets for this document.
Facets []Facet
}
// FieldLoadSaver can be converted from and to a slice of Fields
// with additional document metadata.
type FieldLoadSaver interface {
Load([]Field, *DocumentMetadata) error
Save() ([]Field, *DocumentMetadata, error)
}
// FieldList converts a []Field to implement FieldLoadSaver.
type FieldList []Field
// Load loads all of the provided fields into l.
// It does not first reset *l to an empty slice.
func (l *FieldList) Load(f []Field, _ *DocumentMetadata) error {
*l = append(*l, f...)
return nil
}
// Save returns all of l's fields as a slice of Fields.
func (l *FieldList) Save() ([]Field, *DocumentMetadata, error) {
return *l, nil, nil
}
var _ FieldLoadSaver = (*FieldList)(nil)
================================================
FILE: vendor/google.golang.org/appengine/search/search.go
================================================
// Copyright 2012 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
package search
// TODO: let Put specify the document language: "en", "fr", etc. Also: order_id?? storage??
// TODO: Index.GetAll (or Iterator.GetAll)?
// TODO: struct <-> protobuf tests.
// TODO: enforce Python's MIN_NUMBER_VALUE and MIN_DATE (which would disallow a zero
// time.Time)? _MAXIMUM_STRING_LENGTH?
import (
"errors"
"fmt"
"math"
"reflect"
"regexp"
"strconv"
"strings"
"time"
"unicode/utf8"
"github.com/golang/protobuf/proto"
"golang.org/x/net/context"
"google.golang.org/appengine"
"google.golang.org/appengine/internal"
pb "google.golang.org/appengine/internal/search"
)
var (
// ErrInvalidDocumentType is returned when methods like Put, Get or Next
// are passed a dst or src argument of invalid type.
ErrInvalidDocumentType = errors.New("search: invalid document type")
// ErrNoSuchDocument is returned when no document was found for a given ID.
ErrNoSuchDocument = errors.New("search: no such document")
)
// Atom is a document field whose contents are indexed as a single indivisible
// string.
type Atom string
// HTML is a document field whose contents are indexed as HTML. Only text nodes
// are indexed: "foobar" will be treated as "foobar".
type HTML string
// validIndexNameOrDocID is the Go equivalent of Python's
// _ValidateVisiblePrintableAsciiNotReserved.
func validIndexNameOrDocID(s string) bool {
if strings.HasPrefix(s, "!") {
return false
}
for _, c := range s {
if c < 0x21 || 0x7f <= c {
return false
}
}
return true
}
var (
fieldNameRE = regexp.MustCompile(`^[A-Za-z][A-Za-z0-9_]*$`)
languageRE = regexp.MustCompile(`^[a-z]{2}$`)
)
// validFieldName is the Go equivalent of Python's _CheckFieldName. It checks
// the validity of both field and facet names.
func validFieldName(s string) bool {
return len(s) <= 500 && fieldNameRE.MatchString(s)
}
// validDocRank checks that the ranks is in the range [0, 2^31).
func validDocRank(r int) bool {
return 0 <= r && r <= (1<<31-1)
}
// validLanguage checks that a language looks like ISO 639-1.
func validLanguage(s string) bool {
return languageRE.MatchString(s)
}
// validFloat checks that f is in the range [-2147483647, 2147483647].
func validFloat(f float64) bool {
return -(1<<31-1) <= f && f <= (1<<31-1)
}
// Index is an index of documents.
type Index struct {
spec pb.IndexSpec
}
// orderIDEpoch forms the basis for populating OrderId on documents.
var orderIDEpoch = time.Date(2011, 1, 1, 0, 0, 0, 0, time.UTC)
// Open opens the index with the given name. The index is created if it does
// not already exist.
//
// The name is a human-readable ASCII string. It must contain no whitespace
// characters and not start with "!".
func Open(name string) (*Index, error) {
if !validIndexNameOrDocID(name) {
return nil, fmt.Errorf("search: invalid index name %q", name)
}
return &Index{
spec: pb.IndexSpec{
Name: &name,
},
}, nil
}
// Put saves src to the index. If id is empty, a new ID is allocated by the
// service and returned. If id is not empty, any existing index entry for that
// ID is replaced.
//
// The ID is a human-readable ASCII string. It must contain no whitespace
// characters and not start with "!".
//
// src must be a non-nil struct pointer or implement the FieldLoadSaver
// interface.
func (x *Index) Put(c context.Context, id string, src interface{}) (string, error) {
d, err := saveDoc(src)
if err != nil {
return "", err
}
if id != "" {
if !validIndexNameOrDocID(id) {
return "", fmt.Errorf("search: invalid ID %q", id)
}
d.Id = proto.String(id)
}
req := &pb.IndexDocumentRequest{
Params: &pb.IndexDocumentParams{
Document: []*pb.Document{d},
IndexSpec: &x.spec,
},
}
res := &pb.IndexDocumentResponse{}
if err := internal.Call(c, "search", "IndexDocument", req, res); err != nil {
return "", err
}
if len(res.Status) > 0 {
if s := res.Status[0]; s.GetCode() != pb.SearchServiceError_OK {
return "", fmt.Errorf("search: %s: %s", s.GetCode(), s.GetErrorDetail())
}
}
if len(res.Status) != 1 || len(res.DocId) != 1 {
return "", fmt.Errorf("search: internal error: wrong number of results (%d Statuses, %d DocIDs)",
len(res.Status), len(res.DocId))
}
return res.DocId[0], nil
}
// Get loads the document with the given ID into dst.
//
// The ID is a human-readable ASCII string. It must be non-empty, contain no
// whitespace characters and not start with "!".
//
// dst must be a non-nil struct pointer or implement the FieldLoadSaver
// interface.
//
// ErrFieldMismatch is returned when a field is to be loaded into a different
// type than the one it was stored from, or when a field is missing or
// unexported in the destination struct. ErrFieldMismatch is only returned if
// dst is a struct pointer. It is up to the callee to decide whether this error
// is fatal, recoverable, or ignorable.
func (x *Index) Get(c context.Context, id string, dst interface{}) error {
if id == "" || !validIndexNameOrDocID(id) {
return fmt.Errorf("search: invalid ID %q", id)
}
req := &pb.ListDocumentsRequest{
Params: &pb.ListDocumentsParams{
IndexSpec: &x.spec,
StartDocId: proto.String(id),
Limit: proto.Int32(1),
},
}
res := &pb.ListDocumentsResponse{}
if err := internal.Call(c, "search", "ListDocuments", req, res); err != nil {
return err
}
if res.Status == nil || res.Status.GetCode() != pb.SearchServiceError_OK {
return fmt.Errorf("search: %s: %s", res.Status.GetCode(), res.Status.GetErrorDetail())
}
if len(res.Document) != 1 || res.Document[0].GetId() != id {
return ErrNoSuchDocument
}
return loadDoc(dst, res.Document[0], nil)
}
// Delete deletes a document from the index.
func (x *Index) Delete(c context.Context, id string) error {
req := &pb.DeleteDocumentRequest{
Params: &pb.DeleteDocumentParams{
DocId: []string{id},
IndexSpec: &x.spec,
},
}
res := &pb.DeleteDocumentResponse{}
if err := internal.Call(c, "search", "DeleteDocument", req, res); err != nil {
return err
}
if len(res.Status) != 1 {
return fmt.Errorf("search: internal error: wrong number of results (%d)", len(res.Status))
}
if s := res.Status[0]; s.GetCode() != pb.SearchServiceError_OK {
return fmt.Errorf("search: %s: %s", s.GetCode(), s.GetErrorDetail())
}
return nil
}
// List lists all of the documents in an index. The documents are returned in
// increasing ID order.
func (x *Index) List(c context.Context, opts *ListOptions) *Iterator {
t := &Iterator{
c: c,
index: x,
count: -1,
listInclusive: true,
more: moreList,
}
if opts != nil {
t.listStartID = opts.StartID
t.limit = opts.Limit
t.idsOnly = opts.IDsOnly
}
return t
}
func moreList(t *Iterator) error {
req := &pb.ListDocumentsRequest{
Params: &pb.ListDocumentsParams{
IndexSpec: &t.index.spec,
},
}
if t.listStartID != "" {
req.Params.StartDocId = &t.listStartID
req.Params.IncludeStartDoc = &t.listInclusive
}
if t.limit > 0 {
req.Params.Limit = proto.Int32(int32(t.limit))
}
if t.idsOnly {
req.Params.KeysOnly = &t.idsOnly
}
res := &pb.ListDocumentsResponse{}
if err := internal.Call(t.c, "search", "ListDocuments", req, res); err != nil {
return err
}
if res.Status == nil || res.Status.GetCode() != pb.SearchServiceError_OK {
return fmt.Errorf("search: %s: %s", res.Status.GetCode(), res.Status.GetErrorDetail())
}
t.listRes = res.Document
t.listStartID, t.listInclusive, t.more = "", false, nil
if len(res.Document) != 0 && t.limit <= 0 {
if id := res.Document[len(res.Document)-1].GetId(); id != "" {
t.listStartID, t.more = id, moreList
}
}
return nil
}
// ListOptions are the options for listing documents in an index. Passing a nil
// *ListOptions is equivalent to using the default values.
type ListOptions struct {
// StartID is the inclusive lower bound for the ID of the returned
// documents. The zero value means all documents will be returned.
StartID string
// Limit is the maximum number of documents to return. The zero value
// indicates no limit.
Limit int
// IDsOnly indicates that only document IDs should be returned for the list
// operation; no document fields are populated.
IDsOnly bool
}
// Search searches the index for the given query.
func (x *Index) Search(c context.Context, query string, opts *SearchOptions) *Iterator {
t := &Iterator{
c: c,
index: x,
searchQuery: query,
more: moreSearch,
}
if opts != nil {
if opts.Cursor != "" {
if opts.Offset != 0 {
return errIter("at most one of Cursor and Offset may be specified")
}
t.searchCursor = proto.String(string(opts.Cursor))
}
t.limit = opts.Limit
t.fields = opts.Fields
t.idsOnly = opts.IDsOnly
t.sort = opts.Sort
t.exprs = opts.Expressions
t.refinements = opts.Refinements
t.facetOpts = opts.Facets
t.searchOffset = opts.Offset
}
return t
}
func moreSearch(t *Iterator) error {
// We use per-result (rather than single/per-page) cursors since this
// lets us return a Cursor for every iterator document. The two cursor
// types are largely interchangeable: a page cursor is the same as the
// last per-result cursor in a given search response.
req := &pb.SearchRequest{
Params: &pb.SearchParams{
IndexSpec: &t.index.spec,
Query: &t.searchQuery,
Cursor: t.searchCursor,
CursorType: pb.SearchParams_PER_RESULT.Enum(),
FieldSpec: &pb.FieldSpec{
Name: t.fields,
},
},
}
if t.limit > 0 {
req.Params.Limit = proto.Int32(int32(t.limit))
}
if t.searchOffset > 0 {
req.Params.Offset = proto.Int32(int32(t.searchOffset))
t.searchOffset = 0
}
if t.idsOnly {
req.Params.KeysOnly = &t.idsOnly
}
if t.sort != nil {
if err := sortToProto(t.sort, req.Params); err != nil {
return err
}
}
if t.refinements != nil {
if err := refinementsToProto(t.refinements, req.Params); err != nil {
return err
}
}
for _, e := range t.exprs {
req.Params.FieldSpec.Expression = append(req.Params.FieldSpec.Expression, &pb.FieldSpec_Expression{
Name: proto.String(e.Name),
Expression: proto.String(e.Expr),
})
}
for _, f := range t.facetOpts {
if err := f.setParams(req.Params); err != nil {
return fmt.Errorf("bad FacetSearchOption: %v", err)
}
}
// Don't repeat facet search.
t.facetOpts = nil
res := &pb.SearchResponse{}
if err := internal.Call(t.c, "search", "Search", req, res); err != nil {
return err
}
if res.Status == nil || res.Status.GetCode() != pb.SearchServiceError_OK {
return fmt.Errorf("search: %s: %s", res.Status.GetCode(), res.Status.GetErrorDetail())
}
t.searchRes = res.Result
if len(res.FacetResult) > 0 {
t.facetRes = res.FacetResult
}
t.count = int(*res.MatchedCount)
if t.limit > 0 {
t.more = nil
} else {
t.more = moreSearch
}
return nil
}
// SearchOptions are the options for searching an index. Passing a nil
// *SearchOptions is equivalent to using the default values.
type SearchOptions struct {
// Limit is the maximum number of documents to return. The zero value
// indicates no limit.
Limit int
// IDsOnly indicates that only document IDs should be returned for the search
// operation; no document fields are populated.
IDsOnly bool
// Sort controls the ordering of search results.
Sort *SortOptions
// Fields specifies which document fields to include in the results. If omitted,
// all document fields are returned. No more than 100 fields may be specified.
Fields []string
// Expressions specifies additional computed fields to add to each returned
// document.
Expressions []FieldExpression
// Facets controls what facet information is returned for these search results.
// If no options are specified, no facet results will be returned.
Facets []FacetSearchOption
// Refinements filters the returned documents by requiring them to contain facets
// with specific values. Refinements are applied in conjunction for facets with
// different names, and in disjunction otherwise.
Refinements []Facet
// Cursor causes the results to commence with the first document after
// the document associated with the cursor.
Cursor Cursor
// Offset specifies the number of documents to skip over before returning results.
// When specified, Cursor must be nil.
Offset int
}
// Cursor represents an iterator's position.
//
// The string value of a cursor is web-safe. It can be saved and restored
// for later use.
type Cursor string
// FieldExpression defines a custom expression to evaluate for each result.
type FieldExpression struct {
// Name is the name to use for the computed field.
Name string
// Expr is evaluated to provide a custom content snippet for each document.
// See https://cloud.google.com/appengine/docs/go/search/options for
// the supported expression syntax.
Expr string
}
// FacetSearchOption controls what facet information is returned in search results.
type FacetSearchOption interface {
setParams(*pb.SearchParams) error
}
// AutoFacetDiscovery returns a FacetSearchOption which enables automatic facet
// discovery for the search. Automatic facet discovery looks for the facets
// which appear the most often in the aggregate in the matched documents.
//
// The maximum number of facets returned is controlled by facetLimit, and the
// maximum number of values per facet by facetLimit. A limit of zero indicates
// a default limit should be used.
func AutoFacetDiscovery(facetLimit, valueLimit int) FacetSearchOption {
return &autoFacetOpt{facetLimit, valueLimit}
}
type autoFacetOpt struct {
facetLimit, valueLimit int
}
const defaultAutoFacetLimit = 10 // As per python runtime search.py.
func (o *autoFacetOpt) setParams(params *pb.SearchParams) error {
lim := int32(o.facetLimit)
if lim == 0 {
lim = defaultAutoFacetLimit
}
params.AutoDiscoverFacetCount = &lim
if o.valueLimit > 0 {
params.FacetAutoDetectParam = &pb.FacetAutoDetectParam{
ValueLimit: proto.Int32(int32(o.valueLimit)),
}
}
return nil
}
// FacetDiscovery returns a FacetSearchOption which selects a facet to be
// returned with the search results. By default, the most frequently
// occurring values for that facet will be returned. However, you can also
// specify a list of particular Atoms or specific Ranges to return.
func FacetDiscovery(name string, value ...interface{}) FacetSearchOption {
return &facetOpt{name, value}
}
type facetOpt struct {
name string
values []interface{}
}
func (o *facetOpt) setParams(params *pb.SearchParams) error {
req := &pb.FacetRequest{Name: &o.name}
params.IncludeFacet = append(params.IncludeFacet, req)
if len(o.values) == 0 {
return nil
}
vtype := reflect.TypeOf(o.values[0])
reqParam := &pb.FacetRequestParam{}
for _, v := range o.values {
if reflect.TypeOf(v) != vtype {
return errors.New("values must all be Atom, or must all be Range")
}
switch v := v.(type) {
case Atom:
reqParam.ValueConstraint = append(reqParam.ValueConstraint, string(v))
case Range:
rng, err := rangeToProto(v)
if err != nil {
return fmt.Errorf("invalid range: %v", err)
}
reqParam.Range = append(reqParam.Range, rng)
default:
return fmt.Errorf("unsupported value type %T", v)
}
}
req.Params = reqParam
return nil
}
// FacetDocumentDepth returns a FacetSearchOption which controls the number of
// documents to be evaluated with preparing facet results.
func FacetDocumentDepth(depth int) FacetSearchOption {
return facetDepthOpt(depth)
}
type facetDepthOpt int
func (o facetDepthOpt) setParams(params *pb.SearchParams) error {
params.FacetDepth = proto.Int32(int32(o))
return nil
}
// FacetResult represents the number of times a particular facet and value
// appeared in the documents matching a search request.
type FacetResult struct {
Facet
// Count is the number of times this specific facet and value appeared in the
// matching documents.
Count int
}
// Range represents a numeric range with inclusive start and exclusive end.
// Start may be specified as math.Inf(-1) to indicate there is no minimum
// value, and End may similarly be specified as math.Inf(1); at least one of
// Start or End must be a finite number.
type Range struct {
Start, End float64
}
var (
negInf = math.Inf(-1)
posInf = math.Inf(1)
)
// AtLeast returns a Range matching any value greater than, or equal to, min.
func AtLeast(min float64) Range {
return Range{Start: min, End: posInf}
}
// LessThan returns a Range matching any value less than max.
func LessThan(max float64) Range {
return Range{Start: negInf, End: max}
}
// SortOptions control the ordering and scoring of search results.
type SortOptions struct {
// Expressions is a slice of expressions representing a multi-dimensional
// sort.
Expressions []SortExpression
// Scorer, when specified, will cause the documents to be scored according to
// search term frequency.
Scorer Scorer
// Limit is the maximum number of objects to score and/or sort. Limit cannot
// be more than 10,000. The zero value indicates a default limit.
Limit int
}
// SortExpression defines a single dimension for sorting a document.
type SortExpression struct {
// Expr is evaluated to provide a sorting value for each document.
// See https://cloud.google.com/appengine/docs/go/search/options for
// the supported expression syntax.
Expr string
// Reverse causes the documents to be sorted in ascending order.
Reverse bool
// The default value to use when no field is present or the expresion
// cannot be calculated for a document. For text sorts, Default must
// be of type string; for numeric sorts, float64.
Default interface{}
}
// A Scorer defines how a document is scored.
type Scorer interface {
toProto(*pb.ScorerSpec)
}
type enumScorer struct {
enum pb.ScorerSpec_Scorer
}
func (e enumScorer) toProto(spec *pb.ScorerSpec) {
spec.Scorer = e.enum.Enum()
}
var (
// MatchScorer assigns a score based on term frequency in a document.
MatchScorer Scorer = enumScorer{pb.ScorerSpec_MATCH_SCORER}
// RescoringMatchScorer assigns a score based on the quality of the query
// match. It is similar to a MatchScorer but uses a more complex scoring
// algorithm based on match term frequency and other factors like field type.
// Please be aware that this algorithm is continually refined and can change
// over time without notice. This means that the ordering of search results
// that use this scorer can also change without notice.
RescoringMatchScorer Scorer = enumScorer{pb.ScorerSpec_RESCORING_MATCH_SCORER}
)
func sortToProto(sort *SortOptions, params *pb.SearchParams) error {
for _, e := range sort.Expressions {
spec := &pb.SortSpec{
SortExpression: proto.String(e.Expr),
}
if e.Reverse {
spec.SortDescending = proto.Bool(false)
}
if e.Default != nil {
switch d := e.Default.(type) {
case float64:
spec.DefaultValueNumeric = &d
case string:
spec.DefaultValueText = &d
default:
return fmt.Errorf("search: invalid Default type %T for expression %q", d, e.Expr)
}
}
params.SortSpec = append(params.SortSpec, spec)
}
spec := &pb.ScorerSpec{}
if sort.Limit > 0 {
spec.Limit = proto.Int32(int32(sort.Limit))
params.ScorerSpec = spec
}
if sort.Scorer != nil {
sort.Scorer.toProto(spec)
params.ScorerSpec = spec
}
return nil
}
func refinementsToProto(refinements []Facet, params *pb.SearchParams) error {
for _, r := range refinements {
ref := &pb.FacetRefinement{
Name: proto.String(r.Name),
}
switch v := r.Value.(type) {
case Atom:
ref.Value = proto.String(string(v))
case Range:
rng, err := rangeToProto(v)
if err != nil {
return fmt.Errorf("search: refinement for facet %q: %v", r.Name, err)
}
// Unfortunately there are two identical messages for identify Facet ranges.
ref.Range = &pb.FacetRefinement_Range{Start: rng.Start, End: rng.End}
default:
return fmt.Errorf("search: unsupported refinement for facet %q of type %T", r.Name, v)
}
params.FacetRefinement = append(params.FacetRefinement, ref)
}
return nil
}
func rangeToProto(r Range) (*pb.FacetRange, error) {
rng := &pb.FacetRange{}
if r.Start != negInf {
if !validFloat(r.Start) {
return nil, errors.New("invalid value for Start")
}
rng.Start = proto.String(strconv.FormatFloat(r.Start, 'e', -1, 64))
} else if r.End == posInf {
return nil, errors.New("either Start or End must be finite")
}
if r.End != posInf {
if !validFloat(r.End) {
return nil, errors.New("invalid value for End")
}
rng.End = proto.String(strconv.FormatFloat(r.End, 'e', -1, 64))
}
return rng, nil
}
func protoToRange(rng *pb.FacetRefinement_Range) Range {
r := Range{Start: negInf, End: posInf}
if x, err := strconv.ParseFloat(rng.GetStart(), 64); err != nil {
r.Start = x
}
if x, err := strconv.ParseFloat(rng.GetEnd(), 64); err != nil {
r.End = x
}
return r
}
// Iterator is the result of searching an index for a query or listing an
// index.
type Iterator struct {
c context.Context
index *Index
err error
listRes []*pb.Document
listStartID string
listInclusive bool
searchRes []*pb.SearchResult
facetRes []*pb.FacetResult
searchQuery string
searchCursor *string
searchOffset int
sort *SortOptions
fields []string
exprs []FieldExpression
refinements []Facet
facetOpts []FacetSearchOption
more func(*Iterator) error
count int
limit int // items left to return; 0 for unlimited.
idsOnly bool
}
// errIter returns an iterator that only returns the given error.
func errIter(err string) *Iterator {
return &Iterator{
err: errors.New(err),
}
}
// Done is returned when a query iteration has completed.
var Done = errors.New("search: query has no more results")
// Count returns an approximation of the number of documents matched by the
// query. It is only valid to call for iterators returned by Search.
func (t *Iterator) Count() int { return t.count }
// fetchMore retrieves more results, if there are no errors or pending results.
func (t *Iterator) fetchMore() {
if t.err == nil && len(t.listRes)+len(t.searchRes) == 0 && t.more != nil {
t.err = t.more(t)
}
}
// Next returns the ID of the next result. When there are no more results,
// Done is returned as the error.
//
// dst must be a non-nil struct pointer, implement the FieldLoadSaver
// interface, or be a nil interface value. If a non-nil dst is provided, it
// will be filled with the indexed fields. dst is ignored if this iterator was
// created with an IDsOnly option.
func (t *Iterator) Next(dst interface{}) (string, error) {
t.fetchMore()
if t.err != nil {
return "", t.err
}
var doc *pb.Document
var exprs []*pb.Field
switch {
case len(t.listRes) != 0:
doc = t.listRes[0]
t.listRes = t.listRes[1:]
case len(t.searchRes) != 0:
doc = t.searchRes[0].Document
exprs = t.searchRes[0].Expression
t.searchCursor = t.searchRes[0].Cursor
t.searchRes = t.searchRes[1:]
default:
return "", Done
}
if doc == nil {
return "", errors.New("search: internal error: no document returned")
}
if !t.idsOnly && dst != nil {
if err := loadDoc(dst, doc, exprs); err != nil {
return "", err
}
}
return doc.GetId(), nil
}
// Cursor returns the cursor associated with the current document (that is,
// the document most recently returned by a call to Next).
//
// Passing this cursor in a future call to Search will cause those results
// to commence with the first document after the current document.
func (t *Iterator) Cursor() Cursor {
if t.searchCursor == nil {
return ""
}
return Cursor(*t.searchCursor)
}
// Facets returns the facets found within the search results, if any facets
// were requested in the SearchOptions.
func (t *Iterator) Facets() ([][]FacetResult, error) {
t.fetchMore()
if t.err != nil && t.err != Done {
return nil, t.err
}
var facets [][]FacetResult
for _, f := range t.facetRes {
fres := make([]FacetResult, 0, len(f.Value))
for _, v := range f.Value {
ref := v.Refinement
facet := FacetResult{
Facet: Facet{Name: ref.GetName()},
Count: int(v.GetCount()),
}
if ref.Value != nil {
facet.Value = Atom(*ref.Value)
} else {
facet.Value = protoToRange(ref.Range)
}
fres = append(fres, facet)
}
facets = append(facets, fres)
}
return facets, nil
}
// saveDoc converts from a struct pointer or
// FieldLoadSaver/FieldMetadataLoadSaver to the Document protobuf.
func saveDoc(src interface{}) (*pb.Document, error) {
var err error
var fields []Field
var meta *DocumentMetadata
switch x := src.(type) {
case FieldLoadSaver:
fields, meta, err = x.Save()
default:
fields, err = SaveStruct(src)
}
if err != nil {
return nil, err
}
fieldsProto, err := fieldsToProto(fields)
if err != nil {
return nil, err
}
d := &pb.Document{
Field: fieldsProto,
OrderId: proto.Int32(int32(time.Since(orderIDEpoch).Seconds())),
}
if meta != nil {
if meta.Rank != 0 {
if !validDocRank(meta.Rank) {
return nil, fmt.Errorf("search: invalid rank %d, must be [0, 2^31)", meta.Rank)
}
*d.OrderId = int32(meta.Rank)
}
if len(meta.Facets) > 0 {
facets, err := facetsToProto(meta.Facets)
if err != nil {
return nil, err
}
d.Facet = facets
}
}
return d, nil
}
func fieldsToProto(src []Field) ([]*pb.Field, error) {
// Maps to catch duplicate time or numeric fields.
timeFields, numericFields := make(map[string]bool), make(map[string]bool)
dst := make([]*pb.Field, 0, len(src))
for _, f := range src {
if !validFieldName(f.Name) {
return nil, fmt.Errorf("search: invalid field name %q", f.Name)
}
fieldValue := &pb.FieldValue{}
switch x := f.Value.(type) {
case string:
fieldValue.Type = pb.FieldValue_TEXT.Enum()
fieldValue.StringValue = proto.String(x)
case Atom:
fieldValue.Type = pb.FieldValue_ATOM.Enum()
fieldValue.StringValue = proto.String(string(x))
case HTML:
fieldValue.Type = pb.FieldValue_HTML.Enum()
fieldValue.StringValue = proto.String(string(x))
case time.Time:
if timeFields[f.Name] {
return nil, fmt.Errorf("search: duplicate time field %q", f.Name)
}
timeFields[f.Name] = true
fieldValue.Type = pb.FieldValue_DATE.Enum()
fieldValue.StringValue = proto.String(strconv.FormatInt(x.UnixNano()/1e6, 10))
case float64:
if numericFields[f.Name] {
return nil, fmt.Errorf("search: duplicate numeric field %q", f.Name)
}
if !validFloat(x) {
return nil, fmt.Errorf("search: numeric field %q with invalid value %f", f.Name, x)
}
numericFields[f.Name] = true
fieldValue.Type = pb.FieldValue_NUMBER.Enum()
fieldValue.StringValue = proto.String(strconv.FormatFloat(x, 'e', -1, 64))
case appengine.GeoPoint:
if !x.Valid() {
return nil, fmt.Errorf(
"search: GeoPoint field %q with invalid value %v",
f.Name, x)
}
fieldValue.Type = pb.FieldValue_GEO.Enum()
fieldValue.Geo = &pb.FieldValue_Geo{
Lat: proto.Float64(x.Lat),
Lng: proto.Float64(x.Lng),
}
default:
return nil, fmt.Errorf("search: unsupported field type: %v", reflect.TypeOf(f.Value))
}
if f.Language != "" {
switch f.Value.(type) {
case string, HTML:
if !validLanguage(f.Language) {
return nil, fmt.Errorf("search: invalid language for field %q: %q", f.Name, f.Language)
}
fieldValue.Language = proto.String(f.Language)
default:
return nil, fmt.Errorf("search: setting language not supported for field %q of type %T", f.Name, f.Value)
}
}
if p := fieldValue.StringValue; p != nil && !utf8.ValidString(*p) {
return nil, fmt.Errorf("search: %q field is invalid UTF-8: %q", f.Name, *p)
}
dst = append(dst, &pb.Field{
Name: proto.String(f.Name),
Value: fieldValue,
})
}
return dst, nil
}
func facetsToProto(src []Facet) ([]*pb.Facet, error) {
dst := make([]*pb.Facet, 0, len(src))
for _, f := range src {
if !validFieldName(f.Name) {
return nil, fmt.Errorf("search: invalid facet name %q", f.Name)
}
facetValue := &pb.FacetValue{}
switch x := f.Value.(type) {
case Atom:
if !utf8.ValidString(string(x)) {
return nil, fmt.Errorf("search: %q facet is invalid UTF-8: %q", f.Name, x)
}
facetValue.Type = pb.FacetValue_ATOM.Enum()
facetValue.StringValue = proto.String(string(x))
case float64:
if !validFloat(x) {
return nil, fmt.Errorf("search: numeric facet %q with invalid value %f", f.Name, x)
}
facetValue.Type = pb.FacetValue_NUMBER.Enum()
facetValue.StringValue = proto.String(strconv.FormatFloat(x, 'e', -1, 64))
default:
return nil, fmt.Errorf("search: unsupported facet type: %v", reflect.TypeOf(f.Value))
}
dst = append(dst, &pb.Facet{
Name: proto.String(f.Name),
Value: facetValue,
})
}
return dst, nil
}
// loadDoc converts from protobufs to a struct pointer or
// FieldLoadSaver/FieldMetadataLoadSaver. The src param provides the document's
// stored fields and facets, and any document metadata. An additional slice of
// fields, exprs, may optionally be provided to contain any derived expressions
// requested by the developer.
func loadDoc(dst interface{}, src *pb.Document, exprs []*pb.Field) (err error) {
fields, err := protoToFields(src.Field)
if err != nil {
return err
}
facets, err := protoToFacets(src.Facet)
if err != nil {
return err
}
if len(exprs) > 0 {
exprFields, err := protoToFields(exprs)
if err != nil {
return err
}
// Mark each field as derived.
for i := range exprFields {
exprFields[i].Derived = true
}
fields = append(fields, exprFields...)
}
meta := &DocumentMetadata{
Rank: int(src.GetOrderId()),
Facets: facets,
}
switch x := dst.(type) {
case FieldLoadSaver:
return x.Load(fields, meta)
default:
return loadStructWithMeta(dst, fields, meta)
}
}
func protoToFields(fields []*pb.Field) ([]Field, error) {
dst := make([]Field, 0, len(fields))
for _, field := range fields {
fieldValue := field.GetValue()
f := Field{
Name: field.GetName(),
}
switch fieldValue.GetType() {
case pb.FieldValue_TEXT:
f.Value = fieldValue.GetStringValue()
f.Language = fieldValue.GetLanguage()
case pb.FieldValue_ATOM:
f.Value = Atom(fieldValue.GetStringValue())
case pb.FieldValue_HTML:
f.Value = HTML(fieldValue.GetStringValue())
f.Language = fieldValue.GetLanguage()
case pb.FieldValue_DATE:
sv := fieldValue.GetStringValue()
millis, err := strconv.ParseInt(sv, 10, 64)
if err != nil {
return nil, fmt.Errorf("search: internal error: bad time.Time encoding %q: %v", sv, err)
}
f.Value = time.Unix(0, millis*1e6)
case pb.FieldValue_NUMBER:
sv := fieldValue.GetStringValue()
x, err := strconv.ParseFloat(sv, 64)
if err != nil {
return nil, err
}
f.Value = x
case pb.FieldValue_GEO:
geoValue := fieldValue.GetGeo()
geoPoint := appengine.GeoPoint{geoValue.GetLat(), geoValue.GetLng()}
if !geoPoint.Valid() {
return nil, fmt.Errorf("search: internal error: invalid GeoPoint encoding: %v", geoPoint)
}
f.Value = geoPoint
default:
return nil, fmt.Errorf("search: internal error: unknown data type %s", fieldValue.GetType())
}
dst = append(dst, f)
}
return dst, nil
}
func protoToFacets(facets []*pb.Facet) ([]Facet, error) {
if len(facets) == 0 {
return nil, nil
}
dst := make([]Facet, 0, len(facets))
for _, facet := range facets {
facetValue := facet.GetValue()
f := Facet{
Name: facet.GetName(),
}
switch facetValue.GetType() {
case pb.FacetValue_ATOM:
f.Value = Atom(facetValue.GetStringValue())
case pb.FacetValue_NUMBER:
sv := facetValue.GetStringValue()
x, err := strconv.ParseFloat(sv, 64)
if err != nil {
return nil, err
}
f.Value = x
default:
return nil, fmt.Errorf("search: internal error: unknown data type %s", facetValue.GetType())
}
dst = append(dst, f)
}
return dst, nil
}
func namespaceMod(m proto.Message, namespace string) {
set := func(s **string) {
if *s == nil {
*s = &namespace
}
}
switch m := m.(type) {
case *pb.IndexDocumentRequest:
set(&m.Params.IndexSpec.Namespace)
case *pb.ListDocumentsRequest:
set(&m.Params.IndexSpec.Namespace)
case *pb.DeleteDocumentRequest:
set(&m.Params.IndexSpec.Namespace)
case *pb.SearchRequest:
set(&m.Params.IndexSpec.Namespace)
}
}
func init() {
internal.RegisterErrorCodeMap("search", pb.SearchServiceError_ErrorCode_name)
internal.NamespaceMods["search"] = namespaceMod
}
================================================
FILE: vendor/google.golang.org/appengine/search/struct.go
================================================
// Copyright 2015 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
package search
import (
"fmt"
"reflect"
"strings"
"sync"
)
// ErrFieldMismatch is returned when a field is to be loaded into a different
// than the one it was stored from, or when a field is missing or unexported in
// the destination struct.
type ErrFieldMismatch struct {
FieldName string
Reason string
}
func (e *ErrFieldMismatch) Error() string {
return fmt.Sprintf("search: cannot load field %q: %s", e.FieldName, e.Reason)
}
// ErrFacetMismatch is returned when a facet is to be loaded into a different
// type than the one it was stored from, or when a field is missing or
// unexported in the destination struct. StructType is the type of the struct
// pointed to by the destination argument passed to Iterator.Next.
type ErrFacetMismatch struct {
StructType reflect.Type
FacetName string
Reason string
}
func (e *ErrFacetMismatch) Error() string {
return fmt.Sprintf("search: cannot load facet %q into a %q: %s", e.FacetName, e.StructType, e.Reason)
}
// structCodec defines how to convert a given struct to/from a search document.
type structCodec struct {
// byIndex returns the struct tag for the i'th struct field.
byIndex []structTag
// fieldByName returns the index of the struct field for the given field name.
fieldByName map[string]int
// facetByName returns the index of the struct field for the given facet name,
facetByName map[string]int
}
// structTag holds a structured version of each struct field's parsed tag.
type structTag struct {
name string
facet bool
}
var (
codecsMu sync.RWMutex
codecs = map[reflect.Type]*structCodec{}
)
func loadCodec(t reflect.Type) (*structCodec, error) {
codecsMu.RLock()
codec, ok := codecs[t]
codecsMu.RUnlock()
if ok {
return codec, nil
}
codecsMu.Lock()
defer codecsMu.Unlock()
if codec, ok := codecs[t]; ok {
return codec, nil
}
codec = &structCodec{
fieldByName: make(map[string]int),
facetByName: make(map[string]int),
}
for i, I := 0, t.NumField(); i < I; i++ {
f := t.Field(i)
name, opts := f.Tag.Get("search"), ""
if i := strings.Index(name, ","); i != -1 {
name, opts = name[:i], name[i+1:]
}
// TODO(davidday): Support name=="-" as per datastore.
if name == "" {
name = f.Name
} else if !validFieldName(name) {
return nil, fmt.Errorf("search: struct tag has invalid field name: %q", name)
}
facet := opts == "facet"
codec.byIndex = append(codec.byIndex, structTag{name: name, facet: facet})
if facet {
codec.facetByName[name] = i
} else {
codec.fieldByName[name] = i
}
}
codecs[t] = codec
return codec, nil
}
// structFLS adapts a struct to be a FieldLoadSaver.
type structFLS struct {
v reflect.Value
codec *structCodec
}
func (s structFLS) Load(fields []Field, meta *DocumentMetadata) error {
var err error
for _, field := range fields {
i, ok := s.codec.fieldByName[field.Name]
if !ok {
// Note the error, but keep going.
err = &ErrFieldMismatch{
FieldName: field.Name,
Reason: "no such struct field",
}
continue
}
f := s.v.Field(i)
if !f.CanSet() {
// Note the error, but keep going.
err = &ErrFieldMismatch{
FieldName: field.Name,
Reason: "cannot set struct field",
}
continue
}
v := reflect.ValueOf(field.Value)
if ft, vt := f.Type(), v.Type(); ft != vt {
err = &ErrFieldMismatch{
FieldName: field.Name,
Reason: fmt.Sprintf("type mismatch: %v for %v data", ft, vt),
}
continue
}
f.Set(v)
}
if meta == nil {
return nil
}
for _, facet := range meta.Facets {
i, ok := s.codec.facetByName[facet.Name]
if !ok {
// Note the error, but keep going.
if err == nil {
err = &ErrFacetMismatch{
StructType: s.v.Type(),
FacetName: facet.Name,
Reason: "no matching field found",
}
}
continue
}
f := s.v.Field(i)
if !f.CanSet() {
// Note the error, but keep going.
if err == nil {
err = &ErrFacetMismatch{
StructType: s.v.Type(),
FacetName: facet.Name,
Reason: "unable to set unexported field of struct",
}
}
continue
}
v := reflect.ValueOf(facet.Value)
if ft, vt := f.Type(), v.Type(); ft != vt {
if err == nil {
err = &ErrFacetMismatch{
StructType: s.v.Type(),
FacetName: facet.Name,
Reason: fmt.Sprintf("type mismatch: %v for %d data", ft, vt),
}
continue
}
}
f.Set(v)
}
return err
}
func (s structFLS) Save() ([]Field, *DocumentMetadata, error) {
fields := make([]Field, 0, len(s.codec.fieldByName))
var facets []Facet
for i, tag := range s.codec.byIndex {
f := s.v.Field(i)
if !f.CanSet() {
continue
}
if tag.facet {
facets = append(facets, Facet{Name: tag.name, Value: f.Interface()})
} else {
fields = append(fields, Field{Name: tag.name, Value: f.Interface()})
}
}
return fields, &DocumentMetadata{Facets: facets}, nil
}
// newStructFLS returns a FieldLoadSaver for the struct pointer p.
func newStructFLS(p interface{}) (FieldLoadSaver, error) {
v := reflect.ValueOf(p)
if v.Kind() != reflect.Ptr || v.IsNil() || v.Elem().Kind() != reflect.Struct {
return nil, ErrInvalidDocumentType
}
codec, err := loadCodec(v.Elem().Type())
if err != nil {
return nil, err
}
return structFLS{v.Elem(), codec}, nil
}
func loadStructWithMeta(dst interface{}, f []Field, meta *DocumentMetadata) error {
x, err := newStructFLS(dst)
if err != nil {
return err
}
return x.Load(f, meta)
}
func saveStructWithMeta(src interface{}) ([]Field, *DocumentMetadata, error) {
x, err := newStructFLS(src)
if err != nil {
return nil, nil, err
}
return x.Save()
}
// LoadStruct loads the fields from f to dst. dst must be a struct pointer.
func LoadStruct(dst interface{}, f []Field) error {
return loadStructWithMeta(dst, f, nil)
}
// SaveStruct returns the fields from src as a slice of Field.
// src must be a struct pointer.
func SaveStruct(src interface{}) ([]Field, error) {
f, _, err := saveStructWithMeta(src)
return f, err
}
================================================
FILE: vendor/google.golang.org/appengine/socket/doc.go
================================================
// Copyright 2012 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
// Package socket provides outbound network sockets.
//
// This package is only required in the classic App Engine environment.
// Applications running only in the Managed VM hosting environment should
// use the standard library's net package.
package socket
================================================
FILE: vendor/google.golang.org/appengine/socket/socket_classic.go
================================================
// Copyright 2012 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
// +build appengine
package socket
import (
"fmt"
"io"
"net"
"strconv"
"time"
"github.com/golang/protobuf/proto"
"golang.org/x/net/context"
"google.golang.org/appengine/internal"
pb "google.golang.org/appengine/internal/socket"
)
// Dial connects to the address addr on the network protocol.
// The address format is host:port, where host may be a hostname or an IP address.
// Known protocols are "tcp" and "udp".
// The returned connection satisfies net.Conn, and is valid while ctx is valid;
// if the connection is to be used after ctx becomes invalid, invoke SetContext
// with the new context.
func Dial(ctx context.Context, protocol, addr string) (*Conn, error) {
return DialTimeout(ctx, protocol, addr, 0)
}
var ipFamilies = []pb.CreateSocketRequest_SocketFamily{
pb.CreateSocketRequest_IPv4,
pb.CreateSocketRequest_IPv6,
}
// DialTimeout is like Dial but takes a timeout.
// The timeout includes name resolution, if required.
func DialTimeout(ctx context.Context, protocol, addr string, timeout time.Duration) (*Conn, error) {
dialCtx := ctx // Used for dialing and name resolution, but not stored in the *Conn.
if timeout > 0 {
var cancel context.CancelFunc
dialCtx, cancel = context.WithTimeout(ctx, timeout)
defer cancel()
}
host, portStr, err := net.SplitHostPort(addr)
if err != nil {
return nil, err
}
port, err := strconv.Atoi(portStr)
if err != nil {
return nil, fmt.Errorf("socket: bad port %q: %v", portStr, err)
}
var prot pb.CreateSocketRequest_SocketProtocol
switch protocol {
case "tcp":
prot = pb.CreateSocketRequest_TCP
case "udp":
prot = pb.CreateSocketRequest_UDP
default:
return nil, fmt.Errorf("socket: unknown protocol %q", protocol)
}
packedAddrs, resolved, err := resolve(dialCtx, ipFamilies, host)
if err != nil {
return nil, fmt.Errorf("socket: failed resolving %q: %v", host, err)
}
if len(packedAddrs) == 0 {
return nil, fmt.Errorf("no addresses for %q", host)
}
packedAddr := packedAddrs[0] // use first address
fam := pb.CreateSocketRequest_IPv4
if len(packedAddr) == net.IPv6len {
fam = pb.CreateSocketRequest_IPv6
}
req := &pb.CreateSocketRequest{
Family: fam.Enum(),
Protocol: prot.Enum(),
RemoteIp: &pb.AddressPort{
Port: proto.Int32(int32(port)),
PackedAddress: packedAddr,
},
}
if resolved {
req.RemoteIp.HostnameHint = &host
}
res := &pb.CreateSocketReply{}
if err := internal.Call(dialCtx, "remote_socket", "CreateSocket", req, res); err != nil {
return nil, err
}
return &Conn{
ctx: ctx,
desc: res.GetSocketDescriptor(),
prot: prot,
local: res.ProxyExternalIp,
remote: req.RemoteIp,
}, nil
}
// LookupIP returns the given host's IP addresses.
func LookupIP(ctx context.Context, host string) (addrs []net.IP, err error) {
packedAddrs, _, err := resolve(ctx, ipFamilies, host)
if err != nil {
return nil, fmt.Errorf("socket: failed resolving %q: %v", host, err)
}
addrs = make([]net.IP, len(packedAddrs))
for i, pa := range packedAddrs {
addrs[i] = net.IP(pa)
}
return addrs, nil
}
func resolve(ctx context.Context, fams []pb.CreateSocketRequest_SocketFamily, host string) ([][]byte, bool, error) {
// Check if it's an IP address.
if ip := net.ParseIP(host); ip != nil {
if ip := ip.To4(); ip != nil {
return [][]byte{ip}, false, nil
}
return [][]byte{ip}, false, nil
}
req := &pb.ResolveRequest{
Name: &host,
AddressFamilies: fams,
}
res := &pb.ResolveReply{}
if err := internal.Call(ctx, "remote_socket", "Resolve", req, res); err != nil {
// XXX: need to map to pb.ResolveReply_ErrorCode?
return nil, false, err
}
return res.PackedAddress, true, nil
}
// withDeadline is like context.WithDeadline, except it ignores the zero deadline.
func withDeadline(parent context.Context, deadline time.Time) (context.Context, context.CancelFunc) {
if deadline.IsZero() {
return parent, func() {}
}
return context.WithDeadline(parent, deadline)
}
// Conn represents a socket connection.
// It implements net.Conn.
type Conn struct {
ctx context.Context
desc string
offset int64
prot pb.CreateSocketRequest_SocketProtocol
local, remote *pb.AddressPort
readDeadline, writeDeadline time.Time // optional
}
// SetContext sets the context that is used by this Conn.
// It is usually used only when using a Conn that was created in a different context,
// such as when a connection is created during a warmup request but used while
// servicing a user request.
func (cn *Conn) SetContext(ctx context.Context) {
cn.ctx = ctx
}
func (cn *Conn) Read(b []byte) (n int, err error) {
const maxRead = 1 << 20
if len(b) > maxRead {
b = b[:maxRead]
}
req := &pb.ReceiveRequest{
SocketDescriptor: &cn.desc,
DataSize: proto.Int32(int32(len(b))),
}
res := &pb.ReceiveReply{}
if !cn.readDeadline.IsZero() {
req.TimeoutSeconds = proto.Float64(cn.readDeadline.Sub(time.Now()).Seconds())
}
ctx, cancel := withDeadline(cn.ctx, cn.readDeadline)
defer cancel()
if err := internal.Call(ctx, "remote_socket", "Receive", req, res); err != nil {
return 0, err
}
if len(res.Data) == 0 {
return 0, io.EOF
}
if len(res.Data) > len(b) {
return 0, fmt.Errorf("socket: internal error: read too much data: %d > %d", len(res.Data), len(b))
}
return copy(b, res.Data), nil
}
func (cn *Conn) Write(b []byte) (n int, err error) {
const lim = 1 << 20 // max per chunk
for n < len(b) {
chunk := b[n:]
if len(chunk) > lim {
chunk = chunk[:lim]
}
req := &pb.SendRequest{
SocketDescriptor: &cn.desc,
Data: chunk,
StreamOffset: &cn.offset,
}
res := &pb.SendReply{}
if !cn.writeDeadline.IsZero() {
req.TimeoutSeconds = proto.Float64(cn.writeDeadline.Sub(time.Now()).Seconds())
}
ctx, cancel := withDeadline(cn.ctx, cn.writeDeadline)
defer cancel()
if err = internal.Call(ctx, "remote_socket", "Send", req, res); err != nil {
// assume zero bytes were sent in this RPC
break
}
n += int(res.GetDataSent())
cn.offset += int64(res.GetDataSent())
}
return
}
func (cn *Conn) Close() error {
req := &pb.CloseRequest{
SocketDescriptor: &cn.desc,
}
res := &pb.CloseReply{}
if err := internal.Call(cn.ctx, "remote_socket", "Close", req, res); err != nil {
return err
}
cn.desc = "CLOSED"
return nil
}
func addr(prot pb.CreateSocketRequest_SocketProtocol, ap *pb.AddressPort) net.Addr {
if ap == nil {
return nil
}
switch prot {
case pb.CreateSocketRequest_TCP:
return &net.TCPAddr{
IP: net.IP(ap.PackedAddress),
Port: int(*ap.Port),
}
case pb.CreateSocketRequest_UDP:
return &net.UDPAddr{
IP: net.IP(ap.PackedAddress),
Port: int(*ap.Port),
}
}
panic("unknown protocol " + prot.String())
}
func (cn *Conn) LocalAddr() net.Addr { return addr(cn.prot, cn.local) }
func (cn *Conn) RemoteAddr() net.Addr { return addr(cn.prot, cn.remote) }
func (cn *Conn) SetDeadline(t time.Time) error {
cn.readDeadline = t
cn.writeDeadline = t
return nil
}
func (cn *Conn) SetReadDeadline(t time.Time) error {
cn.readDeadline = t
return nil
}
func (cn *Conn) SetWriteDeadline(t time.Time) error {
cn.writeDeadline = t
return nil
}
// KeepAlive signals that the connection is still in use.
// It may be called to prevent the socket being closed due to inactivity.
func (cn *Conn) KeepAlive() error {
req := &pb.GetSocketNameRequest{
SocketDescriptor: &cn.desc,
}
res := &pb.GetSocketNameReply{}
return internal.Call(cn.ctx, "remote_socket", "GetSocketName", req, res)
}
func init() {
internal.RegisterErrorCodeMap("remote_socket", pb.RemoteSocketServiceError_ErrorCode_name)
}
================================================
FILE: vendor/google.golang.org/appengine/socket/socket_vm.go
================================================
// Copyright 2015 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
// +build !appengine
package socket
import (
"net"
"time"
"golang.org/x/net/context"
)
// Dial connects to the address addr on the network protocol.
// The address format is host:port, where host may be a hostname or an IP address.
// Known protocols are "tcp" and "udp".
// The returned connection satisfies net.Conn, and is valid while ctx is valid;
// if the connection is to be used after ctx becomes invalid, invoke SetContext
// with the new context.
func Dial(ctx context.Context, protocol, addr string) (*Conn, error) {
conn, err := net.Dial(protocol, addr)
if err != nil {
return nil, err
}
return &Conn{conn}, nil
}
// DialTimeout is like Dial but takes a timeout.
// The timeout includes name resolution, if required.
func DialTimeout(ctx context.Context, protocol, addr string, timeout time.Duration) (*Conn, error) {
conn, err := net.DialTimeout(protocol, addr, timeout)
if err != nil {
return nil, err
}
return &Conn{conn}, nil
}
// LookupIP returns the given host's IP addresses.
func LookupIP(ctx context.Context, host string) (addrs []net.IP, err error) {
return net.LookupIP(host)
}
// Conn represents a socket connection.
// It implements net.Conn.
type Conn struct {
net.Conn
}
// SetContext sets the context that is used by this Conn.
// It is usually used only when using a Conn that was created in a different context,
// such as when a connection is created during a warmup request but used while
// servicing a user request.
func (cn *Conn) SetContext(ctx context.Context) {
// This function is not required on managed VMs.
}
// KeepAlive signals that the connection is still in use.
// It may be called to prevent the socket being closed due to inactivity.
func (cn *Conn) KeepAlive() error {
// This function is not required on managed VMs.
return nil
}
================================================
FILE: vendor/google.golang.org/appengine/taskqueue/taskqueue.go
================================================
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
/*
Package taskqueue provides a client for App Engine's taskqueue service.
Using this service, applications may perform work outside a user's request.
A Task may be constructed manually; alternatively, since the most common
taskqueue operation is to add a single POST task, NewPOSTTask makes it easy.
t := taskqueue.NewPOSTTask("/worker", url.Values{
"key": {key},
})
taskqueue.Add(c, t, "") // add t to the default queue
*/
package taskqueue
import (
"errors"
"fmt"
"net/http"
"net/url"
"time"
"github.com/golang/protobuf/proto"
"golang.org/x/net/context"
"google.golang.org/appengine"
"google.golang.org/appengine/internal"
dspb "google.golang.org/appengine/internal/datastore"
pb "google.golang.org/appengine/internal/taskqueue"
)
var (
// ErrTaskAlreadyAdded is the error returned by Add and AddMulti when a task has already been added with a particular name.
ErrTaskAlreadyAdded = errors.New("taskqueue: task has already been added")
)
// RetryOptions let you control whether to retry a task and the backoff intervals between tries.
type RetryOptions struct {
// Number of tries/leases after which the task fails permanently and is deleted.
// If AgeLimit is also set, both limits must be exceeded for the task to fail permanently.
RetryLimit int32
// Maximum time allowed since the task's first try before the task fails permanently and is deleted (only for push tasks).
// If RetryLimit is also set, both limits must be exceeded for the task to fail permanently.
AgeLimit time.Duration
// Minimum time between successive tries (only for push tasks).
MinBackoff time.Duration
// Maximum time between successive tries (only for push tasks).
MaxBackoff time.Duration
// Maximum number of times to double the interval between successive tries before the intervals increase linearly (only for push tasks).
MaxDoublings int32
// If MaxDoublings is zero, set ApplyZeroMaxDoublings to true to override the default non-zero value.
// Otherwise a zero MaxDoublings is ignored and the default is used.
ApplyZeroMaxDoublings bool
}
// toRetryParameter converts RetryOptions to pb.TaskQueueRetryParameters.
func (opt *RetryOptions) toRetryParameters() *pb.TaskQueueRetryParameters {
params := &pb.TaskQueueRetryParameters{}
if opt.RetryLimit > 0 {
params.RetryLimit = proto.Int32(opt.RetryLimit)
}
if opt.AgeLimit > 0 {
params.AgeLimitSec = proto.Int64(int64(opt.AgeLimit.Seconds()))
}
if opt.MinBackoff > 0 {
params.MinBackoffSec = proto.Float64(opt.MinBackoff.Seconds())
}
if opt.MaxBackoff > 0 {
params.MaxBackoffSec = proto.Float64(opt.MaxBackoff.Seconds())
}
if opt.MaxDoublings > 0 || (opt.MaxDoublings == 0 && opt.ApplyZeroMaxDoublings) {
params.MaxDoublings = proto.Int32(opt.MaxDoublings)
}
return params
}
// A Task represents a task to be executed.
type Task struct {
// Path is the worker URL for the task.
// If unset, it will default to /_ah/queue/.
Path string
// Payload is the data for the task.
// This will be delivered as the HTTP request body.
// It is only used when Method is POST, PUT or PULL.
// url.Values' Encode method may be used to generate this for POST requests.
Payload []byte
// Additional HTTP headers to pass at the task's execution time.
// To schedule the task to be run with an alternate app version
// or backend, set the "Host" header.
Header http.Header
// Method is the HTTP method for the task ("GET", "POST", etc.),
// or "PULL" if this is task is destined for a pull-based queue.
// If empty, this defaults to "POST".
Method string
// A name for the task.
// If empty, a name will be chosen.
Name string
// Delay specifies the duration the task queue service must wait
// before executing the task.
// Either Delay or ETA may be set, but not both.
Delay time.Duration
// ETA specifies the earliest time a task may be executed (push queues)
// or leased (pull queues).
// Either Delay or ETA may be set, but not both.
ETA time.Time
// The number of times the task has been dispatched or leased.
RetryCount int32
// Tag for the task. Only used when Method is PULL.
Tag string
// Retry options for this task. May be nil.
RetryOptions *RetryOptions
}
func (t *Task) method() string {
if t.Method == "" {
return "POST"
}
return t.Method
}
// NewPOSTTask creates a Task that will POST to a path with the given form data.
func NewPOSTTask(path string, params url.Values) *Task {
h := make(http.Header)
h.Set("Content-Type", "application/x-www-form-urlencoded")
return &Task{
Path: path,
Payload: []byte(params.Encode()),
Header: h,
Method: "POST",
}
}
var (
currentNamespace = http.CanonicalHeaderKey("X-AppEngine-Current-Namespace")
defaultNamespace = http.CanonicalHeaderKey("X-AppEngine-Default-Namespace")
)
func getDefaultNamespace(ctx context.Context) string {
return internal.IncomingHeaders(ctx).Get(defaultNamespace)
}
func newAddReq(c context.Context, task *Task, queueName string) (*pb.TaskQueueAddRequest, error) {
if queueName == "" {
queueName = "default"
}
path := task.Path
if path == "" {
path = "/_ah/queue/" + queueName
}
eta := task.ETA
if eta.IsZero() {
eta = time.Now().Add(task.Delay)
} else if task.Delay != 0 {
panic("taskqueue: both Delay and ETA are set")
}
req := &pb.TaskQueueAddRequest{
QueueName: []byte(queueName),
TaskName: []byte(task.Name),
EtaUsec: proto.Int64(eta.UnixNano() / 1e3),
}
method := task.method()
if method == "PULL" {
// Pull-based task
req.Body = task.Payload
req.Mode = pb.TaskQueueMode_PULL.Enum()
if task.Tag != "" {
req.Tag = []byte(task.Tag)
}
} else {
// HTTP-based task
if v, ok := pb.TaskQueueAddRequest_RequestMethod_value[method]; ok {
req.Method = pb.TaskQueueAddRequest_RequestMethod(v).Enum()
} else {
return nil, fmt.Errorf("taskqueue: bad method %q", method)
}
req.Url = []byte(path)
for k, vs := range task.Header {
for _, v := range vs {
req.Header = append(req.Header, &pb.TaskQueueAddRequest_Header{
Key: []byte(k),
Value: []byte(v),
})
}
}
if method == "POST" || method == "PUT" {
req.Body = task.Payload
}
// Namespace headers.
if _, ok := task.Header[currentNamespace]; !ok {
// Fetch the current namespace of this request.
ns := internal.NamespaceFromContext(c)
req.Header = append(req.Header, &pb.TaskQueueAddRequest_Header{
Key: []byte(currentNamespace),
Value: []byte(ns),
})
}
if _, ok := task.Header[defaultNamespace]; !ok {
// Fetch the X-AppEngine-Default-Namespace header of this request.
if ns := getDefaultNamespace(c); ns != "" {
req.Header = append(req.Header, &pb.TaskQueueAddRequest_Header{
Key: []byte(defaultNamespace),
Value: []byte(ns),
})
}
}
}
if task.RetryOptions != nil {
req.RetryParameters = task.RetryOptions.toRetryParameters()
}
return req, nil
}
var alreadyAddedErrors = map[pb.TaskQueueServiceError_ErrorCode]bool{
pb.TaskQueueServiceError_TASK_ALREADY_EXISTS: true,
pb.TaskQueueServiceError_TOMBSTONED_TASK: true,
}
// Add adds the task to a named queue.
// An empty queue name means that the default queue will be used.
// Add returns an equivalent Task with defaults filled in, including setting
// the task's Name field to the chosen name if the original was empty.
func Add(c context.Context, task *Task, queueName string) (*Task, error) {
req, err := newAddReq(c, task, queueName)
if err != nil {
return nil, err
}
res := &pb.TaskQueueAddResponse{}
if err := internal.Call(c, "taskqueue", "Add", req, res); err != nil {
apiErr, ok := err.(*internal.APIError)
if ok && alreadyAddedErrors[pb.TaskQueueServiceError_ErrorCode(apiErr.Code)] {
return nil, ErrTaskAlreadyAdded
}
return nil, err
}
resultTask := *task
resultTask.Method = task.method()
if task.Name == "" {
resultTask.Name = string(res.ChosenTaskName)
}
return &resultTask, nil
}
// AddMulti adds multiple tasks to a named queue.
// An empty queue name means that the default queue will be used.
// AddMulti returns a slice of equivalent tasks with defaults filled in, including setting
// each task's Name field to the chosen name if the original was empty.
// If a given task is badly formed or could not be added, an appengine.MultiError is returned.
func AddMulti(c context.Context, tasks []*Task, queueName string) ([]*Task, error) {
req := &pb.TaskQueueBulkAddRequest{
AddRequest: make([]*pb.TaskQueueAddRequest, len(tasks)),
}
me, any := make(appengine.MultiError, len(tasks)), false
for i, t := range tasks {
req.AddRequest[i], me[i] = newAddReq(c, t, queueName)
any = any || me[i] != nil
}
if any {
return nil, me
}
res := &pb.TaskQueueBulkAddResponse{}
if err := internal.Call(c, "taskqueue", "BulkAdd", req, res); err != nil {
return nil, err
}
if len(res.Taskresult) != len(tasks) {
return nil, errors.New("taskqueue: server error")
}
tasksOut := make([]*Task, len(tasks))
for i, tr := range res.Taskresult {
tasksOut[i] = new(Task)
*tasksOut[i] = *tasks[i]
tasksOut[i].Method = tasksOut[i].method()
if tasksOut[i].Name == "" {
tasksOut[i].Name = string(tr.ChosenTaskName)
}
if *tr.Result != pb.TaskQueueServiceError_OK {
if alreadyAddedErrors[*tr.Result] {
me[i] = ErrTaskAlreadyAdded
} else {
me[i] = &internal.APIError{
Service: "taskqueue",
Code: int32(*tr.Result),
}
}
any = true
}
}
if any {
return tasksOut, me
}
return tasksOut, nil
}
// Delete deletes a task from a named queue.
func Delete(c context.Context, task *Task, queueName string) error {
err := DeleteMulti(c, []*Task{task}, queueName)
if me, ok := err.(appengine.MultiError); ok {
return me[0]
}
return err
}
// DeleteMulti deletes multiple tasks from a named queue.
// If a given task could not be deleted, an appengine.MultiError is returned.
func DeleteMulti(c context.Context, tasks []*Task, queueName string) error {
taskNames := make([][]byte, len(tasks))
for i, t := range tasks {
taskNames[i] = []byte(t.Name)
}
if queueName == "" {
queueName = "default"
}
req := &pb.TaskQueueDeleteRequest{
QueueName: []byte(queueName),
TaskName: taskNames,
}
res := &pb.TaskQueueDeleteResponse{}
if err := internal.Call(c, "taskqueue", "Delete", req, res); err != nil {
return err
}
if a, b := len(req.TaskName), len(res.Result); a != b {
return fmt.Errorf("taskqueue: internal error: requested deletion of %d tasks, got %d results", a, b)
}
me, any := make(appengine.MultiError, len(res.Result)), false
for i, ec := range res.Result {
if ec != pb.TaskQueueServiceError_OK {
me[i] = &internal.APIError{
Service: "taskqueue",
Code: int32(ec),
}
any = true
}
}
if any {
return me
}
return nil
}
func lease(c context.Context, maxTasks int, queueName string, leaseTime int, groupByTag bool, tag []byte) ([]*Task, error) {
if queueName == "" {
queueName = "default"
}
req := &pb.TaskQueueQueryAndOwnTasksRequest{
QueueName: []byte(queueName),
LeaseSeconds: proto.Float64(float64(leaseTime)),
MaxTasks: proto.Int64(int64(maxTasks)),
GroupByTag: proto.Bool(groupByTag),
Tag: tag,
}
res := &pb.TaskQueueQueryAndOwnTasksResponse{}
if err := internal.Call(c, "taskqueue", "QueryAndOwnTasks", req, res); err != nil {
return nil, err
}
tasks := make([]*Task, len(res.Task))
for i, t := range res.Task {
tasks[i] = &Task{
Payload: t.Body,
Name: string(t.TaskName),
Method: "PULL",
ETA: time.Unix(0, *t.EtaUsec*1e3),
RetryCount: *t.RetryCount,
Tag: string(t.Tag),
}
}
return tasks, nil
}
// Lease leases tasks from a queue.
// leaseTime is in seconds.
// The number of tasks fetched will be at most maxTasks.
func Lease(c context.Context, maxTasks int, queueName string, leaseTime int) ([]*Task, error) {
return lease(c, maxTasks, queueName, leaseTime, false, nil)
}
// LeaseByTag leases tasks from a queue, grouped by tag.
// If tag is empty, then the returned tasks are grouped by the tag of the task with earliest ETA.
// leaseTime is in seconds.
// The number of tasks fetched will be at most maxTasks.
func LeaseByTag(c context.Context, maxTasks int, queueName string, leaseTime int, tag string) ([]*Task, error) {
return lease(c, maxTasks, queueName, leaseTime, true, []byte(tag))
}
// Purge removes all tasks from a queue.
func Purge(c context.Context, queueName string) error {
if queueName == "" {
queueName = "default"
}
req := &pb.TaskQueuePurgeQueueRequest{
QueueName: []byte(queueName),
}
res := &pb.TaskQueuePurgeQueueResponse{}
return internal.Call(c, "taskqueue", "PurgeQueue", req, res)
}
// ModifyLease modifies the lease of a task.
// Used to request more processing time, or to abandon processing.
// leaseTime is in seconds and must not be negative.
func ModifyLease(c context.Context, task *Task, queueName string, leaseTime int) error {
if queueName == "" {
queueName = "default"
}
req := &pb.TaskQueueModifyTaskLeaseRequest{
QueueName: []byte(queueName),
TaskName: []byte(task.Name),
EtaUsec: proto.Int64(task.ETA.UnixNano() / 1e3), // Used to verify ownership.
LeaseSeconds: proto.Float64(float64(leaseTime)),
}
res := &pb.TaskQueueModifyTaskLeaseResponse{}
if err := internal.Call(c, "taskqueue", "ModifyTaskLease", req, res); err != nil {
return err
}
task.ETA = time.Unix(0, *res.UpdatedEtaUsec*1e3)
return nil
}
// QueueStatistics represents statistics about a single task queue.
type QueueStatistics struct {
Tasks int // may be an approximation
OldestETA time.Time // zero if there are no pending tasks
Executed1Minute int // tasks executed in the last minute
InFlight int // tasks executing now
EnforcedRate float64 // requests per second
}
// QueueStats retrieves statistics about queues.
func QueueStats(c context.Context, queueNames []string) ([]QueueStatistics, error) {
req := &pb.TaskQueueFetchQueueStatsRequest{
QueueName: make([][]byte, len(queueNames)),
}
for i, q := range queueNames {
if q == "" {
q = "default"
}
req.QueueName[i] = []byte(q)
}
res := &pb.TaskQueueFetchQueueStatsResponse{}
if err := internal.Call(c, "taskqueue", "FetchQueueStats", req, res); err != nil {
return nil, err
}
qs := make([]QueueStatistics, len(res.Queuestats))
for i, qsg := range res.Queuestats {
qs[i] = QueueStatistics{
Tasks: int(*qsg.NumTasks),
}
if eta := *qsg.OldestEtaUsec; eta > -1 {
qs[i].OldestETA = time.Unix(0, eta*1e3)
}
if si := qsg.ScannerInfo; si != nil {
qs[i].Executed1Minute = int(*si.ExecutedLastMinute)
qs[i].InFlight = int(si.GetRequestsInFlight())
qs[i].EnforcedRate = si.GetEnforcedRate()
}
}
return qs, nil
}
func setTransaction(x *pb.TaskQueueAddRequest, t *dspb.Transaction) {
x.Transaction = t
}
func init() {
internal.RegisterErrorCodeMap("taskqueue", pb.TaskQueueServiceError_ErrorCode_name)
// Datastore error codes are shifted by DATASTORE_ERROR when presented through taskqueue.
dsCode := int32(pb.TaskQueueServiceError_DATASTORE_ERROR) + int32(dspb.Error_TIMEOUT)
internal.RegisterTimeoutErrorCode("taskqueue", dsCode)
// Transaction registration.
internal.RegisterTransactionSetter(setTransaction)
internal.RegisterTransactionSetter(func(x *pb.TaskQueueBulkAddRequest, t *dspb.Transaction) {
for _, req := range x.AddRequest {
setTransaction(req, t)
}
})
}
================================================
FILE: vendor/google.golang.org/appengine/timeout.go
================================================
// Copyright 2013 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
package appengine
import "golang.org/x/net/context"
// IsTimeoutError reports whether err is a timeout error.
func IsTimeoutError(err error) bool {
if err == context.DeadlineExceeded {
return true
}
if t, ok := err.(interface {
IsTimeout() bool
}); ok {
return t.IsTimeout()
}
return false
}
================================================
FILE: vendor/google.golang.org/appengine/urlfetch/urlfetch.go
================================================
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
// Package urlfetch provides an http.RoundTripper implementation
// for fetching URLs via App Engine's urlfetch service.
package urlfetch
import (
"errors"
"fmt"
"io"
"io/ioutil"
"net/http"
"net/url"
"strconv"
"strings"
"time"
"github.com/golang/protobuf/proto"
"golang.org/x/net/context"
"google.golang.org/appengine/internal"
pb "google.golang.org/appengine/internal/urlfetch"
)
// Transport is an implementation of http.RoundTripper for
// App Engine. Users should generally create an http.Client using
// this transport and use the Client rather than using this transport
// directly.
type Transport struct {
Context context.Context
// Controls whether the application checks the validity of SSL certificates
// over HTTPS connections. A value of false (the default) instructs the
// application to send a request to the server only if the certificate is
// valid and signed by a trusted certificate authority (CA), and also
// includes a hostname that matches the certificate. A value of true
// instructs the application to perform no certificate validation.
AllowInvalidServerCertificate bool
}
// Verify statically that *Transport implements http.RoundTripper.
var _ http.RoundTripper = (*Transport)(nil)
// Client returns an *http.Client using a default urlfetch Transport. This
// client will have the default deadline of 5 seconds, and will check the
// validity of SSL certificates.
//
// Any deadline of the provided context will be used for requests through this client;
// if the client does not have a deadline then a 5 second default is used.
func Client(ctx context.Context) *http.Client {
return &http.Client{
Transport: &Transport{
Context: ctx,
},
}
}
type bodyReader struct {
content []byte
truncated bool
closed bool
}
// ErrTruncatedBody is the error returned after the final Read() from a
// response's Body if the body has been truncated by App Engine's proxy.
var ErrTruncatedBody = errors.New("urlfetch: truncated body")
func statusCodeToText(code int) string {
if t := http.StatusText(code); t != "" {
return t
}
return strconv.Itoa(code)
}
func (br *bodyReader) Read(p []byte) (n int, err error) {
if br.closed {
if br.truncated {
return 0, ErrTruncatedBody
}
return 0, io.EOF
}
n = copy(p, br.content)
if n > 0 {
br.content = br.content[n:]
return
}
if br.truncated {
br.closed = true
return 0, ErrTruncatedBody
}
return 0, io.EOF
}
func (br *bodyReader) Close() error {
br.closed = true
br.content = nil
return nil
}
// A map of the URL Fetch-accepted methods that take a request body.
var methodAcceptsRequestBody = map[string]bool{
"POST": true,
"PUT": true,
"PATCH": true,
}
// urlString returns a valid string given a URL. This function is necessary because
// the String method of URL doesn't correctly handle URLs with non-empty Opaque values.
// See http://code.google.com/p/go/issues/detail?id=4860.
func urlString(u *url.URL) string {
if u.Opaque == "" || strings.HasPrefix(u.Opaque, "//") {
return u.String()
}
aux := *u
aux.Opaque = "//" + aux.Host + aux.Opaque
return aux.String()
}
// RoundTrip issues a single HTTP request and returns its response. Per the
// http.RoundTripper interface, RoundTrip only returns an error if there
// was an unsupported request or the URL Fetch proxy fails.
// Note that HTTP response codes such as 5xx, 403, 404, etc are not
// errors as far as the transport is concerned and will be returned
// with err set to nil.
func (t *Transport) RoundTrip(req *http.Request) (res *http.Response, err error) {
methNum, ok := pb.URLFetchRequest_RequestMethod_value[req.Method]
if !ok {
return nil, fmt.Errorf("urlfetch: unsupported HTTP method %q", req.Method)
}
method := pb.URLFetchRequest_RequestMethod(methNum)
freq := &pb.URLFetchRequest{
Method: &method,
Url: proto.String(urlString(req.URL)),
FollowRedirects: proto.Bool(false), // http.Client's responsibility
MustValidateServerCertificate: proto.Bool(!t.AllowInvalidServerCertificate),
}
if deadline, ok := t.Context.Deadline(); ok {
freq.Deadline = proto.Float64(deadline.Sub(time.Now()).Seconds())
}
for k, vals := range req.Header {
for _, val := range vals {
freq.Header = append(freq.Header, &pb.URLFetchRequest_Header{
Key: proto.String(k),
Value: proto.String(val),
})
}
}
if methodAcceptsRequestBody[req.Method] && req.Body != nil {
// Avoid a []byte copy if req.Body has a Bytes method.
switch b := req.Body.(type) {
case interface {
Bytes() []byte
}:
freq.Payload = b.Bytes()
default:
freq.Payload, err = ioutil.ReadAll(req.Body)
if err != nil {
return nil, err
}
}
}
fres := &pb.URLFetchResponse{}
if err := internal.Call(t.Context, "urlfetch", "Fetch", freq, fres); err != nil {
return nil, err
}
res = &http.Response{}
res.StatusCode = int(*fres.StatusCode)
res.Status = fmt.Sprintf("%d %s", res.StatusCode, statusCodeToText(res.StatusCode))
res.Header = make(http.Header)
res.Request = req
// Faked:
res.ProtoMajor = 1
res.ProtoMinor = 1
res.Proto = "HTTP/1.1"
res.Close = true
for _, h := range fres.Header {
hkey := http.CanonicalHeaderKey(*h.Key)
hval := *h.Value
if hkey == "Content-Length" {
// Will get filled in below for all but HEAD requests.
if req.Method == "HEAD" {
res.ContentLength, _ = strconv.ParseInt(hval, 10, 64)
}
continue
}
res.Header.Add(hkey, hval)
}
if req.Method != "HEAD" {
res.ContentLength = int64(len(fres.Content))
}
truncated := fres.GetContentWasTruncated()
res.Body = &bodyReader{content: fres.Content, truncated: truncated}
return
}
func init() {
internal.RegisterErrorCodeMap("urlfetch", pb.URLFetchServiceError_ErrorCode_name)
internal.RegisterTimeoutErrorCode("urlfetch", int32(pb.URLFetchServiceError_DEADLINE_EXCEEDED))
}
================================================
FILE: vendor/google.golang.org/appengine/user/oauth.go
================================================
// Copyright 2012 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
package user
import (
"golang.org/x/net/context"
"google.golang.org/appengine/internal"
pb "google.golang.org/appengine/internal/user"
)
// CurrentOAuth returns the user associated with the OAuth consumer making this
// request. If the OAuth consumer did not make a valid OAuth request, or the
// scopes is non-empty and the current user does not have at least one of the
// scopes, this method will return an error.
func CurrentOAuth(c context.Context, scopes ...string) (*User, error) {
req := &pb.GetOAuthUserRequest{}
if len(scopes) != 1 || scopes[0] != "" {
// The signature for this function used to be CurrentOAuth(Context, string).
// Ignore the singular "" scope to preserve existing behavior.
req.Scopes = scopes
}
res := &pb.GetOAuthUserResponse{}
err := internal.Call(c, "user", "GetOAuthUser", req, res)
if err != nil {
return nil, err
}
return &User{
Email: *res.Email,
AuthDomain: *res.AuthDomain,
Admin: res.GetIsAdmin(),
ID: *res.UserId,
ClientID: res.GetClientId(),
}, nil
}
// OAuthConsumerKey returns the OAuth consumer key provided with the current
// request. This method will return an error if the OAuth request was invalid.
func OAuthConsumerKey(c context.Context) (string, error) {
req := &pb.CheckOAuthSignatureRequest{}
res := &pb.CheckOAuthSignatureResponse{}
err := internal.Call(c, "user", "CheckOAuthSignature", req, res)
if err != nil {
return "", err
}
return *res.OauthConsumerKey, err
}
================================================
FILE: vendor/google.golang.org/appengine/user/user.go
================================================
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
// Package user provides a client for App Engine's user authentication service.
package user
import (
"strings"
"github.com/golang/protobuf/proto"
"golang.org/x/net/context"
"google.golang.org/appengine/internal"
pb "google.golang.org/appengine/internal/user"
)
// User represents a user of the application.
type User struct {
Email string
AuthDomain string
Admin bool
// ID is the unique permanent ID of the user.
// It is populated if the Email is associated
// with a Google account, or empty otherwise.
ID string
// ClientID is the ID of the pre-registered client so its identity can be verified.
// See https://developers.google.com/console/help/#generatingoauth2 for more information.
ClientID string
FederatedIdentity string
FederatedProvider string
}
// String returns a displayable name for the user.
func (u *User) String() string {
if u.AuthDomain != "" && strings.HasSuffix(u.Email, "@"+u.AuthDomain) {
return u.Email[:len(u.Email)-len("@"+u.AuthDomain)]
}
if u.FederatedIdentity != "" {
return u.FederatedIdentity
}
return u.Email
}
// LoginURL returns a URL that, when visited, prompts the user to sign in,
// then redirects the user to the URL specified by dest.
func LoginURL(c context.Context, dest string) (string, error) {
return LoginURLFederated(c, dest, "")
}
// LoginURLFederated is like LoginURL but accepts a user's OpenID identifier.
func LoginURLFederated(c context.Context, dest, identity string) (string, error) {
req := &pb.CreateLoginURLRequest{
DestinationUrl: proto.String(dest),
}
if identity != "" {
req.FederatedIdentity = proto.String(identity)
}
res := &pb.CreateLoginURLResponse{}
if err := internal.Call(c, "user", "CreateLoginURL", req, res); err != nil {
return "", err
}
return *res.LoginUrl, nil
}
// LogoutURL returns a URL that, when visited, signs the user out,
// then redirects the user to the URL specified by dest.
func LogoutURL(c context.Context, dest string) (string, error) {
req := &pb.CreateLogoutURLRequest{
DestinationUrl: proto.String(dest),
}
res := &pb.CreateLogoutURLResponse{}
if err := internal.Call(c, "user", "CreateLogoutURL", req, res); err != nil {
return "", err
}
return *res.LogoutUrl, nil
}
func init() {
internal.RegisterErrorCodeMap("user", pb.UserServiceError_ErrorCode_name)
}
================================================
FILE: vendor/google.golang.org/appengine/user/user_classic.go
================================================
// Copyright 2015 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
// +build appengine
package user
import (
"appengine/user"
"golang.org/x/net/context"
"google.golang.org/appengine/internal"
)
func Current(ctx context.Context) *User {
u := user.Current(internal.ClassicContextFromContext(ctx))
if u == nil {
return nil
}
// Map appengine/user.User to this package's User type.
return &User{
Email: u.Email,
AuthDomain: u.AuthDomain,
Admin: u.Admin,
ID: u.ID,
FederatedIdentity: u.FederatedIdentity,
FederatedProvider: u.FederatedProvider,
}
}
func IsAdmin(ctx context.Context) bool {
return user.IsAdmin(internal.ClassicContextFromContext(ctx))
}
================================================
FILE: vendor/google.golang.org/appengine/user/user_vm.go
================================================
// Copyright 2014 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
// +build !appengine
package user
import (
"golang.org/x/net/context"
"google.golang.org/appengine/internal"
)
// Current returns the currently logged-in user,
// or nil if the user is not signed in.
func Current(c context.Context) *User {
h := internal.IncomingHeaders(c)
u := &User{
Email: h.Get("X-AppEngine-User-Email"),
AuthDomain: h.Get("X-AppEngine-Auth-Domain"),
ID: h.Get("X-AppEngine-User-Id"),
Admin: h.Get("X-AppEngine-User-Is-Admin") == "1",
FederatedIdentity: h.Get("X-AppEngine-Federated-Identity"),
FederatedProvider: h.Get("X-AppEngine-Federated-Provider"),
}
if u.Email == "" && u.FederatedIdentity == "" {
return nil
}
return u
}
// IsAdmin returns true if the current user is signed in and
// is currently registered as an administrator of the application.
func IsAdmin(c context.Context) bool {
h := internal.IncomingHeaders(c)
return h.Get("X-AppEngine-User-Is-Admin") == "1"
}
================================================
FILE: vendor/google.golang.org/appengine/xmpp/xmpp.go
================================================
// Copyright 2011 Google Inc. All rights reserved.
// Use of this source code is governed by the Apache 2.0
// license that can be found in the LICENSE file.
/*
Package xmpp provides the means to send and receive instant messages
to and from users of XMPP-compatible services.
To send a message,
m := &xmpp.Message{
To: []string{"kaylee@example.com"},
Body: `Hi! How's the carrot?`,
}
err := m.Send(c)
To receive messages,
func init() {
xmpp.Handle(handleChat)
}
func handleChat(c context.Context, m *xmpp.Message) {
// ...
}
*/
package xmpp
import (
"errors"
"fmt"
"net/http"
"golang.org/x/net/context"
"google.golang.org/appengine"
"google.golang.org/appengine/internal"
pb "google.golang.org/appengine/internal/xmpp"
)
// Message represents an incoming chat message.
type Message struct {
// Sender is the JID of the sender.
// Optional for outgoing messages.
Sender string
// To is the intended recipients of the message.
// Incoming messages will have exactly one element.
To []string
// Body is the body of the message.
Body string
// Type is the message type, per RFC 3921.
// It defaults to "chat".
Type string
// RawXML is whether the body contains raw XML.
RawXML bool
}
// Presence represents an outgoing presence update.
type Presence struct {
// Sender is the JID (optional).
Sender string
// The intended recipient of the presence update.
To string
// Type, per RFC 3921 (optional). Defaults to "available".
Type string
// State of presence (optional).
// Valid values: "away", "chat", "xa", "dnd" (RFC 3921).
State string
// Free text status message (optional).
Status string
}
var (
ErrPresenceUnavailable = errors.New("xmpp: presence unavailable")
ErrInvalidJID = errors.New("xmpp: invalid JID")
)
// Handle arranges for f to be called for incoming XMPP messages.
// Only messages of type "chat" or "normal" will be handled.
func Handle(f func(c context.Context, m *Message)) {
http.HandleFunc("/_ah/xmpp/message/chat/", func(_ http.ResponseWriter, r *http.Request) {
f(appengine.NewContext(r), &Message{
Sender: r.FormValue("from"),
To: []string{r.FormValue("to")},
Body: r.FormValue("body"),
})
})
}
// Send sends a message.
// If any failures occur with specific recipients, the error will be an appengine.MultiError.
func (m *Message) Send(c context.Context) error {
req := &pb.XmppMessageRequest{
Jid: m.To,
Body: &m.Body,
RawXml: &m.RawXML,
}
if m.Type != "" && m.Type != "chat" {
req.Type = &m.Type
}
if m.Sender != "" {
req.FromJid = &m.Sender
}
res := &pb.XmppMessageResponse{}
if err := internal.Call(c, "xmpp", "SendMessage", req, res); err != nil {
return err
}
if len(res.Status) != len(req.Jid) {
return fmt.Errorf("xmpp: sent message to %d JIDs, but only got %d statuses back", len(req.Jid), len(res.Status))
}
me, any := make(appengine.MultiError, len(req.Jid)), false
for i, st := range res.Status {
if st != pb.XmppMessageResponse_NO_ERROR {
me[i] = errors.New(st.String())
any = true
}
}
if any {
return me
}
return nil
}
// Invite sends an invitation. If the from address is an empty string
// the default (yourapp@appspot.com/bot) will be used.
func Invite(c context.Context, to, from string) error {
req := &pb.XmppInviteRequest{
Jid: &to,
}
if from != "" {
req.FromJid = &from
}
res := &pb.XmppInviteResponse{}
return internal.Call(c, "xmpp", "SendInvite", req, res)
}
// Send sends a presence update.
func (p *Presence) Send(c context.Context) error {
req := &pb.XmppSendPresenceRequest{
Jid: &p.To,
}
if p.State != "" {
req.Show = &p.State
}
if p.Type != "" {
req.Type = &p.Type
}
if p.Sender != "" {
req.FromJid = &p.Sender
}
if p.Status != "" {
req.Status = &p.Status
}
res := &pb.XmppSendPresenceResponse{}
return internal.Call(c, "xmpp", "SendPresence", req, res)
}
var presenceMap = map[pb.PresenceResponse_SHOW]string{
pb.PresenceResponse_NORMAL: "",
pb.PresenceResponse_AWAY: "away",
pb.PresenceResponse_DO_NOT_DISTURB: "dnd",
pb.PresenceResponse_CHAT: "chat",
pb.PresenceResponse_EXTENDED_AWAY: "xa",
}
// GetPresence retrieves a user's presence.
// If the from address is an empty string the default
// (yourapp@appspot.com/bot) will be used.
// Possible return values are "", "away", "dnd", "chat", "xa".
// ErrPresenceUnavailable is returned if the presence is unavailable.
func GetPresence(c context.Context, to string, from string) (string, error) {
req := &pb.PresenceRequest{
Jid: &to,
}
if from != "" {
req.FromJid = &from
}
res := &pb.PresenceResponse{}
if err := internal.Call(c, "xmpp", "GetPresence", req, res); err != nil {
return "", err
}
if !*res.IsAvailable || res.Presence == nil {
return "", ErrPresenceUnavailable
}
presence, ok := presenceMap[*res.Presence]
if ok {
return presence, nil
}
return "", fmt.Errorf("xmpp: unknown presence %v", *res.Presence)
}
// GetPresenceMulti retrieves multiple users' presence.
// If the from address is an empty string the default
// (yourapp@appspot.com/bot) will be used.
// Possible return values are "", "away", "dnd", "chat", "xa".
// If any presence is unavailable, an appengine.MultiError is returned
func GetPresenceMulti(c context.Context, to []string, from string) ([]string, error) {
req := &pb.BulkPresenceRequest{
Jid: to,
}
if from != "" {
req.FromJid = &from
}
res := &pb.BulkPresenceResponse{}
if err := internal.Call(c, "xmpp", "BulkGetPresence", req, res); err != nil {
return nil, err
}
presences := make([]string, 0, len(res.PresenceResponse))
errs := appengine.MultiError{}
addResult := func(presence string, err error) {
presences = append(presences, presence)
errs = append(errs, err)
}
anyErr := false
for _, subres := range res.PresenceResponse {
if !subres.GetValid() {
anyErr = true
addResult("", ErrInvalidJID)
continue
}
if !*subres.IsAvailable || subres.Presence == nil {
anyErr = true
addResult("", ErrPresenceUnavailable)
continue
}
presence, ok := presenceMap[*subres.Presence]
if ok {
addResult(presence, nil)
} else {
anyErr = true
addResult("", fmt.Errorf("xmpp: unknown presence %q", *subres.Presence))
}
}
if anyErr {
return presences, errs
}
return presences, nil
}
func init() {
internal.RegisterErrorCodeMap("xmpp", pb.XmppServiceError_ErrorCode_name)
}
================================================
FILE: vendor/google.golang.org/cloud/.travis.yml
================================================
language: go
go:
- 1.4
- tip
install:
- go get -v google.golang.org/cloud/...
script:
- openssl aes-256-cbc -K $encrypted_912ff8fa81ad_key -iv $encrypted_912ff8fa81ad_iv -in key.json.enc -out key.json -d
- GCLOUD_TESTS_GOLANG_PROJECT_ID="dulcet-port-762" GCLOUD_TESTS_GOLANG_KEY="$(pwd)/key.json"
go test -v -tags=integration google.golang.org/cloud/...
================================================
FILE: vendor/google.golang.org/cloud/AUTHORS
================================================
# This is the official list of cloud authors for copyright purposes.
# This file is distinct from the CONTRIBUTORS files.
# See the latter for an explanation.
# Names should be added to this file as:
# Name or Organization
# The email address is not required for organizations.
Google Inc.
Palm Stone Games, Inc.
Péter Szilágyi
Tyler Treat
================================================
FILE: vendor/google.golang.org/cloud/CONTRIBUTING.md
================================================
# Contributing
1. Sign one of the contributor license agreements below.
1. `go get golang.org/x/review/git-review` to install the code reviewing tool.
1. Get the cloud package by running `go get -d google.golang.org/cloud`.
If you've already got the package, make sure that the remote git origin
is https://code.googlesource.com/gocloud.
`git remote set-url origin https://code.googlesource.com/gocloud`
1. Make changes and create a change by running `review change `,
provide a command message, and use `review mail` to create a Gerrit CL.
1. Keep amending to the change and mail as your recieve feedback.
## Integration Tests
Additional to the unit tests, you may run the integration test suite.
To run the integrations tests, creating and configuration of a project in the
Google Developers Console is required. Once you create a project, set the
following environment variables to be able to run the against the actual APIs.
- **GCLOUD_TESTS_GOLANG_PROJECT_ID**: Developers Console project's ID (e.g. bamboo-shift-455)
- **GCLOUD_TESTS_GOLANG_KEY**: The path to the JSON key file.
Create a storage bucket with the same name as the project id set in **GCLOUD_TESTS_GOLANG_PROJECT_ID**.
The storage integration test will create and delete some objects in this bucket.
Install the [gcloud command-line tool][gcloudcli] to your machine and use it
to create the indexes used in the datastore integration tests with indexes
found in `datastore/testdata/index.yaml`:
From the project's root directory:
``` sh
# Install the app component
$ gcloud components update app
# Set the default project in your env
$ gcloud config set project $GCLOUD_TESTS_GOLANG_PROJECT_ID
# Authenticate the gcloud tool with your account
$ gcloud auth login
# Create the indexes
$ gcloud preview datastore create-indexes datastore/testdata
```
You can run the integration tests by running:
``` sh
$ go test -v -tags=integration google.golang.org/cloud/...
```
## Contributor License Agreements
Before we can accept your pull requests you'll need to sign a Contributor
License Agreement (CLA):
- **If you are an individual writing original source code** and **you own the
- intellectual property**, then you'll need to sign an [individual CLA][indvcla].
- **If you work for a company that wants to allow you to contribute your work**,
then you'll need to sign a [corporate CLA][corpcla].
You can sign these electronically (just scroll to the bottom). After that,
we'll be able to accept your pull requests.
[gcloudcli]: https://developers.google.com/cloud/sdk/gcloud/
[indvcla]: https://developers.google.com/open-source/cla/individual
[corpcla]: https://developers.google.com/open-source/cla/corporate
================================================
FILE: vendor/google.golang.org/cloud/CONTRIBUTORS
================================================
# People who have agreed to one of the CLAs and can contribute patches.
# The AUTHORS file lists the copyright holders; this file
# lists people. For example, Google employees are listed here
# but not in AUTHORS, because Google holds the copyright.
#
# https://developers.google.com/open-source/cla/individual
# https://developers.google.com/open-source/cla/corporate
#
# Names should be added to this file as:
# Name
# Keep the list alphabetically sorted.
Andrew Gerrand
Brad Fitzpatrick
Burcu Dogan
Dave Day
David Symonds
Glenn Lewis
Johan Euphrosine
Luna Duclos
Michael McGreevy
Péter Szilágyi
Tyler Treat
================================================
FILE: vendor/google.golang.org/cloud/LICENSE
================================================
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright 2014 Google Inc.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
================================================
FILE: vendor/google.golang.org/cloud/README.md
================================================
# Google Cloud for Go
[](https://travis-ci.org/GoogleCloudPlatform/gcloud-golang)
**NOTE:** These packages are experimental, and may occasionally make
backwards-incompatible changes.
**NOTE:** Github repo is a mirror of [https://code.googlesource.com/gocloud](https://code.googlesource.com/gocloud).
Go packages for Google Cloud Platform services. Supported APIs include:
* Google Cloud Datastore
* Google Cloud Storage
* Google Cloud Pub/Sub
* Google Cloud Container Engine
``` go
import "google.golang.org/cloud"
```
Documentation and examples are available at
[https://godoc.org/google.golang.org/cloud](https://godoc.org/google.golang.org/cloud).
## Authorization
Authorization, throughout the package, is delegated to the godoc.org/golang.org/x/oauth2.
Refer to the [godoc documentation](https://godoc.org/golang.org/x/oauth2)
for examples on using oauth2 with the Cloud package.
## Google Cloud Datastore
[Google Cloud Datastore][cloud-datastore] ([docs][cloud-datastore-docs]) is a fully
managed, schemaless database for storing non-relational data. Cloud Datastore
automatically scales with your users and supports ACID transactions, high availability
of reads and writes, strong consistency for reads and ancestor queries, and eventual
consistency for all other queries.
Follow the [activation instructions][cloud-datastore-activation] to use the Google
Cloud Datastore API with your project.
[https://godoc.org/google.golang.org/cloud/datastore](https://godoc.org/google.golang.org/cloud/datastore)
```go
type Post struct {
Title string
Body string `datastore:",noindex"`
PublishedAt time.Time
}
keys := []*datastore.Key{
datastore.NewKey(ctx, "Post", "post1", 0, nil),
datastore.NewKey(ctx, "Post", "post2", 0, nil),
}
posts := []*Post{
{Title: "Post 1", Body: "...", PublishedAt: time.Now()},
{Title: "Post 2", Body: "...", PublishedAt: time.Now()},
}
if _, err := datastore.PutMulti(ctx, keys, posts); err != nil {
log.Println(err)
}
```
## Google Cloud Storage
[Google Cloud Storage][cloud-storage] ([docs][cloud-storage-docs]) allows you to store
data on Google infrastructure with very high reliability, performance and availability,
and can be used to distribute large data objects to users via direct download.
[https://godoc.org/google.golang.org/cloud/storage](https://godoc.org/google.golang.org/cloud/storage)
```go
// Read the object1 from bucket.
rc, err := storage.NewReader(ctx, "bucket", "object1")
if err != nil {
log.Fatal(err)
}
slurp, err := ioutil.ReadAll(rc)
rc.Close()
if err != nil {
log.Fatal(err)
}
```
## Google Cloud Pub/Sub (Alpha)
> Google Cloud Pub/Sub is in **Alpha status**. As a result, it might change in
> backward-incompatible ways and is not recommended for production use. It is not
> subject to any SLA or deprecation policy.
[Google Cloud Pub/Sub][cloud-pubsub] ([docs][cloud-pubsub-docs]) allows you to connect
your services with reliable, many-to-many, asynchronous messaging hosted on Google's
infrastructure. Cloud Pub/Sub automatically scales as you need it and provides a foundation
for building your own robust, global services.
[https://godoc.org/google.golang.org/cloud/pubsub](https://godoc.org/google.golang.org/cloud/pubsub)
```go
// Publish "hello world" on topic1.
msgIDs, err := pubsub.Publish(ctx, "topic1", &pubsub.Message{
Data: []byte("hello world"),
})
if err != nil {
log.Println(err)
}
// Pull messages via subscription1.
msgs, err := pubsub.Pull(ctx, "subscription1", 1)
if err != nil {
log.Println(err)
}
```
## Contributing
Contributions are welcome. Please, see the
[CONTRIBUTING](https://github.com/GoogleCloudPlatform/gcloud-golang/blob/master/CONTRIBUTING.md)
document for details. We're using Gerrit for our code reviews. Please don't open pull
requests against this repo, new pull requests will be automatically closed.
[cloud-datastore]: https://cloud.google.com/datastore/
[cloud-datastore-docs]: https://cloud.google.com/datastore/docs
[cloud-datastore-activation]: https://cloud.google.com/datastore/docs/activate
[cloud-pubsub]: https://cloud.google.com/pubsub/
[cloud-pubsub-docs]: https://cloud.google.com/pubsub/docs
[cloud-storage]: https://cloud.google.com/storage/
[cloud-storage-docs]: https://cloud.google.com/storage/docs/overview
[cloud-storage-create-bucket]: https://cloud.google.com/storage/docs/cloud-console#_creatingbuckets
================================================
FILE: vendor/google.golang.org/cloud/bigquery/bigquery.go
================================================
// Copyright 2015 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package bigquery
// TODO(mcgreevy): support dry-run mode when creating jobs.
import (
"fmt"
"net/http"
"golang.org/x/net/context"
bq "google.golang.org/api/bigquery/v2"
)
// A Source is a source of data for the Copy function.
type Source interface {
implementsSource()
}
// A Destination is a destination of data for the Copy function.
type Destination interface {
implementsDestination()
}
// An Option is an optional argument to Copy.
type Option interface {
implementsOption()
}
// A ReadSource is a source of data for the Read function.
type ReadSource interface {
implementsReadSource()
}
// A ReadOption is an optional argument to Read.
type ReadOption interface {
customizeRead(conf *pagingConf)
}
const Scope = "https://www.googleapis.com/auth/bigquery"
// Client may be used to perform BigQuery operations.
type Client struct {
service service
projectID string
}
// Note: many of the methods on *Client appear in the various *_op.go source files.
// NewClient constructs a new Client which can perform BigQuery operations.
// Operations performed via the client are billed to the specified GCP project.
// The supplied http.Client is used for making requests to the BigQuery server and must be capable of
// authenticating requests with Scope.
func NewClient(client *http.Client, projectID string) (*Client, error) {
bqService, err := newBigqueryService(client)
if err != nil {
return nil, fmt.Errorf("constructing bigquery client: %v", err)
}
c := &Client{
service: bqService,
projectID: projectID,
}
return c, nil
}
// initJobProto creates and returns a bigquery Job proto.
// The proto is customized using any jobOptions in options.
// The list of Options is returned with the jobOptions removed.
func initJobProto(projectID string, options []Option) (*bq.Job, []Option) {
job := &bq.Job{}
var other []Option
for _, opt := range options {
if o, ok := opt.(jobOption); ok {
o.customizeJob(job, projectID)
} else {
other = append(other, opt)
}
}
return job, other
}
// Copy starts a BigQuery operation to copy data from a Source to a Destination.
func (c *Client) Copy(ctx context.Context, dst Destination, src Source, options ...Option) (*Job, error) {
switch dst := dst.(type) {
case *Table:
switch src := src.(type) {
case *GCSReference:
return c.load(ctx, dst, src, options)
case *Table:
return c.cp(ctx, dst, Tables{src}, options)
case Tables:
return c.cp(ctx, dst, src, options)
case *Query:
return c.query(ctx, dst, src, options)
}
case *GCSReference:
if src, ok := src.(*Table); ok {
return c.extract(ctx, dst, src, options)
}
}
return nil, fmt.Errorf("no Copy operation matches dst/src pair: dst: %T ; src: %T", dst, src)
}
// Read fetches data from a Source and returns the data via an Iterator.
func (c *Client) Read(ctx context.Context, src ReadSource, options ...ReadOption) (*Iterator, error) {
// TODO(mcgreevy): support Query as a ReadSource.
// TODO(mcgreevy): use ctx.
switch src := src.(type) {
case *Table:
return c.readTable(src, options)
}
return nil, fmt.Errorf("src (%T) does not support the Read operation", src)
}
================================================
FILE: vendor/google.golang.org/cloud/bigquery/copy_op.go
================================================
// Copyright 2015 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package bigquery
import (
"fmt"
"golang.org/x/net/context"
bq "google.golang.org/api/bigquery/v2"
)
type copyOption interface {
customizeCopy(conf *bq.JobConfigurationTableCopy, projectID string)
}
func (c *Client) cp(ctx context.Context, dst *Table, src Tables, options []Option) (*Job, error) {
job, options := initJobProto(c.projectID, options)
payload := &bq.JobConfigurationTableCopy{}
dst.customizeCopyDst(payload, c.projectID)
src.customizeCopySrc(payload, c.projectID)
for _, opt := range options {
o, ok := opt.(copyOption)
if !ok {
return nil, fmt.Errorf("option (%#v) not applicable to dst/src pair: dst: %T ; src: %T", opt, dst, src)
}
o.customizeCopy(payload, c.projectID)
}
job.Configuration = &bq.JobConfiguration{
Copy: payload,
}
return c.service.insertJob(ctx, job, c.projectID)
}
================================================
FILE: vendor/google.golang.org/cloud/bigquery/doc.go
================================================
// Copyright 2015 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Package bigquery provides a client for the BigQuery service.
//
// Note: This package is a work-in-progress. Backwards-incompatible changes should be expected.
package bigquery
================================================
FILE: vendor/google.golang.org/cloud/bigquery/error.go
================================================
// Copyright 2015 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package bigquery
import (
"fmt"
bq "google.golang.org/api/bigquery/v2"
)
// An Error contains detailed information about an error encountered while processing a job.
type Error struct {
// Mirrors bq.ErrorProto, but drops DebugInfo
Location, Message, Reason string
}
func (e Error) Error() string {
return fmt.Sprintf("{Location: %q; Message: %q; Reason: %q}", e.Location, e.Message, e.Reason)
}
func errorFromErrorProto(ep *bq.ErrorProto) *Error {
if ep == nil {
return nil
}
return &Error{
Location: ep.Location,
Message: ep.Message,
Reason: ep.Reason,
}
}
================================================
FILE: vendor/google.golang.org/cloud/bigquery/extract_op.go
================================================
// Copyright 2015 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package bigquery
import (
"fmt"
"golang.org/x/net/context"
bq "google.golang.org/api/bigquery/v2"
)
type extractOption interface {
customizeExtract(conf *bq.JobConfigurationExtract, projectID string)
}
// DisableHeader returns an Option that disables the printing of a header row in exported data.
func DisableHeader() Option { return disableHeader{} }
type disableHeader struct{}
func (opt disableHeader) implementsOption() {}
func (opt disableHeader) customizeExtract(conf *bq.JobConfigurationExtract, projectID string) {
conf.PrintHeader = false
}
func (c *Client) extract(ctx context.Context, dst *GCSReference, src *Table, options []Option) (*Job, error) {
job, options := initJobProto(c.projectID, options)
payload := &bq.JobConfigurationExtract{}
dst.customizeExtractDst(payload, c.projectID)
src.customizeExtractSrc(payload, c.projectID)
for _, opt := range options {
o, ok := opt.(extractOption)
if !ok {
return nil, fmt.Errorf("option (%#v) not applicable to dst/src pair: dst: %T ; src: %T", opt, dst, src)
}
o.customizeExtract(payload, c.projectID)
}
job.Configuration = &bq.JobConfiguration{
Extract: payload,
}
return c.service.insertJob(ctx, job, c.projectID)
}
================================================
FILE: vendor/google.golang.org/cloud/bigquery/gcs.go
================================================
// Copyright 2015 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package bigquery
import bq "google.golang.org/api/bigquery/v2"
// GCSReference is a reference to one or more Google Cloud Storage objects, which together constitute
// an input or output to a BigQuery operation.
type GCSReference struct {
uris []string
// FieldDelimiter is the separator for fields in a CSV file, used when loading or exporting data.
// The default is ",".
FieldDelimiter string
// The number of rows at the top of a CSV file that BigQuery will skip when loading the data.
SkipLeadingRows int64
// SourceFormat is the format of the GCS data to be loaded into BigQuery.
// Allowed values are: CSV, JSON, DatastoreBackup. The default is CSV.
SourceFormat DataFormat
// Only used when loading data.
Encoding Encoding
// Quote is the value used to quote data sections in a CSV file.
// The default quotation character is the double quote ("), which is used if both Quote and ForceZeroQuote are unset.
// To specify that no character should be interpreted as a quotation character, set ForceZeroQuote to true.
// Only used when loading data.
Quote string
ForceZeroQuote bool
// DestinationFormat is the format to use when writing exported files.
// Allowed values are: CSV, Avro, JSON. The default is CSV.
// CSV is not supported for tables with nested or repeated fields.
DestinationFormat DataFormat
// Only used when writing data. Default is None.
Compression Compression
}
func (gcs *GCSReference) implementsSource() {}
func (gcs *GCSReference) implementsDestination() {}
// NewGCSReference constructs a reference to one or more Google Cloud Storage objects, which together constitute a data source or destination.
// In the simple case, a single URI in the form gs://bucket/object may refer to a single GCS object.
// Data may also be split into mutiple files, if multiple URIs or URIs containing wildcards are provided.
// Each URI may contain one '*' wildcard character, which (if present) must come after the bucket name.
// For more information about the treatment of wildcards and multiple URIs,
// see https://cloud.google.com/bigquery/exporting-data-from-bigquery#exportingmultiple
func (c *Client) NewGCSReference(uri ...string) *GCSReference {
return &GCSReference{uris: uri}
}
type DataFormat string
const (
CSV DataFormat = "CSV"
Avro DataFormat = "AVRO"
JSON DataFormat = "NEWLINE_DELIMITED_JSON"
DatastoreBackup DataFormat = "DATASTORE_BACKUP"
)
// Encoding specifies the character encoding of data to be loaded into BigQuery.
// See https://cloud.google.com/bigquery/docs/reference/v2/jobs#configuration.load.encoding
// for more details about how this is used.
type Encoding string
const (
UTF_8 Encoding = "UTF-8"
ISO_8859_1 Encoding = "ISO-8859-1"
)
// Compression is the type of compression to apply when writing data to Google Cloud Storage.
type Compression string
const (
None Compression = "NONE"
Gzip Compression = "GZIP"
)
func (gcs *GCSReference) customizeLoadSrc(conf *bq.JobConfigurationLoad, projectID string) {
conf.SourceUris = gcs.uris
conf.SkipLeadingRows = gcs.SkipLeadingRows
conf.SourceFormat = string(gcs.SourceFormat)
conf.Encoding = string(gcs.Encoding)
conf.FieldDelimiter = gcs.FieldDelimiter
// TODO(mcgreevy): take into account gcs.ForceZeroQuote once the underlying library supports it.
conf.Quote = gcs.Quote
}
func (gcs *GCSReference) customizeExtractDst(conf *bq.JobConfigurationExtract, projectID string) {
conf.DestinationUris = gcs.uris
conf.Compression = string(gcs.Compression)
conf.DestinationFormat = string(gcs.DestinationFormat)
conf.FieldDelimiter = gcs.FieldDelimiter
}
================================================
FILE: vendor/google.golang.org/cloud/bigquery/iterator.go
================================================
// Copyright 2015 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package bigquery
import (
"fmt"
"golang.org/x/net/context"
)
// Iterator provides access to the result of a BigQuery lookup.
// Next must be called before the first call to Get.
type Iterator struct {
s service
// conf contains the information necessary to make the next readTabledata call.
// conf is set to nil when there is no more data to be fetched from the server.
conf *readTabledataConf
rs [][]Value // contains prefetched rows. The first element is returned by Get.
err error // contains any error encountered during calls to Next.
}
// Next advances the Iterator to the next row, making that row available
// via the Get method.
// Next must be called before the first call to Get.
// Next returns false when there are no more rows available, either because
// the end of the output was reached, or because there was an error (consult
// the Err method to determine which).
func (it *Iterator) Next(ctx context.Context) bool {
if it.err != nil {
return false
}
if len(it.rs) > 0 {
it.rs = it.rs[1:]
}
if len(it.rs) == 0 {
it.fetchRows(ctx)
}
return it.hasCurrentRow()
}
func (it *Iterator) hasCurrentRow() bool {
return it.err == nil && len(it.rs) != 0
}
// fetchRows fetches a series of rows from the BigQuery service.
// The fetched rows will be returned via subsequent calls to Get.
func (it *Iterator) fetchRows(ctx context.Context) {
if it.conf == nil {
return
}
// TODO(mcgreevy): refactor to support reads of query results.
res, err := it.s.readTabledata(ctx, it.conf)
if err != nil {
it.err = err
return
}
if res.pageToken == "" {
// No more data.
it.conf = nil
} else {
it.conf.paging.pageToken = res.pageToken
}
it.rs = res.rows
}
// Err returns the last error encountered by Next, or nil for no error.
func (it *Iterator) Err() error {
return it.err
}
// Get loads the current row into dst, which must implement ValueLoader.
func (it *Iterator) Get(dst interface{}) error {
if !it.hasCurrentRow() {
return fmt.Errorf("Get called on iterator with no remaining values")
}
if dst, ok := dst.(ValueLoader); ok {
return dst.Load(it.rs[0])
}
return fmt.Errorf("Get called with unsupported argument type")
}
================================================
FILE: vendor/google.golang.org/cloud/bigquery/job.go
================================================
// Copyright 2015 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package bigquery
import (
"golang.org/x/net/context"
bq "google.golang.org/api/bigquery/v2"
)
// A Job represents an operation which has been submitted to BigQuery for processing.
type Job struct {
service service
projectID string
jobID string
}
// State is one of a sequence of states that a Job progresses through as it is processed.
type State int
const (
Pending State = iota
Running
Done
)
// JobStatus contains the current State of a job, and errors encountered while processing that job.
type JobStatus struct {
State State
err error
// All errors encountered during the running of the job.
// Not all Errors are fatal, so errors here do not necessarily mean that the job has completed or was unsuccessful.
Errors []*Error
}
// jobOption is an Option which modifies a bq.Job proto.
// This is used for configuring values that apply to all operations, such as setting a jobReference.
type jobOption interface {
customizeJob(job *bq.Job, projectID string)
}
type jobID string
// JobID returns an Option that sets the job ID of a BigQuery job.
// If this Option is not used, a job ID is generated automatically.
func JobID(ID string) Option {
return jobID(ID)
}
func (opt jobID) implementsOption() {}
func (opt jobID) customizeJob(job *bq.Job, projectID string) {
job.JobReference = &bq.JobReference{
JobId: string(opt),
ProjectId: projectID,
}
}
// Done reports whether the job has completed.
// After Done returns true, the Err method will return an error if the job completed unsuccesfully.
func (s *JobStatus) Done() bool {
return s.State == Done
}
// Err returns the error that caused the job to complete unsuccesfully (if any).
func (s *JobStatus) Err() error {
return s.err
}
// Status returns the current status of the job. It fails if the Status could not be determined.
func (j *Job) Status(ctx context.Context) (*JobStatus, error) {
return j.service.jobStatus(ctx, j.projectID, j.jobID)
}
================================================
FILE: vendor/google.golang.org/cloud/bigquery/load_op.go
================================================
// Copyright 2015 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package bigquery
import (
"fmt"
"golang.org/x/net/context"
bq "google.golang.org/api/bigquery/v2"
)
type loadOption interface {
customizeLoad(conf *bq.JobConfigurationLoad, projectID string)
}
// A DestinationSchema must be supplied when loading data from Google Cloud Storage into a non-existent table.
// Caveat: DestinationSchema is not required if the data being loaded is a datastore backup.
func DestinationSchema(schema Schema) Option { return destSchema(schema) }
type destSchema Schema
func (opt destSchema) implementsOption() {}
func (opt destSchema) customizeLoad(conf *bq.JobConfigurationLoad, projectID string) {
var fields []*bq.TableFieldSchema
for _, f := range opt {
fields = append(fields, f.proto())
}
if len(fields) > 0 {
conf.Schema = &bq.TableSchema{Fields: fields}
}
}
// MaxBadRecords returns an Option that sets the maximum number of bad records that will be ignored.
// If this maximum is exceeded, the operation will be unsuccessful.
func MaxBadRecords(n int64) Option { return maxBadRecords(n) }
type maxBadRecords int64
func (opt maxBadRecords) implementsOption() {}
func (opt maxBadRecords) customizeLoad(conf *bq.JobConfigurationLoad, projectID string) {
conf.MaxBadRecords = int64(opt)
}
// AllowJaggedRows returns an Option that causes missing trailing optional columns to be tolerated in CSV data. Missing values are treated as nulls.
func AllowJaggedRows() Option { return allowJaggedRows{} }
type allowJaggedRows struct{}
func (opt allowJaggedRows) implementsOption() {}
func (opt allowJaggedRows) customizeLoad(conf *bq.JobConfigurationLoad, projectID string) {
conf.AllowJaggedRows = true
}
// AllowQuotedNewlines returns an Option that allows quoted data sections containing newlines in CSV data.
func AllowQuotedNewlines() Option { return allowQuotedNewlines{} }
type allowQuotedNewlines struct{}
func (opt allowQuotedNewlines) implementsOption() {}
func (opt allowQuotedNewlines) customizeLoad(conf *bq.JobConfigurationLoad, projectID string) {
conf.AllowQuotedNewlines = true
}
// IgnoreUnknownValues returns an Option that causes values not matching the schema to be tolerated.
// Unknown values are ignored. For CSV this ignores extra values at the end of a line.
// For JSON this ignores named values that do not match any column name.
// If this Option is not used, records containing unknown values are treated as bad records.
// The MaxBadRecords Option can be used to customize how bad records are handled.
func IgnoreUnknownValues() Option { return ignoreUnknownValues{} }
type ignoreUnknownValues struct{}
func (opt ignoreUnknownValues) implementsOption() {}
func (opt ignoreUnknownValues) customizeLoad(conf *bq.JobConfigurationLoad, projectID string) {
conf.IgnoreUnknownValues = true
}
func (c *Client) load(ctx context.Context, dst *Table, src *GCSReference, options []Option) (*Job, error) {
job, options := initJobProto(c.projectID, options)
payload := &bq.JobConfigurationLoad{}
dst.customizeLoadDst(payload, c.projectID)
src.customizeLoadSrc(payload, c.projectID)
for _, opt := range options {
o, ok := opt.(loadOption)
if !ok {
return nil, fmt.Errorf("option (%#v) not applicable to dst/src pair: dst: %T ; src: %T", opt, dst, src)
}
o.customizeLoad(payload, c.projectID)
}
job.Configuration = &bq.JobConfiguration{
Load: payload,
}
return c.service.insertJob(ctx, job, c.projectID)
}
================================================
FILE: vendor/google.golang.org/cloud/bigquery/query.go
================================================
// Copyright 2015 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package bigquery
import bq "google.golang.org/api/bigquery/v2"
// Query represents a query to be executed.
type Query struct {
// The query to execute. See https://cloud.google.com/bigquery/query-reference for details.
Q string
// DefaultProjectID and DefaultDatasetID specify the dataset to use for unqualified table names in the query.
// If DefaultProjectID is set, DefaultDatasetID must also be set.
DefaultProjectID string
DefaultDatasetID string
}
func (q *Query) implementsSource() {}
func (q *Query) customizeQuerySrc(conf *bq.JobConfigurationQuery, projectID string) {
conf.Query = q.Q
if q.DefaultProjectID != "" || q.DefaultDatasetID != "" {
conf.DefaultDataset = &bq.DatasetReference{
DatasetId: q.DefaultDatasetID,
ProjectId: q.DefaultProjectID,
}
}
}
================================================
FILE: vendor/google.golang.org/cloud/bigquery/query_op.go
================================================
// Copyright 2015 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package bigquery
import (
"fmt"
"golang.org/x/net/context"
bq "google.golang.org/api/bigquery/v2"
)
type queryOption interface {
customizeQuery(conf *bq.JobConfigurationQuery, projectID string)
}
// UseQueryCache returns an Option that causes results to be fetched from the query cache if they are available.
// The query cache is a best-effort cache that is flushed whenever tables in the query are modified.
// Cached results are only available when TableID is unspecified in the query's destination Table.
// For more information, see https://cloud.google.com/bigquery/querying-data#querycaching
func UseQueryCache() Option { return useQueryCache{} }
type useQueryCache struct{}
func (opt useQueryCache) implementsOption() {}
func (opt useQueryCache) customizeQuery(conf *bq.JobConfigurationQuery, projectID string) {
conf.UseQueryCache = true
}
// JobPriority returns an Option that causes a query to be scheduled with the specified priority.
// The default priority is InteractivePriority.
// For more information, see https://cloud.google.com/bigquery/querying-data#batchqueries
func JobPriority(priority string) Option { return jobPriority(priority) }
type jobPriority string
func (opt jobPriority) implementsOption() {}
func (opt jobPriority) customizeQuery(conf *bq.JobConfigurationQuery, projectID string) {
conf.Priority = string(opt)
}
const (
BatchPriority = "BATCH"
InteractivePriority = "INTERACTIVE"
)
// TODO(mcgreevy): support large results.
// TODO(mcgreevy): support non-flattened results.
func (c *Client) query(ctx context.Context, dst *Table, src *Query, options []Option) (*Job, error) {
job, options := initJobProto(c.projectID, options)
payload := &bq.JobConfigurationQuery{}
dst.customizeQueryDst(payload, c.projectID)
src.customizeQuerySrc(payload, c.projectID)
for _, opt := range options {
o, ok := opt.(queryOption)
if !ok {
return nil, fmt.Errorf("option (%#v) not applicable to dst/src pair: dst: %T ; src: %T", opt, dst, src)
}
o.customizeQuery(payload, c.projectID)
}
job.Configuration = &bq.JobConfiguration{
Query: payload,
}
return c.service.insertJob(ctx, job, c.projectID)
}
================================================
FILE: vendor/google.golang.org/cloud/bigquery/read_op.go
================================================
// Copyright 2015 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package bigquery
// RecordsPerRequest returns a ReadOption that sets the number of records to fetch per request when streaming data from BigQuery.
func RecordsPerRequest(n int64) ReadOption { return recordsPerRequest(n) }
type recordsPerRequest int64
func (opt recordsPerRequest) customizeRead(conf *pagingConf) {
conf.recordsPerRequest = int64(opt)
conf.setRecordsPerRequest = true
}
// TODO(mcgreevy): support configurable startIndex and pageToken.
func (c *Client) readTable(src *Table, options []ReadOption) (*Iterator, error) {
conf := &readTabledataConf{}
src.customizeReadSrc(conf)
for _, o := range options {
o.customizeRead(&conf.paging)
}
// The iterator takes care of actually fetching the data.
it := &Iterator{
conf: conf,
s: c.service,
}
return it, nil
}
================================================
FILE: vendor/google.golang.org/cloud/bigquery/schema.go
================================================
// Copyright 2015 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package bigquery
import bq "google.golang.org/api/bigquery/v2"
// Schema describes the fields in a table or query result.
type Schema []*FieldSchema
// TODO(mcgreevy): add a function to generate a schema from a struct.
type FieldSchema struct {
// The field name.
// Must contain only letters (a-z, A-Z), numbers (0-9), or underscores (_),
// and must start with a letter or underscore.
// The maximum length is 128 characters.
Name string
// A description of the field. The maximum length is 16,384 characters.
Description string
// Whether the field may contain multiple values.
Repeated bool
// Whether the field is required. Ignored if Repeated is true.
Required bool
// The field data type. If Type is Record, then this field contains a nested schema,
// which is described by Schema.
Type FieldType
// Describes the nested schema if Type is set to Record.
Schema Schema
}
func (fs *FieldSchema) proto() *bq.TableFieldSchema {
tfs := &bq.TableFieldSchema{
Description: fs.Description,
Name: fs.Name,
Type: string(fs.Type),
}
if fs.Repeated {
tfs.Mode = "REPEATED"
} else if fs.Required {
tfs.Mode = "REQUIRED"
} // else leave as default, which is interpreted as NULLABLE.
for _, f := range fs.Schema {
tfs.Fields = append(tfs.Fields, f.proto())
}
return tfs
}
type FieldType string
const (
StringFieldType FieldType = "STRING"
IntegerFieldType FieldType = "INTEGER"
FloatFieldType FieldType = "FLOAT"
BooleanFieldType FieldType = "BOOLEAN"
TimestampFieldType FieldType = "TIMESTAMP"
RecordFieldType FieldType = "RECORD"
)
================================================
FILE: vendor/google.golang.org/cloud/bigquery/service.go
================================================
// Copyright 2015 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package bigquery
import (
"fmt"
"net/http"
"golang.org/x/net/context"
bq "google.golang.org/api/bigquery/v2"
)
// service provides an internal abstraction to isolate the generated
// BigQuery API; most of this package uses this interface instead.
// The single implementation, *bigqueryService, contains all the knowledge
// of the generated BigQuery API.
type service interface {
insertJob(ctx context.Context, job *bq.Job, projectId string) (*Job, error)
jobStatus(ctx context.Context, projectId, jobID string) (*JobStatus, error)
readTabledata(ctx context.Context, conf *readTabledataConf) (*readTabledataResult, error)
}
type bigqueryService struct {
s *bq.Service
}
func newBigqueryService(client *http.Client) (*bigqueryService, error) {
s, err := bq.New(client)
if err != nil {
return nil, fmt.Errorf("constructing bigquery client: %v", err)
}
return &bigqueryService{s: s}, nil
}
func (s *bigqueryService) insertJob(ctx context.Context, job *bq.Job, projectID string) (*Job, error) {
// TODO(mcgreevy): use ctx
res, err := s.s.Jobs.Insert(projectID, job).Do()
if err != nil {
return nil, err
}
return &Job{service: s, projectID: projectID, jobID: res.JobReference.JobId}, nil
}
type pagingConf struct {
pageToken string
recordsPerRequest int64
setRecordsPerRequest bool
}
type readTabledataConf struct {
projectID, datasetID, tableID string
paging pagingConf
}
type readTabledataResult struct {
pageToken string
rows [][]Value
totalRows int64
}
func (s *bigqueryService) readTabledata(ctx context.Context, conf *readTabledataConf) (*readTabledataResult, error) {
list := s.s.Tabledata.List(conf.projectID, conf.datasetID, conf.tableID).
PageToken(conf.paging.pageToken)
if conf.paging.setRecordsPerRequest {
list = list.MaxResults(conf.paging.recordsPerRequest)
}
res, err := list.Do()
if err != nil {
return nil, err
}
var rs [][]Value
for _, r := range res.Rows {
rs = append(rs, convertRow(r))
}
result := &readTabledataResult{
pageToken: res.PageToken,
rows: rs,
totalRows: res.TotalRows,
}
return result, nil
}
func convertRow(r *bq.TableRow) []Value {
var values []Value
for _, cell := range r.F {
values = append(values, cell.V)
}
return values
}
func (s *bigqueryService) jobStatus(ctx context.Context, projectID, jobID string) (*JobStatus, error) {
// TODO(mcgreevy): use ctx
res, err := s.s.Jobs.Get(projectID, jobID).Do()
if err != nil {
return nil, err
}
return jobStatusFromProto(res.Status)
}
var stateMap = map[string]State{"PENDING": Pending, "RUNNING": Running, "DONE": Done}
func jobStatusFromProto(status *bq.JobStatus) (*JobStatus, error) {
state, ok := stateMap[status.State]
if !ok {
return nil, fmt.Errorf("unexpected job state: %v", status.State)
}
newStatus := &JobStatus{
State: state,
err: nil,
}
if err := errorFromErrorProto(status.ErrorResult); state == Done && err != nil {
newStatus.err = err
}
for _, ep := range status.Errors {
newStatus.Errors = append(newStatus.Errors, errorFromErrorProto(ep))
}
return newStatus, nil
}
================================================
FILE: vendor/google.golang.org/cloud/bigquery/table.go
================================================
// Copyright 2015 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package bigquery
import bq "google.golang.org/api/bigquery/v2"
// A Table is a reference to a BigQuery table.
type Table struct {
// ProjectID, DatasetID and TableID may be omitted if the Table is the destination for a query.
// In this case the result will be stored in an ephemeral table.
ProjectID string
DatasetID string
// TableID must contain only letters (a-z, A-Z), numbers (0-9), or underscores (_).
// The maximum length is 1,024 characters.
TableID string
// All following fields are optional.
CreateDisposition CreateDisposition // default is CreateIfNeeded.
WriteDisposition WriteDisposition // default is WriteAppend.
}
// Tables is a group of tables. The tables may belong to differing projects or datasets.
type Tables []*Table
// CreateDisposition specifies the circumstances under which destination table will be created.
type CreateDisposition string
const (
// The table will be created if it does not already exist. Tables are created atomically on successful completion of a job.
CreateIfNeeded CreateDisposition = "CREATE_IF_NEEDED"
// The table must already exist and will not be automatically created.
CreateNever CreateDisposition = "CREATE_NEVER"
)
// WriteDisposition specifies how existing data in a destination table is treated.
type WriteDisposition string
const (
// Data will be appended to any existing data in the destination table.
// Data is appended atomically on successful completion of a job.
WriteAppend WriteDisposition = "WRITE_APPEND"
// Existing data in the destination table will be overwritten.
// Data is overwritten atomically on successful completion of a job.
WriteTruncate WriteDisposition = "WRITE_TRUNCATE"
// Writes will fail if the destination table already contains data.
WriteEmpty WriteDisposition = "WRITE_EMPTY"
)
func (t *Table) implementsSource() {}
func (t *Table) implementsReadSource() {}
func (t *Table) implementsDestination() {}
func (ts Tables) implementsSource() {}
func (t *Table) tableRefProto() *bq.TableReference {
return &bq.TableReference{
ProjectId: t.ProjectID,
DatasetId: t.DatasetID,
TableId: t.TableID,
}
}
// implicitTable reports whether Table is an empty placeholder, which signifies that a new table should be created with an auto-generated Table ID.
func (t *Table) implicitTable() bool {
return t.ProjectID == "" && t.DatasetID == "" && t.TableID == ""
}
func (t *Table) customizeLoadDst(conf *bq.JobConfigurationLoad, projectID string) {
conf.DestinationTable = t.tableRefProto()
conf.CreateDisposition = string(t.CreateDisposition)
conf.WriteDisposition = string(t.WriteDisposition)
}
func (t *Table) customizeExtractSrc(conf *bq.JobConfigurationExtract, projectID string) {
conf.SourceTable = t.tableRefProto()
}
func (t *Table) customizeCopyDst(conf *bq.JobConfigurationTableCopy, projectID string) {
conf.DestinationTable = t.tableRefProto()
conf.CreateDisposition = string(t.CreateDisposition)
conf.WriteDisposition = string(t.WriteDisposition)
}
func (ts Tables) customizeCopySrc(conf *bq.JobConfigurationTableCopy, projectID string) {
for _, t := range ts {
conf.SourceTables = append(conf.SourceTables, t.tableRefProto())
}
}
func (t *Table) customizeQueryDst(conf *bq.JobConfigurationQuery, projectID string) {
if !t.implicitTable() {
conf.DestinationTable = t.tableRefProto()
}
conf.CreateDisposition = string(t.CreateDisposition)
conf.WriteDisposition = string(t.WriteDisposition)
}
func (t *Table) customizeReadSrc(conf *readTabledataConf) {
conf.projectID = t.ProjectID
conf.datasetID = t.DatasetID
conf.tableID = t.TableID
}
================================================
FILE: vendor/google.golang.org/cloud/bigquery/value.go
================================================
// Copyright 2015 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package bigquery
// Value stores the contents of a single cell from a BigQuery result.
type Value interface{}
// ValueLoader stores a slice of Values representing a result row from a Read operation.
// See Iterator.Get for more information.
type ValueLoader interface {
Load(v []Value) error
}
// ValueList converts a []Value to implement ValueLoader.
type ValueList []Value
// Load stores a sequence of values in a ValueList.
func (vs *ValueList) Load(v []Value) error {
*vs = append(*vs, v...)
return nil
}
================================================
FILE: vendor/google.golang.org/cloud/bigtable/admin.go
================================================
/*
Copyright 2015 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package bigtable
import (
"fmt"
"strings"
"golang.org/x/net/context"
"google.golang.org/cloud"
btcspb "google.golang.org/cloud/bigtable/internal/cluster_service_proto"
bttspb "google.golang.org/cloud/bigtable/internal/table_service_proto"
"google.golang.org/grpc"
)
const adminAddr = "bigtabletableadmin.googleapis.com:443"
// AdminClient is a client type for performing admin operations on a specific cluster.
type AdminClient struct {
conn *grpc.ClientConn
tClient bttspb.BigtableTableServiceClient
cClient btcspb.BigtableClusterServiceClient
project, zone, cluster string
}
// NewAdminClient creates a new AdminClient for a given project, zone and cluster.
func NewAdminClient(ctx context.Context, project, zone, cluster string, opts ...cloud.ClientOption) (*AdminClient, error) {
o := []cloud.ClientOption{
cloud.WithEndpoint(adminAddr),
cloud.WithScopes(AdminScope),
}
o = append(o, opts...)
conn, err := cloud.DialGRPC(ctx, o...)
if err != nil {
return nil, fmt.Errorf("dialing: %v", err)
}
return &AdminClient{
conn: conn,
tClient: bttspb.NewBigtableTableServiceClient(conn),
cClient: btcspb.NewBigtableClusterServiceClient(conn),
project: project,
zone: zone,
cluster: cluster,
}, nil
}
// Close closes the AdminClient.
func (ac *AdminClient) Close() {
ac.conn.Close()
}
func (ac *AdminClient) clusterPrefix() string {
return fmt.Sprintf("projects/%s/zones/%s/clusters/%s", ac.project, ac.zone, ac.cluster)
}
// Tables returns a list of the tables in the cluster.
func (ac *AdminClient) Tables(ctx context.Context) ([]string, error) {
prefix := ac.clusterPrefix()
req := &bttspb.ListTablesRequest{
Name: prefix,
}
res, err := ac.tClient.ListTables(ctx, req)
if err != nil {
return nil, err
}
names := make([]string, 0, len(res.Tables))
for _, tbl := range res.Tables {
names = append(names, strings.TrimPrefix(tbl.Name, prefix+"/tables/"))
}
return names, nil
}
// CreateTable creates a new table in the cluster.
// This method may return before the table's creation is complete.
func (ac *AdminClient) CreateTable(ctx context.Context, table string) error {
prefix := ac.clusterPrefix()
req := &bttspb.CreateTableRequest{
Name: prefix,
TableId: table,
}
_, err := ac.tClient.CreateTable(ctx, req)
if err != nil {
return err
}
return nil
}
// CreateColumnFamily creates a new column family in a table.
func (ac *AdminClient) CreateColumnFamily(ctx context.Context, table, family string) error {
// TODO(dsymonds): Permit specifying gcexpr and any other family settings.
prefix := ac.clusterPrefix()
req := &bttspb.CreateColumnFamilyRequest{
Name: prefix + "/tables/" + table,
ColumnFamilyId: family,
}
_, err := ac.tClient.CreateColumnFamily(ctx, req)
return err
}
// DeleteTable deletes a table and all of its data.
func (ac *AdminClient) DeleteTable(ctx context.Context, table string) error {
prefix := ac.clusterPrefix()
req := &bttspb.DeleteTableRequest{
Name: prefix + "/tables/" + table,
}
_, err := ac.tClient.DeleteTable(ctx, req)
return err
}
// DeleteColumnFamily deletes a column family in a table and all of its data.
func (ac *AdminClient) DeleteColumnFamily(ctx context.Context, table, family string) error {
prefix := ac.clusterPrefix()
req := &bttspb.DeleteColumnFamilyRequest{
Name: prefix + "/tables/" + table + "/columnFamilies/" + family,
}
_, err := ac.tClient.DeleteColumnFamily(ctx, req)
return err
}
// TableInfo represents information about a table.
type TableInfo struct {
Families []string
}
// TableInfo retrieves information about a table.
func (ac *AdminClient) TableInfo(ctx context.Context, table string) (*TableInfo, error) {
prefix := ac.clusterPrefix()
req := &bttspb.GetTableRequest{
Name: prefix + "/tables/" + table,
}
res, err := ac.tClient.GetTable(ctx, req)
if err != nil {
return nil, err
}
ti := &TableInfo{}
for fam := range res.ColumnFamilies {
ti.Families = append(ti.Families, fam)
}
return ti, nil
}
// SetClusterSize sets the number of server nodes for this cluster.
func (ac *AdminClient) SetClusterSize(ctx context.Context, nodes int) error {
req := &btcspb.GetClusterRequest{
Name: ac.clusterPrefix(),
}
clu, err := ac.cClient.GetCluster(ctx, req)
if err != nil {
return err
}
clu.ServeNodes = int32(nodes)
_, err = ac.cClient.UpdateCluster(ctx, clu)
return err
}
================================================
FILE: vendor/google.golang.org/cloud/bigtable/bigtable.go
================================================
/*
Copyright 2015 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package bigtable
import (
"fmt"
"io"
"strconv"
"time"
"github.com/golang/protobuf/proto"
"golang.org/x/net/context"
"google.golang.org/cloud"
btdpb "google.golang.org/cloud/bigtable/internal/data_proto"
btspb "google.golang.org/cloud/bigtable/internal/service_proto"
"google.golang.org/grpc"
)
const prodAddr = "bigtable.googleapis.com:443"
// Client is a client for reading and writing data to tables in a cluster.
type Client struct {
conn *grpc.ClientConn
client btspb.BigtableServiceClient
project, zone, cluster string
}
// NewClient creates a new Client for a given project, zone and cluster.
func NewClient(ctx context.Context, project, zone, cluster string, opts ...cloud.ClientOption) (*Client, error) {
o := []cloud.ClientOption{
cloud.WithEndpoint(prodAddr),
cloud.WithScopes(Scope),
}
o = append(o, opts...)
conn, err := cloud.DialGRPC(ctx, o...)
if err != nil {
return nil, fmt.Errorf("dialing: %v", err)
}
return &Client{
conn: conn,
client: btspb.NewBigtableServiceClient(conn),
project: project,
zone: zone,
cluster: cluster,
}, nil
}
// Close closes the Client.
func (c *Client) Close() {
c.conn.Close()
}
func (c *Client) fullTableName(table string) string {
return fmt.Sprintf("projects/%s/zones/%s/clusters/%s/tables/%s", c.project, c.zone, c.cluster, table)
}
// A Table refers to a table.
type Table struct {
c *Client
table string
}
// Open opens a table.
func (c *Client) Open(table string) *Table {
return &Table{
c: c,
table: table,
}
}
// TODO(dsymonds): Read method that returns a sequence of ReadItems.
// ReadRows reads rows from a table. f is called for each row.
// If f returns false, the stream is shut down and ReadRows returns.
// f owns its argument, and f is called serially.
//
// By default, the yielded rows will contain all values in all cells.
// Use RowFilter to limit the cells returned.
func (t *Table) ReadRows(ctx context.Context, arg RowRange, f func(Row) bool, opts ...ReadOption) error {
req := &btspb.ReadRowsRequest{
TableName: t.c.fullTableName(t.table),
RowRange: arg.proto(),
}
for _, opt := range opts {
opt.set(req)
}
ctx, cancel := context.WithCancel(ctx) // for aborting the stream
stream, err := t.c.client.ReadRows(ctx, req)
if err != nil {
return err
}
cr := new(chunkReader)
for {
res, err := stream.Recv()
if err == io.EOF {
break
}
if err != nil {
return err
}
if row := cr.process(res); row != nil {
if !f(row) {
// Cancel and drain stream.
cancel()
for {
if _, err := stream.Recv(); err != nil {
return nil
}
}
}
}
}
return nil
}
// ReadRow is a convenience implementation of a single-row reader.
// A missing row will return a zero-length map and a nil error.
func (t *Table) ReadRow(ctx context.Context, row string, opts ...ReadOption) (Row, error) {
var r Row
err := t.ReadRows(ctx, SingleRow(row), func(rr Row) bool {
r = rr
return true
}, opts...)
return r, err
}
type chunkReader struct {
partial map[string]Row // incomplete rows
}
// process handles a single btspb.ReadRowsResponse.
// If it completes a row, that row is returned.
func (cr *chunkReader) process(rrr *btspb.ReadRowsResponse) Row {
if cr.partial == nil {
cr.partial = make(map[string]Row)
}
row := string(rrr.RowKey)
r := cr.partial[row]
if r == nil {
r = make(Row)
cr.partial[row] = r
}
for _, chunk := range rrr.Chunks {
if chunk.ResetRow {
r = make(Row)
cr.partial[row] = r
continue
}
if chunk.CommitRow {
delete(cr.partial, row)
return r // assume that this is the last chunk
}
decodeFamilyProto(r, row, chunk.RowContents)
}
return nil
}
// decodeFamilyProto adds the cell data from f to the given row.
func decodeFamilyProto(r Row, row string, f *btdpb.Family) {
fam := f.Name // does not have colon
for _, col := range f.Columns {
for _, cell := range col.Cells {
ri := ReadItem{
Row: row,
Column: fmt.Sprintf("%s:%s", fam, col.Qualifier),
Timestamp: Timestamp(cell.TimestampMicros),
Value: cell.Value,
}
r[fam] = append(r[fam], ri)
}
}
}
// A RowRange is used to describe the rows to be read.
// A RowRange is a half-open interval [Start, Limit) encompassing
// all the rows with keys at least as large as Start, and less than Limit.
// (Bigtable string comparison is the same as Go's.)
// A RowRange can be unbounded, encompassing all keys at least as large as Start.
type RowRange struct {
start string
limit string
}
// NewRange returns the new RowRange [begin, end).
func NewRange(begin, end string) RowRange {
return RowRange{
start: begin,
limit: end,
}
}
// Unbounded tests whether a RowRange is unbounded.
func (r RowRange) Unbounded() bool {
return r.limit == ""
}
// Contains says whether the RowRange contains the key.
func (r RowRange) Contains(row string) bool {
return r.start <= row && (r.limit == "" || r.limit > row)
}
// String provides a printable description of a RowRange.
func (r RowRange) String() string {
a := strconv.Quote(r.start)
if r.Unbounded() {
return fmt.Sprintf("[%s,∞)", a)
}
return fmt.Sprintf("[%s,%q)", a, r.limit)
}
func (r RowRange) proto() *btdpb.RowRange {
if r.Unbounded() {
return &btdpb.RowRange{StartKey: []byte(r.start)}
}
return &btdpb.RowRange{
StartKey: []byte(r.start),
EndKey: []byte(r.limit),
}
}
// SingleRow returns a RowRange for reading a single row.
func SingleRow(row string) RowRange {
return RowRange{
start: row,
limit: row + "\x00",
}
}
// PrefixRange returns a RowRange consisting of all keys starting with the prefix.
func PrefixRange(prefix string) RowRange {
return RowRange{
start: prefix,
limit: prefixSuccessor(prefix),
}
}
// InfiniteRange returns the RowRange consisting of all keys at least as
// large as start.
func InfiniteRange(start string) RowRange {
return RowRange{
start: start,
limit: "",
}
}
// prefixSuccessor returns the lexically smallest string greater than the
// prefix, if it exists, or "" otherwise. In either case, it is the string
// needed for the Limit of a RowRange.
func prefixSuccessor(prefix string) string {
if prefix == "" {
return "" // infinite range
}
n := len(prefix)
for n--; n >= 0 && prefix[n] == '\xff'; n-- {
}
if n == -1 {
return ""
}
ans := []byte(prefix[:n])
ans = append(ans, prefix[n]+1)
return string(ans)
}
// A ReadOption is an optional argument to ReadRows.
type ReadOption interface {
set(req *btspb.ReadRowsRequest)
}
// RowFilter returns a ReadOption that applies f to the contents of read rows.
func RowFilter(f Filter) ReadOption { return rowFilter{f} }
type rowFilter struct{ f Filter }
func (rf rowFilter) set(req *btspb.ReadRowsRequest) { req.Filter = rf.f.proto() }
// LimitRows returns a ReadOption that will limit the number of rows to be read.
func LimitRows(limit int64) ReadOption { return limitRows{limit} }
type limitRows struct{ limit int64 }
func (lr limitRows) set(req *btspb.ReadRowsRequest) { req.NumRowsLimit = lr.limit }
// A Row is returned by ReadRow. The map is keyed by column family (the prefix
// of the column name before the colon). The values are the returned ReadItems
// for that column family in the order returned by Read.
type Row map[string][]ReadItem
// Key returns the row's key, or "" if the row is empty.
func (r Row) Key() string {
for _, items := range r {
if len(items) > 0 {
return items[0].Row
}
}
return ""
}
// A ReadItem is returned by Read. A ReadItem contains data from a specific row and column.
type ReadItem struct {
Row, Column string
Timestamp Timestamp
Value []byte
}
// Apply applies a Mutation to a specific row.
func (t *Table) Apply(ctx context.Context, row string, m *Mutation, opts ...ApplyOption) error {
after := func(res proto.Message) {
for _, o := range opts {
o.after(res)
}
}
if m.cond == nil {
req := &btspb.MutateRowRequest{
TableName: t.c.fullTableName(t.table),
RowKey: []byte(row),
Mutations: m.ops,
}
res, err := t.c.client.MutateRow(ctx, req)
if err == nil {
after(res)
}
return err
}
req := &btspb.CheckAndMutateRowRequest{
TableName: t.c.fullTableName(t.table),
RowKey: []byte(row),
PredicateFilter: m.cond.proto(),
}
if m.mtrue != nil {
req.TrueMutations = m.mtrue.ops
}
if m.mfalse != nil {
req.FalseMutations = m.mfalse.ops
}
res, err := t.c.client.CheckAndMutateRow(ctx, req)
if err == nil {
after(res)
}
return err
}
// An ApplyOption is an optional argument to Apply.
type ApplyOption interface {
after(res proto.Message)
}
type applyAfterFunc func(res proto.Message)
func (a applyAfterFunc) after(res proto.Message) { a(res) }
// GetCondMutationResult returns an ApplyOption that reports whether the conditional
// mutation's condition matched.
func GetCondMutationResult(matched *bool) ApplyOption {
return applyAfterFunc(func(res proto.Message) {
if res, ok := res.(*btspb.CheckAndMutateRowResponse); ok {
*matched = res.PredicateMatched
}
})
}
// Mutation represents a set of changes for a single row of a table.
type Mutation struct {
ops []*btdpb.Mutation
// for conditional mutations
cond Filter
mtrue, mfalse *Mutation
}
// NewMutation returns a new mutation.
func NewMutation() *Mutation {
return new(Mutation)
}
// NewCondMutation returns a conditional mutation.
// The given row filter determines which mutation is applied:
// If the filter matches any cell in the row, mtrue is applied;
// otherwise, mfalse is applied.
// Either given mutation may be nil.
func NewCondMutation(cond Filter, mtrue, mfalse *Mutation) *Mutation {
return &Mutation{cond: cond, mtrue: mtrue, mfalse: mfalse}
}
// Set sets a value in a specified column, with the given timestamp.
// The timestamp will be truncated to millisecond resolution.
// A timestamp of ServerTime means to use the server timestamp.
func (m *Mutation) Set(family, column string, ts Timestamp, value []byte) {
if ts != ServerTime {
// Truncate to millisecond resolution, since that's the default table config.
// TODO(dsymonds): Provide a way to override this behaviour.
ts -= ts % 1000
}
m.ops = append(m.ops, &btdpb.Mutation{SetCell: &btdpb.Mutation_SetCell{
FamilyName: family,
ColumnQualifier: []byte(column),
TimestampMicros: int64(ts),
Value: value,
}})
}
// DeleteCellsInColumn will delete all the cells whose columns are family:column.
func (m *Mutation) DeleteCellsInColumn(family, column string) {
m.ops = append(m.ops, &btdpb.Mutation{DeleteFromColumn: &btdpb.Mutation_DeleteFromColumn{
FamilyName: family,
ColumnQualifier: []byte(column),
}})
}
// DeleteTimestampRange deletes all cells whose columns are family:column
// and whose timestamps are in the half-open interval [start, end).
// If end is zero, it will be interpreted as infinity.
func (m *Mutation) DeleteTimestampRange(family, column string, start, end Timestamp) {
m.ops = append(m.ops, &btdpb.Mutation{DeleteFromColumn: &btdpb.Mutation_DeleteFromColumn{
FamilyName: family,
ColumnQualifier: []byte(column),
TimeRange: &btdpb.TimestampRange{
StartTimestampMicros: int64(start),
EndTimestampMicros: int64(end),
},
}})
}
// DeleteCellsInFamily will delete all the cells whose columns are family:*.
func (m *Mutation) DeleteCellsInFamily(family string) {
m.ops = append(m.ops, &btdpb.Mutation{DeleteFromFamily: &btdpb.Mutation_DeleteFromFamily{
FamilyName: family,
}})
}
// DeleteRow deletes the entire row.
func (m *Mutation) DeleteRow() {
m.ops = append(m.ops, &btdpb.Mutation{DeleteFromRow: &btdpb.Mutation_DeleteFromRow{}})
}
// Timestamp is in units of microseconds since 1 January 1970.
type Timestamp int64
// ServerTime is a specific Timestamp that may be passed to (*Mutation).Set.
// It indicates that the server's timestamp should be used.
const ServerTime Timestamp = -1
// Time converts a time.Time into a Timestamp.
func Time(t time.Time) Timestamp { return Timestamp(t.UnixNano() / 1e3) }
// Now returns the Timestamp representation of the current time on the client.
func Now() Timestamp { return Time(time.Now()) }
// Time converts a Timestamp into a time.Time.
func (ts Timestamp) Time() time.Time { return time.Unix(0, int64(ts)*1e3) }
// ApplyReadModifyWrite applies a ReadModifyWrite to a specific row.
// It returns the newly written cells.
func (t *Table) ApplyReadModifyWrite(ctx context.Context, row string, m *ReadModifyWrite) (Row, error) {
req := &btspb.ReadModifyWriteRowRequest{
TableName: t.c.fullTableName(t.table),
RowKey: []byte(row),
Rules: m.ops,
}
res, err := t.c.client.ReadModifyWriteRow(ctx, req)
if err != nil {
return nil, err
}
r := make(Row)
for _, fam := range res.Families { // res is *btdpb.Row, fam is *btdpb.Family
decodeFamilyProto(r, row, fam)
}
return r, nil
}
// ReadModifyWrite represents a set of operations on a single row of a table.
// It is like Mutation but for non-idempotent changes.
// When applied, these operations operate on the latest values of the row's cells,
// and result in a new value being written to the relevant cell with a timestamp
// that is max(existing timestamp, current server time).
//
// The application of a ReadModifyWrite is atomic; concurrent ReadModifyWrites will
// be executed serially by the server.
type ReadModifyWrite struct {
ops []*btdpb.ReadModifyWriteRule
}
// NewReadModifyWrite returns a new ReadModifyWrite.
func NewReadModifyWrite() *ReadModifyWrite { return new(ReadModifyWrite) }
// AppendValue appends a value to a specific cell's value.
// If the cell is unset, it will be treated as an empty value.
func (m *ReadModifyWrite) AppendValue(family, column string, v []byte) {
m.ops = append(m.ops, &btdpb.ReadModifyWriteRule{
FamilyName: family,
ColumnQualifier: []byte(column),
AppendValue: v,
})
}
// Increment interprets the value in a specific cell as a 64-bit big-endian signed integer,
// and adds a value to it. If the cell is unset, it will be treated as zero.
// If the cell is set and is not an 8-byte value, the entire ApplyReadModifyWrite
// operation will fail.
func (m *ReadModifyWrite) Increment(family, column string, delta int64) {
m.ops = append(m.ops, &btdpb.ReadModifyWriteRule{
FamilyName: family,
ColumnQualifier: []byte(column),
IncrementAmount: delta,
})
}
================================================
FILE: vendor/google.golang.org/cloud/bigtable/bttest/inmem.go
================================================
/*
Copyright 2015 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
/*
Package bttest contains test helpers for working with the bigtable package.
To use a Server, create it, and then connect to it with no security:
(The project/zone/cluster values are ignored.)
srv, err := bttest.NewServer()
...
client, err := bigtable.NewClient(ctx, proj, zone, cluster,
bigtable.WithCredentials(nil), bigtable.WithInsecureAddr(srv.Addr))
...
*/
package bttest
import (
"encoding/binary"
"fmt"
"log"
"net"
"regexp"
"sort"
"strings"
"sync"
"golang.org/x/net/context"
btdpb "google.golang.org/cloud/bigtable/internal/data_proto"
emptypb "google.golang.org/cloud/bigtable/internal/empty"
btspb "google.golang.org/cloud/bigtable/internal/service_proto"
bttdpb "google.golang.org/cloud/bigtable/internal/table_data_proto"
bttspb "google.golang.org/cloud/bigtable/internal/table_service_proto"
"google.golang.org/grpc"
)
// Server is an in-memory Cloud Bigtable fake.
// It is unauthenticated, and only a rough approximation.
type Server struct {
Addr string
l net.Listener
srv *grpc.Server
s *server
}
// server is the real implementation of the fake.
// It is a separate and unexported type so the API won't be cluttered with
// methods that are only relevant to the fake's implementation.
type server struct {
mu sync.Mutex
tables map[string]*table // keyed by fully qualified name
// Any unimplemented methods will cause a panic.
bttspb.BigtableTableServiceServer
btspb.BigtableServiceServer
}
// NewServer creates a new Server. The Server will be listening for gRPC connections
// at the address named by the Addr field, without TLS.
func NewServer() (*Server, error) {
l, err := net.Listen("tcp", "127.0.0.1:0")
if err != nil {
return nil, err
}
s := &Server{
Addr: l.Addr().String(),
l: l,
srv: grpc.NewServer(),
s: &server{
tables: make(map[string]*table),
},
}
bttspb.RegisterBigtableTableServiceServer(s.srv, s.s)
btspb.RegisterBigtableServiceServer(s.srv, s.s)
go s.srv.Serve(s.l)
return s, nil
}
// Close shuts down the server.
func (s *Server) Close() {
s.srv.Stop()
s.l.Close()
}
func (s *server) CreateTable(ctx context.Context, req *bttspb.CreateTableRequest) (*bttdpb.Table, error) {
tbl := req.Name + "/tables/" + req.TableId
s.mu.Lock()
if _, ok := s.tables[tbl]; ok {
s.mu.Unlock()
return nil, fmt.Errorf("table %q already exists", tbl)
}
s.tables[tbl] = newTable()
s.mu.Unlock()
return &bttdpb.Table{Name: tbl}, nil
}
func (s *server) ListTables(ctx context.Context, req *bttspb.ListTablesRequest) (*bttspb.ListTablesResponse, error) {
res := &bttspb.ListTablesResponse{}
prefix := req.Name + "/tables/"
s.mu.Lock()
for tbl := range s.tables {
if strings.HasPrefix(tbl, prefix) {
res.Tables = append(res.Tables, &bttdpb.Table{Name: tbl})
}
}
s.mu.Unlock()
return res, nil
}
func (s *server) DeleteTable(ctx context.Context, req *bttspb.DeleteTableRequest) (*emptypb.Empty, error) {
s.mu.Lock()
defer s.mu.Unlock()
if _, ok := s.tables[req.Name]; !ok {
return nil, fmt.Errorf("no such table %q", req.Name)
}
delete(s.tables, req.Name)
return &emptypb.Empty{}, nil
}
func (s *server) CreateColumnFamily(ctx context.Context, req *bttspb.CreateColumnFamilyRequest) (*bttdpb.ColumnFamily, error) {
s.mu.Lock()
tbl, ok := s.tables[req.Name]
s.mu.Unlock()
if !ok {
return nil, fmt.Errorf("no such table %q", req.Name)
}
// Check it is unique and record it.
fam := req.ColumnFamilyId
tbl.mu.Lock()
defer tbl.mu.Unlock()
if _, ok := tbl.families[fam]; ok {
return nil, fmt.Errorf("family %q already exists", fam)
}
tbl.families[fam] = true
return &bttdpb.ColumnFamily{
Name: req.Name + "/families/" + fam,
}, nil
}
func (s *server) ReadRows(req *btspb.ReadRowsRequest, stream btspb.BigtableService_ReadRowsServer) error {
s.mu.Lock()
tbl, ok := s.tables[req.TableName]
s.mu.Unlock()
if !ok {
return fmt.Errorf("no such table %q", req.TableName)
}
var start, end string // half-open interval
if rr := req.RowRange; rr != nil {
start, end = string(rr.StartKey), string(rr.EndKey)
} else {
// A single row read is simply an edge case.
start = string(req.RowKey)
end = start + "\x00"
}
// Get rows to stream back.
tbl.mu.RLock()
si, ei := 0, len(tbl.rows) // half-open interval
if start != "" {
si = sort.Search(len(tbl.rows), func(i int) bool { return tbl.rows[i].key >= start })
}
if end != "" {
ei = sort.Search(len(tbl.rows), func(i int) bool { return tbl.rows[i].key >= end })
}
if si >= ei {
tbl.mu.RUnlock()
return nil
}
rows := make([]*row, ei-si)
copy(rows, tbl.rows[si:ei])
tbl.mu.RUnlock()
for _, r := range rows {
if err := streamRow(stream, r, req.Filter); err != nil {
return err
}
}
return nil
}
func streamRow(stream btspb.BigtableService_ReadRowsServer, r *row, f *btdpb.RowFilter) error {
r.mu.Lock()
defer r.mu.Unlock()
rrr := &btspb.ReadRowsResponse{
RowKey: []byte(r.key),
}
for col, cs := range r.cells {
i := strings.Index(col, ":") // guaranteed to exist
fam, col := col[:i], col[i+1:]
cells := filterCells(f, r, fam, col, cs)
if len(cells) == 0 {
continue
}
// TODO(dsymonds): Apply transformers.
chunk := &btspb.ReadRowsResponse_Chunk{
RowContents: &btdpb.Family{
Name: fam,
Columns: []*btdpb.Column{{
Qualifier: []byte(col),
// Cells is populated below.
}},
},
}
colm := chunk.RowContents.Columns[0]
for _, cell := range cells {
colm.Cells = append(colm.Cells, &btdpb.Cell{
TimestampMicros: cell.ts,
Value: cell.value,
})
}
rrr.Chunks = append(rrr.Chunks, chunk)
}
rrr.Chunks = append(rrr.Chunks, &btspb.ReadRowsResponse_Chunk{CommitRow: true})
return stream.Send(rrr)
}
func filterCells(f *btdpb.RowFilter, r *row, fam, col string, cs []cell) []cell {
// Special handling for cells_per_column_limit_filter.
if f != nil && f.CellsPerColumnLimitFilter > 0 {
n := int(f.CellsPerColumnLimitFilter)
if n > len(cs) {
n = len(cs)
}
return cs[:n]
}
var ret []cell
for _, cell := range cs {
if includeCell(f, r, fam, col, cell) {
ret = append(ret, cell)
}
}
return ret
}
func includeCell(f *btdpb.RowFilter, r *row, fam, col string, cell cell) bool {
if f == nil {
return true
}
// TODO(dsymonds): Implement many more filters.
switch {
default:
log.Printf("WARNING: don't know how to handle filter (ignoring it): %v", f)
return true
case f.Chain != nil:
for _, sub := range f.Chain.Filters {
if !includeCell(sub, r, fam, col, cell) {
return false
}
}
return true
case len(f.ColumnQualifierRegexFilter) > 0:
pat := string(f.ColumnQualifierRegexFilter)
rx, err := regexp.Compile(pat)
if err != nil {
log.Printf("Bad column_qualifier_regex_filter pattern %q: %v", pat, err)
return false
}
return rx.MatchString(col)
case len(f.ValueRegexFilter) > 0:
pat := string(f.ValueRegexFilter)
rx, err := regexp.Compile(pat)
if err != nil {
log.Printf("Bad value_regex_filter pattern %q: %v", pat, err)
return false
}
return rx.Match(cell.value)
}
}
func (s *server) MutateRow(ctx context.Context, req *btspb.MutateRowRequest) (*emptypb.Empty, error) {
s.mu.Lock()
tbl, ok := s.tables[req.TableName]
s.mu.Unlock()
if !ok {
return nil, fmt.Errorf("no such table %q", req.TableName)
}
r := tbl.mutableRow(string(req.RowKey))
r.mu.Lock()
defer r.mu.Unlock()
if err := applyMutations(tbl, r, req.Mutations); err != nil {
return nil, err
}
return &emptypb.Empty{}, nil
}
func (s *server) CheckAndMutateRow(ctx context.Context, req *btspb.CheckAndMutateRowRequest) (*btspb.CheckAndMutateRowResponse, error) {
s.mu.Lock()
tbl, ok := s.tables[req.TableName]
s.mu.Unlock()
if !ok {
return nil, fmt.Errorf("no such table %q", req.TableName)
}
res := &btspb.CheckAndMutateRowResponse{}
r := tbl.mutableRow(string(req.RowKey))
r.mu.Lock()
defer r.mu.Unlock()
// Figure out which mutation to apply.
whichMut := false
if req.PredicateFilter == nil {
// Use true_mutations iff row contains any cells.
whichMut = len(r.cells) > 0
} else {
// Use true_mutations iff any cells in the row match the filter.
for col, cs := range r.cells {
i := strings.Index(col, ":") // guaranteed to exist
fam, col := col[:i], col[i+1:]
for _, cell := range cs {
if includeCell(req.PredicateFilter, r, fam, col, cell) {
whichMut = true
break
}
}
if whichMut {
break
}
}
// TODO(dsymonds): Figure out if this is supposed to be set
// even when there's no predicate filter.
res.PredicateMatched = whichMut
}
muts := req.FalseMutations
if whichMut {
muts = req.TrueMutations
}
if err := applyMutations(tbl, r, muts); err != nil {
return nil, err
}
return res, nil
}
// applyMutations applies a sequence of mutations to a row.
// It assumes r.mu is locked.
func applyMutations(tbl *table, r *row, muts []*btdpb.Mutation) error {
for _, mut := range muts {
switch {
default:
return fmt.Errorf("can't handle mutation %v", mut)
case mut.SetCell != nil:
set := mut.SetCell
tbl.mu.RLock()
famOK := tbl.families[set.FamilyName]
tbl.mu.RUnlock()
if !famOK {
return fmt.Errorf("unknown family %q", set.FamilyName)
}
if !tbl.validTimestamp(set.TimestampMicros) {
return fmt.Errorf("invalid timestamp %d", set.TimestampMicros)
}
col := fmt.Sprintf("%s:%s", set.FamilyName, set.ColumnQualifier)
cs := r.cells[col]
newCell := cell{ts: set.TimestampMicros, value: set.Value}
replaced := false
for i, cell := range cs {
if cell.ts == newCell.ts {
cs[i] = newCell
replaced = true
break
}
}
if !replaced {
cs = append(cs, newCell)
}
sort.Sort(byDescTS(cs))
r.cells[col] = cs
case mut.DeleteFromColumn != nil:
del := mut.DeleteFromColumn
col := fmt.Sprintf("%s:%s", del.FamilyName, del.ColumnQualifier)
cs := r.cells[col]
if del.TimeRange != nil {
tsr := del.TimeRange
if !tbl.validTimestamp(tsr.StartTimestampMicros) {
return fmt.Errorf("invalid timestamp %d", tsr.StartTimestampMicros)
}
if !tbl.validTimestamp(tsr.EndTimestampMicros) {
return fmt.Errorf("invalid timestamp %d", tsr.EndTimestampMicros)
}
// Find half-open interval to remove.
// Cells are in descending timestamp order,
// so the predicates to sort.Search are inverted.
si, ei := 0, len(cs)
if tsr.StartTimestampMicros > 0 {
ei = sort.Search(len(cs), func(i int) bool { return cs[i].ts < tsr.StartTimestampMicros })
}
if tsr.EndTimestampMicros > 0 {
si = sort.Search(len(cs), func(i int) bool { return cs[i].ts < tsr.EndTimestampMicros })
}
if si < ei {
copy(cs[si:], cs[ei:])
cs = cs[:len(cs)-(ei-si)]
}
} else {
cs = nil
}
if len(cs) == 0 {
delete(r.cells, col)
} else {
r.cells[col] = cs
}
}
}
return nil
}
func (s *server) ReadModifyWriteRow(ctx context.Context, req *btspb.ReadModifyWriteRowRequest) (*btdpb.Row, error) {
s.mu.Lock()
tbl, ok := s.tables[req.TableName]
s.mu.Unlock()
if !ok {
return nil, fmt.Errorf("no such table %q", req.TableName)
}
updates := make(map[string]cell) // copy of updated cells; keyed by full column name
r := tbl.mutableRow(string(req.RowKey))
r.mu.Lock()
defer r.mu.Unlock()
// Assume all mutations apply to the most recent version of the cell.
// TODO(dsymonds): Verify this assumption and document it in the proto.
for _, rule := range req.Rules {
key := fmt.Sprintf("%s:%s", rule.FamilyName, rule.ColumnQualifier)
newCell := false
if len(r.cells[key]) == 0 {
r.cells[key] = []cell{{
// TODO(dsymonds): should this set a timestamp?
}}
newCell = true
}
cell := &r.cells[key][0]
if len(rule.AppendValue) > 0 {
cell.value = append(cell.value, rule.AppendValue...)
}
if rule.IncrementAmount != 0 {
var v int64
if !newCell {
if len(cell.value) != 8 {
return nil, fmt.Errorf("increment on non-64-bit value")
}
v = int64(binary.BigEndian.Uint64(cell.value))
}
v += rule.IncrementAmount
var val [8]byte
binary.BigEndian.PutUint64(val[:], uint64(v))
cell.value = val[:]
}
updates[key] = *cell
}
res := &btdpb.Row{
Key: req.RowKey,
}
for col, cell := range updates {
i := strings.Index(col, ":")
fam, qual := col[:i], col[i+1:]
var f *btdpb.Family
for _, ff := range res.Families {
if ff.Name == fam {
f = ff
break
}
}
if f == nil {
f = &btdpb.Family{Name: fam}
res.Families = append(res.Families, f)
}
f.Columns = append(f.Columns, &btdpb.Column{
Qualifier: []byte(qual),
Cells: []*btdpb.Cell{{
Value: cell.value,
}},
})
}
return res, nil
}
type table struct {
mu sync.RWMutex
families map[string]bool // keyed by plain family name
rows []*row // sorted by row key
rowIndex map[string]*row // indexed by row key
}
func newTable() *table {
return &table{
families: make(map[string]bool),
rowIndex: make(map[string]*row),
}
}
func (t *table) validTimestamp(ts int64) bool {
// Assume millisecond granularity is required.
return ts%1000 == 0
}
func (t *table) mutableRow(row string) *row {
// Try fast path first.
t.mu.RLock()
r := t.rowIndex[row]
t.mu.RUnlock()
if r != nil {
return r
}
// We probably need to create the row.
t.mu.Lock()
r = t.rowIndex[row]
if r == nil {
r = newRow(row)
t.rowIndex[row] = r
t.rows = append(t.rows, r)
sort.Sort(byRowKey(t.rows)) // yay, inefficient!
}
t.mu.Unlock()
return r
}
type byRowKey []*row
func (b byRowKey) Len() int { return len(b) }
func (b byRowKey) Swap(i, j int) { b[i], b[j] = b[j], b[i] }
func (b byRowKey) Less(i, j int) bool { return b[i].key < b[j].key }
type row struct {
key string
mu sync.Mutex
cells map[string][]cell // keyed by full column name; cells are in descending timestamp order
}
func newRow(key string) *row {
return &row{
key: key,
cells: make(map[string][]cell),
}
}
type cell struct {
ts int64
value []byte
}
type byDescTS []cell
func (b byDescTS) Len() int { return len(b) }
func (b byDescTS) Swap(i, j int) { b[i], b[j] = b[j], b[i] }
func (b byDescTS) Less(i, j int) bool { return b[i].ts > b[j].ts }
================================================
FILE: vendor/google.golang.org/cloud/bigtable/cmd/cbt/cbt.go
================================================
/*
Copyright 2015 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package main
// Command docs are in cbtdoc.go.
import (
"bufio"
"bytes"
"flag"
"fmt"
"go/format"
"io/ioutil"
"log"
"os"
"path/filepath"
"regexp"
"sort"
"strconv"
"strings"
"text/tabwriter"
"text/template"
"time"
"golang.org/x/net/context"
"google.golang.org/cloud/bigtable"
)
var (
// These get default values from $HOME/.cbtrc if it exists.
project = flag.String("project", "", "project ID")
zone = flag.String("zone", "", "CBT zone")
cluster = flag.String("cluster", "", "CBT cluster")
creds = flag.String("creds", "", "if set, use application credentials in this file")
oFlag = flag.String("o", "", "if set, redirect stdout to this file")
client *bigtable.Client
adminClient *bigtable.AdminClient
)
func getClient() *bigtable.Client {
if client == nil {
var err error
client, err = bigtable.NewClient(context.Background(), *project, *zone, *cluster)
if err != nil {
log.Fatalf("Making bigtable.Client: %v", err)
}
}
return client
}
func getAdminClient() *bigtable.AdminClient {
if adminClient == nil {
var err error
adminClient, err = bigtable.NewAdminClient(context.Background(), *project, *zone, *cluster)
if err != nil {
log.Fatalf("Making bigtable.AdminClient: %v", err)
}
}
return adminClient
}
func configFilename() string {
// TODO(dsymonds): Might need tweaking for Windows.
return filepath.Join(os.Getenv("HOME"), ".cbtrc")
}
func loadConfig() {
filename := configFilename()
data, err := ioutil.ReadFile(filename)
if err != nil {
// silent fail if the file isn't there
if os.IsNotExist(err) {
return
}
log.Fatalf("Reading %s: %v", filename, err)
}
s := bufio.NewScanner(bytes.NewReader(data))
for s.Scan() {
line := s.Text()
i := strings.Index(line, "=")
if i < 0 {
log.Fatalf("Bad line in %s: %q", filename, line)
}
key, val := strings.TrimSpace(line[:i]), strings.TrimSpace(line[i+1:])
switch key {
default:
log.Fatalf("Unknown key in %s: %q", filename, key)
case "project":
*project = val
case "zone":
*zone = val
case "cluster":
*cluster = val
case "creds":
*creds = val
}
}
}
func main() {
loadConfig()
flag.Usage = usage
flag.Parse()
if *project == "" {
log.Fatal("Missing -project")
}
if *zone == "" {
log.Fatal("Missing -zone")
}
if *cluster == "" {
log.Fatal("Missing -cluster")
}
if *creds != "" {
os.Setenv("GOOGLE_APPLICATION_CREDENTIALS", *creds)
}
if flag.NArg() == 0 {
usage()
os.Exit(1)
}
if *oFlag != "" {
f, err := os.Create(*oFlag)
if err != nil {
log.Fatal(err)
}
defer func() {
if err := f.Close(); err != nil {
log.Fatal(err)
}
}()
os.Stdout = f
}
ctx := context.Background()
for _, cmd := range commands {
if cmd.Name == flag.Arg(0) {
cmd.do(ctx, flag.Args()[1:]...)
return
}
}
log.Fatalf("Unknown command %q", flag.Arg(0))
}
func usage() {
fmt.Fprintf(os.Stderr, "Usage: %s [flags] ...\n", os.Args[0])
flag.PrintDefaults()
fmt.Fprintf(os.Stderr, "\n%s", cmdSummary)
}
var cmdSummary string // generated in init, below
func init() {
var buf bytes.Buffer
tw := tabwriter.NewWriter(&buf, 10, 8, 4, '\t', 0)
for _, cmd := range commands {
fmt.Fprintf(tw, "cbt %s\t%s\n", cmd.Name, cmd.Desc)
}
tw.Flush()
buf.WriteString(configHelp)
cmdSummary = buf.String()
}
var configHelp = `
For convenience, values of the -project, -zone, -cluster and -creds flags
may be specified in ` + configFilename() + ` in this format:
project = my-project-123
zone = us-central1-b
cluster = my-cluster
creds = path-to-account-key.json
All values are optional, and all will be overridden by flags.
`
var commands = []struct {
Name, Desc string
do func(context.Context, ...string)
Usage string
}{
{
Name: "count",
Desc: "Count rows in a table",
do: doCount,
Usage: "cbt count ",
},
{
Name: "createfamily",
Desc: "Create a column family",
do: doCreateFamily,
Usage: "cbt createfamily ",
},
{
Name: "createtable",
Desc: "Create a table",
do: doCreateTable,
Usage: "cbt createtable ",
},
{
Name: "deletefamily",
Desc: "Delete a column family",
do: doDeleteFamily,
Usage: "cbt deletefamily ",
},
{
Name: "deleterow",
Desc: "Delete a row",
do: doDeleteRow,
Usage: "cbt deleterow ",
},
{
Name: "deletetable",
Desc: "Delete a table",
do: doDeleteTable,
Usage: "cbt deletetable ",
},
{
Name: "doc",
Desc: "Print documentation for cbt",
do: doDoc,
Usage: "cbt doc",
},
{
Name: "help",
Desc: "Print help text",
do: doHelp,
Usage: "cbt help [command]",
},
{
Name: "lookup",
Desc: "Read from a single row",
do: doLookup,
Usage: "cbt lookup ",
},
{
Name: "ls",
Desc: "List tables and column families",
do: doLS,
Usage: "cbt ls List tables\n" +
"cbt ls List column families in ",
},
{
Name: "read",
Desc: "Read rows",
do: doRead,
Usage: "cbt read [start=] [limit=] [prefix=]\n" +
" start= Start reading at this row\n" +
" limit= Stop reading before this row\n" +
" prefix= Read rows with this prefix\n",
},
{
Name: "set",
Desc: "Set value of a cell",
do: doSet,
Usage: "cbt set family:column=val[@ts] ...\n" +
" family:column=val[@ts] may be repeated to set multiple cells.\n" +
"\n" +
" ts is an optional integer timestamp.\n" +
" If it cannot be parsed, the `@ts` part will be\n" +
" interpreted as part of the value.",
},
{
Name: "setclustersize",
Desc: "Set size of a cluster",
do: doSetClusterSize,
Usage: "cbt setclustersize ",
},
}
func doCount(ctx context.Context, args ...string) {
if len(args) != 1 {
log.Fatal("usage: cbt count ")
}
tbl := getClient().Open(args[0])
n := 0
err := tbl.ReadRows(ctx, bigtable.InfiniteRange(""), func(_ bigtable.Row) bool {
n++
return true
}, bigtable.RowFilter(bigtable.StripValueFilter()))
if err != nil {
log.Fatalf("Reading rows: %v", err)
}
fmt.Println(n)
}
func doCreateFamily(ctx context.Context, args ...string) {
if len(args) != 2 {
log.Fatal("usage: cbt createfamily ")
}
err := getAdminClient().CreateColumnFamily(ctx, args[0], args[1])
if err != nil {
log.Fatalf("Creating column family: %v", err)
}
}
func doCreateTable(ctx context.Context, args ...string) {
if len(args) != 1 {
log.Fatal("usage: cbt createtable ")
}
err := getAdminClient().CreateTable(ctx, args[0])
if err != nil {
log.Fatalf("Creating table: %v", err)
}
}
func doDeleteFamily(ctx context.Context, args ...string) {
if len(args) != 2 {
log.Fatal("usage: cbt deletefamily ")
}
err := getAdminClient().DeleteColumnFamily(ctx, args[0], args[1])
if err != nil {
log.Fatalf("Deleting column family: %v", err)
}
}
func doDeleteRow(ctx context.Context, args ...string) {
if len(args) != 2 {
log.Fatal("usage: cbt deleterow ")
}
tbl := getClient().Open(args[0])
mut := bigtable.NewMutation()
mut.DeleteRow()
if err := tbl.Apply(ctx, args[1], mut); err != nil {
log.Fatalf("Deleting row: %v", err)
}
}
func doDeleteTable(ctx context.Context, args ...string) {
if len(args) != 1 {
log.Fatalf("Can't do `cbt deletetable %s`", args)
}
err := getAdminClient().DeleteTable(ctx, args[0])
if err != nil {
log.Fatalf("Deleting table: %v", err)
}
}
// to break circular dependencies
var (
doDocFn func(ctx context.Context, args ...string)
doHelpFn func(ctx context.Context, args ...string)
)
func init() {
doDocFn = doDocReal
doHelpFn = doHelpReal
}
func doDoc(ctx context.Context, args ...string) { doDocFn(ctx, args...) }
func doHelp(ctx context.Context, args ...string) { doHelpFn(ctx, args...) }
func doDocReal(ctx context.Context, args ...string) {
data := map[string]interface{}{
"Commands": commands,
}
var buf bytes.Buffer
if err := docTemplate.Execute(&buf, data); err != nil {
log.Fatalf("Bad doc template: %v", err)
}
out, err := format.Source(buf.Bytes())
if err != nil {
log.Fatalf("Bad doc output: %v", err)
}
os.Stdout.Write(out)
}
var docTemplate = template.Must(template.New("doc").Funcs(template.FuncMap{
"indent": func(s, ind string) string {
ss := strings.Split(s, "\n")
for i, p := range ss {
ss[i] = ind + p
}
return strings.Join(ss, "\n")
},
}).
Parse(`
// DO NOT EDIT. THIS IS AUTOMATICALLY GENERATED.
// Run "go generate" to regenerate.
//go:generate go run cbt.go -o cbtdoc.go doc
/*
Cbt is a tool for doing basic interactions with Cloud Bigtable.
Usage:
cbt [options] command [arguments]
The commands are:
{{range .Commands}}
{{printf "%-25s %s" .Name .Desc}}{{end}}
Use "cbt help " for more information about a command.
{{range .Commands}}
{{.Desc}}
Usage:
{{indent .Usage "\t"}}
{{end}}
*/
package main
`))
func doHelpReal(ctx context.Context, args ...string) {
if len(args) == 0 {
fmt.Print(cmdSummary)
return
}
for _, cmd := range commands {
if cmd.Name == args[0] {
fmt.Println(cmd.Usage)
return
}
}
log.Fatalf("Don't know command %q", args[0])
}
func doLookup(ctx context.Context, args ...string) {
if len(args) != 2 {
log.Fatalf("usage: cbt lookup ")
}
table, row := args[0], args[1]
tbl := getClient().Open(table)
r, err := tbl.ReadRow(ctx, row)
if err != nil {
log.Fatalf("Reading row: %v", err)
}
printRow(r)
}
func printRow(r bigtable.Row) {
fmt.Println(strings.Repeat("-", 40))
fmt.Println(r.Key())
var fams []string
for fam := range r {
fams = append(fams, fam)
}
sort.Strings(fams)
for _, fam := range fams {
ris := r[fam]
sort.Sort(byColumn(ris))
for _, ri := range ris {
ts := time.Unix(0, int64(ri.Timestamp)*1e3)
fmt.Printf(" %-40s @ %s\n", ri.Column, ts.Format("2006/01/02-15:04:05.000000"))
fmt.Printf(" %q\n", ri.Value)
}
}
}
type byColumn []bigtable.ReadItem
func (b byColumn) Len() int { return len(b) }
func (b byColumn) Swap(i, j int) { b[i], b[j] = b[j], b[i] }
func (b byColumn) Less(i, j int) bool { return b[i].Column < b[j].Column }
func doLS(ctx context.Context, args ...string) {
switch len(args) {
default:
log.Fatalf("Can't do `cbt ls %s`", args)
case 0:
tables, err := getAdminClient().Tables(ctx)
if err != nil {
log.Fatalf("Getting list of tables: %v", err)
}
sort.Strings(tables)
for _, table := range tables {
fmt.Println(table)
}
case 1:
table := args[0]
ti, err := getAdminClient().TableInfo(ctx, table)
if err != nil {
log.Fatalf("Getting table info: %v", err)
}
sort.Strings(ti.Families)
for _, fam := range ti.Families {
fmt.Println(fam)
}
}
}
func doRead(ctx context.Context, args ...string) {
if len(args) < 1 {
log.Fatalf("usage: cbt read [args ...]")
}
tbl := getClient().Open(args[0])
parsed := make(map[string]string)
for _, arg := range args[1:] {
i := strings.Index(arg, "=")
if i < 0 {
log.Fatalf("Bad arg %q", arg)
}
key, val := arg[:i], arg[i+1:]
switch key {
default:
log.Fatalf("Unknown arg key %q", key)
case "start", "limit", "prefix":
parsed[key] = val
}
}
if (parsed["start"] != "" || parsed["limit"] != "") && parsed["prefix"] != "" {
log.Fatal(`"start"/"limit" may not be mixed with "prefix"`)
}
var rr bigtable.RowRange
if start, limit := parsed["start"], parsed["limit"]; limit != "" {
rr = bigtable.NewRange(start, limit)
} else if start != "" {
rr = bigtable.InfiniteRange(start)
}
if prefix := parsed["prefix"]; prefix != "" {
rr = bigtable.PrefixRange(prefix)
}
// TODO(dsymonds): Support filters.
err := tbl.ReadRows(ctx, rr, func(r bigtable.Row) bool {
printRow(r)
return true
})
if err != nil {
log.Fatalf("Reading rows: %v", err)
}
}
var setArg = regexp.MustCompile(`([^:]+):([^=]*)=(.*)`)
func doSet(ctx context.Context, args ...string) {
if len(args) < 3 {
log.Fatalf("usage: cbt set family:[column]=val[@ts] ...")
}
tbl := getClient().Open(args[0])
row := args[1]
mut := bigtable.NewMutation()
for _, arg := range args[2:] {
m := setArg.FindStringSubmatch(arg)
if m == nil {
log.Fatalf("Bad set arg %q", arg)
}
val := m[3]
ts := bigtable.Now()
if i := strings.LastIndex(val, "@"); i >= 0 {
// Try parsing a timestamp.
n, err := strconv.ParseInt(val[i+1:], 0, 64)
if err == nil {
val = val[:i]
ts = bigtable.Timestamp(n)
}
}
mut.Set(m[1], m[2], ts, []byte(val))
}
if err := tbl.Apply(ctx, row, mut); err != nil {
log.Fatalf("Applying mutation: %v", err)
}
}
func doSetClusterSize(ctx context.Context, args ...string) {
if len(args) != 1 {
log.Fatalf("usage: cbt setclustersize ")
}
n, err := strconv.ParseInt(args[0], 0, 32)
if err != nil {
log.Fatalf("Bad num_nodes value %q: %v", args[0], err)
}
if err := getAdminClient().SetClusterSize(ctx, int(n)); err != nil {
log.Fatalf("Setting cluster size: %v", err)
}
}
================================================
FILE: vendor/google.golang.org/cloud/bigtable/cmd/cbt/cbtdoc.go
================================================
// DO NOT EDIT. THIS IS AUTOMATICALLY GENERATED.
// Run "go generate" to regenerate.
//go:generate go run cbt.go -o cbtdoc.go doc
/*
Cbt is a tool for doing basic interactions with Cloud Bigtable.
Usage:
cbt [options] command [arguments]
The commands are:
count Count rows in a table
createfamily Create a column family
createtable Create a table
deletefamily Delete a column family
deleterow Delete a row
deletetable Delete a table
doc Print documentation for cbt
help Print help text
lookup Read from a single row
ls List tables and column families
read Read rows
set Set value of a cell
setclustersize Set size of a cluster
Use "cbt help " for more information about a command.
Count rows in a table
Usage:
cbt count
Create a column family
Usage:
cbt createfamily
Create a table
Usage:
cbt createtable
Delete a column family
Usage:
cbt deletefamily
Delete a row
Usage:
cbt deleterow
Delete a table
Usage:
cbt deletetable
Print documentation for cbt
Usage:
cbt doc
Print help text
Usage:
cbt help [command]
Read from a single row
Usage:
cbt lookup
List tables and column families
Usage:
cbt ls List tables
cbt ls List column families in
Read rows
Usage:
cbt read [start=] [limit=] [prefix=]
start= Start reading at this row
limit= Stop reading before this row
prefix= Read rows with this prefix
Set value of a cell
Usage:
cbt set family:column=val[@ts] ...
family:column=val[@ts] may be repeated to set multiple cells.
ts is an optional integer timestamp.
If it cannot be parsed, the `@ts` part will be
interpreted as part of the value.
Set size of a cluster
Usage:
cbt setclustersize
*/
package main
================================================
FILE: vendor/google.golang.org/cloud/bigtable/doc.go
================================================
/*
Copyright 2015 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
/*
Package bigtable is an API to Google Cloud Bigtable.
See https://cloud.google.com/bigtable/docs/ for general product documentation.
Setup and Credentials
Use NewClient or NewAdminClient to create a client that can be used to access
the data or admin APIs respectively. Both require credentials that have permission
to access the Cloud Bigtable API.
If your program is run on Google App Engine or Google Compute Engine, using the Application Default Credentials
(https://developers.google.com/accounts/docs/application-default-credentials)
is the simplest option. Those credentials will be used by default when NewClient or NewAdminClient are called.
To use alternate credentials, pass them to NewClient or NewAdminClient using cloud.WithTokenSource.
For instance, you can use service account credentials by visiting
https://cloud.google.com/console/project/MYPROJECT/apiui/credential,
creating a new OAuth "Client ID", storing the JSON key somewhere accessible, and writing
jsonKey, err := ioutil.ReadFile(pathToKeyFile)
...
config, err := google.JWTConfigFromJSON(jsonKey, bigtable.Scope) // or bigtable.AdminScope, etc.
...
client, err := bigtable.NewClient(ctx, project, zone, cluster, cloud.WithTokenSource(config.TokenSource()))
...
Here, `google` means the golang.org/x/oauth2/google package
and `cloud` means the google.golang.org/cloud package.
Reading
The principal way to read from a Bigtable is to use the ReadRows method on *Table.
A RowRange specifies a contiguous portion of a table. A Filter may be provided through
RowFilter to limit or transform the data that is returned.
tbl := client.Open("mytable")
...
// Read all the rows starting with "com.google.",
// but only fetch the columns in the "links" family.
rr := bigtable.PrefixRange("com.google.")
err := tbl.ReadRows(ctx, rr, func(r Row) bool {
// do something with r
return true // keep going
}, bigtable.RowFilter(bigtable.FamilyFilter("links")))
...
To read a single row, use the ReadRow helper method.
r, err := tbl.ReadRow(ctx, "com.google.cloud") // "com.google.cloud" is the entire row key
...
Writing
This API exposes two distinct forms of writing to a Bigtable: a Mutation and a ReadModifyWrite.
The former expresses idempotent operations.
The latter expresses non-idempotent operations and returns the new values of updated cells.
These operations are performed by creating a Mutation or ReadModifyWrite (with NewMutation or NewReadModifyWrite),
building up one or more operations on that, and then using the Apply or ApplyReadModifyWrite
methods on a Table.
For instance, to set a couple of cells in a table,
tbl := client.Open("mytable")
mut := bigtable.NewMutation()
mut.Set("links", "maps.google.com", bigtable.Now(), []byte("1"))
mut.Set("links", "golang.org", bigtable.Now(), []byte("1"))
err := tbl.Apply(ctx, "com.google.cloud", mut)
...
To increment an encoded value in one cell,
tbl := client.Open("mytable")
rmw := bigtable.NewReadModifyWrite()
rmw.Increment("links", "golang.org", 12) // add 12 to the cell in column "links:golang.org"
r, err := tbl.ApplyReadModifyWrite(ctx, "com.google.cloud", rmw)
...
*/
package bigtable
// Scope constants for authentication credentials.
// These should be used when using credential creation functions such as credentials.NewServiceAccountFromFile.
const (
// Scope is the OAuth scope for Cloud Bigtable data operations.
Scope = "https://www.googleapis.com/auth/bigtable.data"
// ReadonlyScope is the OAuth scope for Cloud Bigtable read-only data operations.
ReadonlyScope = "https://www.googleapis.com/auth/bigtable.readonly"
// AdminScope is the OAuth scope for Cloud Bigtable admin operations.
AdminScope = "https://www.googleapis.com/auth/bigtable.admin"
)
================================================
FILE: vendor/google.golang.org/cloud/bigtable/filter.go
================================================
/*
Copyright 2015 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package bigtable
import (
"fmt"
"strings"
btdpb "google.golang.org/cloud/bigtable/internal/data_proto"
)
// A Filter represents a row filter.
type Filter interface {
String() string
proto() *btdpb.RowFilter
}
// ChainFilters returns a filter that applies a sequence of filters.
func ChainFilters(sub ...Filter) Filter { return chainFilter{sub} }
type chainFilter struct {
sub []Filter
}
func (cf chainFilter) String() string {
var ss []string
for _, sf := range cf.sub {
ss = append(ss, sf.String())
}
return "(" + strings.Join(ss, " | ") + ")"
}
func (cf chainFilter) proto() *btdpb.RowFilter {
f := &btdpb.RowFilter{
Chain: &btdpb.RowFilter_Chain{},
}
for _, sf := range cf.sub {
f.Chain.Filters = append(f.Chain.Filters, sf.proto())
}
return f
}
// InterleaveFilters returns a filter that applies a set of filters in parallel
// and interleaves the results.
func InterleaveFilters(sub ...Filter) Filter { return interleaveFilter{sub} }
type interleaveFilter struct {
sub []Filter
}
func (ilf interleaveFilter) String() string {
var ss []string
for _, sf := range ilf.sub {
ss = append(ss, sf.String())
}
return "(" + strings.Join(ss, " + ") + ")"
}
func (ilf interleaveFilter) proto() *btdpb.RowFilter {
f := &btdpb.RowFilter{
Interleave: &btdpb.RowFilter_Interleave{},
}
for _, sf := range ilf.sub {
f.Interleave.Filters = append(f.Interleave.Filters, sf.proto())
}
return f
}
// RowKeyFilter returns a filter that matches cells from rows whose
// key matches the provided RE2 pattern.
// See https://github.com/google/re2/wiki/Syntax for the accepted syntax.
func RowKeyFilter(pattern string) Filter { return rowKeyFilter(pattern) }
type rowKeyFilter string
func (rkf rowKeyFilter) String() string { return fmt.Sprintf("row(%s)", string(rkf)) }
func (rkf rowKeyFilter) proto() *btdpb.RowFilter {
return &btdpb.RowFilter{RowKeyRegexFilter: []byte(rkf)}
}
// FamilyFilter returns a filter that matches cells whose family name
// matches the provided RE2 pattern.
// See https://github.com/google/re2/wiki/Syntax for the accepted syntax.
func FamilyFilter(pattern string) Filter { return familyFilter(pattern) }
type familyFilter string
func (ff familyFilter) String() string { return fmt.Sprintf("col(%s:)", string(ff)) }
func (ff familyFilter) proto() *btdpb.RowFilter {
return &btdpb.RowFilter{FamilyNameRegexFilter: string(ff)}
}
// ColumnFilter returns a filter that matches cells whose column name
// matches the provided RE2 pattern.
// See https://github.com/google/re2/wiki/Syntax for the accepted syntax.
func ColumnFilter(pattern string) Filter { return columnFilter(pattern) }
type columnFilter string
func (cf columnFilter) String() string { return fmt.Sprintf("col(.*:%s)", string(cf)) }
func (cf columnFilter) proto() *btdpb.RowFilter {
return &btdpb.RowFilter{ColumnQualifierRegexFilter: []byte(cf)}
}
// ValueFilter returns a filter that matches cells whose value
// matches the provided RE2 pattern.
// See https://github.com/google/re2/wiki/Syntax for the accepted syntax.
func ValueFilter(pattern string) Filter { return valueFilter(pattern) }
type valueFilter string
func (vf valueFilter) String() string { return fmt.Sprintf("value_match(%s)", string(vf)) }
func (vf valueFilter) proto() *btdpb.RowFilter {
return &btdpb.RowFilter{ValueRegexFilter: []byte(vf)}
}
// LatestNFilter returns a filter that matches the most recent N cells in each column.
func LatestNFilter(n int) Filter { return latestNFilter(n) }
type latestNFilter int32
func (lnf latestNFilter) String() string { return fmt.Sprintf("col(*,%d)", lnf) }
func (lnf latestNFilter) proto() *btdpb.RowFilter {
return &btdpb.RowFilter{CellsPerColumnLimitFilter: int32(lnf)}
}
// StripValueFilter returns a filter that replaces each value with the empty string.
func StripValueFilter() Filter { return stripValueFilter{} }
type stripValueFilter struct{}
func (stripValueFilter) String() string { return "strip_value()" }
func (stripValueFilter) proto() *btdpb.RowFilter { return &btdpb.RowFilter{StripValueTransformer: true} }
// TODO(dsymonds): More filters: cond, col/ts/value range, sampling
================================================
FILE: vendor/google.golang.org/cloud/bigtable/internal/cluster_data_proto/bigtable_cluster_data.pb.go
================================================
// Code generated by protoc-gen-go.
// source: google.golang.org/cloud/bigtable/internal/cluster_data_proto/bigtable_cluster_data.proto
// DO NOT EDIT!
/*
Package google_bigtable_admin_cluster_v1 is a generated protocol buffer package.
It is generated from these files:
google.golang.org/cloud/bigtable/internal/cluster_data_proto/bigtable_cluster_data.proto
It has these top-level messages:
Zone
Cluster
*/
package google_bigtable_admin_cluster_v1
import proto "github.com/golang/protobuf/proto"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
// Possible states of a zone.
type Zone_Status int32
const (
// The state of the zone is unknown or unspecified.
Zone_UNKNOWN Zone_Status = 0
// The zone is in a good state.
Zone_OK Zone_Status = 1
// The zone is down for planned maintenance.
Zone_PLANNED_MAINTENANCE Zone_Status = 2
// The zone is down for emergency or unplanned maintenance.
Zone_EMERGENCY_MAINENANCE Zone_Status = 3
)
var Zone_Status_name = map[int32]string{
0: "UNKNOWN",
1: "OK",
2: "PLANNED_MAINTENANCE",
3: "EMERGENCY_MAINENANCE",
}
var Zone_Status_value = map[string]int32{
"UNKNOWN": 0,
"OK": 1,
"PLANNED_MAINTENANCE": 2,
"EMERGENCY_MAINENANCE": 3,
}
func (x Zone_Status) String() string {
return proto.EnumName(Zone_Status_name, int32(x))
}
// A physical location in which a particular project can allocate Cloud BigTable
// resources.
type Zone struct {
// A permanent unique identifier for the zone.
// Values are of the form projects//zones/[a-z][-a-z0-9]*
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// The name of this zone as it appears in UIs.
DisplayName string `protobuf:"bytes,2,opt,name=display_name" json:"display_name,omitempty"`
// The current state of this zone.
Status Zone_Status `protobuf:"varint,3,opt,name=status,enum=google.bigtable.admin.cluster.v1.Zone_Status" json:"status,omitempty"`
}
func (m *Zone) Reset() { *m = Zone{} }
func (m *Zone) String() string { return proto.CompactTextString(m) }
func (*Zone) ProtoMessage() {}
// An isolated set of Cloud BigTable resources on which tables can be hosted.
type Cluster struct {
// A permanent unique identifier for the cluster. For technical reasons, the
// zone in which the cluster resides is included here.
// Values are of the form
// projects//zones//clusters/[a-z][-a-z0-9]*
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// The descriptive name for this cluster as it appears in UIs.
// Must be unique per zone.
DisplayName string `protobuf:"bytes,4,opt,name=display_name" json:"display_name,omitempty"`
// The number of serve nodes allocated to this cluster.
ServeNodes int32 `protobuf:"varint,5,opt,name=serve_nodes" json:"serve_nodes,omitempty"`
// The maximum HDD storage usage allowed in this cluster, in bytes.
HddBytes int64 `protobuf:"varint,6,opt,name=hdd_bytes" json:"hdd_bytes,omitempty"`
// The maximum SSD storage usage allowed in this cluster, in bytes.
SsdBytes int64 `protobuf:"varint,7,opt,name=ssd_bytes" json:"ssd_bytes,omitempty"`
}
func (m *Cluster) Reset() { *m = Cluster{} }
func (m *Cluster) String() string { return proto.CompactTextString(m) }
func (*Cluster) ProtoMessage() {}
func init() {
proto.RegisterEnum("google.bigtable.admin.cluster.v1.Zone_Status", Zone_Status_name, Zone_Status_value)
}
================================================
FILE: vendor/google.golang.org/cloud/bigtable/internal/cluster_data_proto/bigtable_cluster_data.proto
================================================
// Copyright (c) 2015, Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
syntax = "proto3";
package google.bigtable.admin.cluster.v1;
option java_multiple_files = true;
option java_outer_classname = "BigtableClusterDataProto";
option java_package = "com.google.bigtable.admin.cluster.v1";
// A physical location in which a particular project can allocate Cloud BigTable
// resources.
message Zone {
// Possible states of a zone.
enum Status {
// The state of the zone is unknown or unspecified.
UNKNOWN = 0;
// The zone is in a good state.
OK = 1;
// The zone is down for planned maintenance.
PLANNED_MAINTENANCE = 2;
// The zone is down for emergency or unplanned maintenance.
EMERGENCY_MAINENANCE = 3;
}
// A permanent unique identifier for the zone.
// Values are of the form projects//zones/[a-z][-a-z0-9]*
string name = 1;
// The name of this zone as it appears in UIs.
string display_name = 2;
// The current state of this zone.
Status status = 3;
}
// An isolated set of Cloud BigTable resources on which tables can be hosted.
message Cluster {
// A permanent unique identifier for the cluster. For technical reasons, the
// zone in which the cluster resides is included here.
// Values are of the form
// projects//zones//clusters/[a-z][-a-z0-9]*
string name = 1;
// If this cluster has been deleted, the time at which its backup will
// be irrevocably destroyed. Omitted otherwise.
// This cannot be set directly, only through DeleteCluster.
// The operation currently running on the cluster, if any.
// This cannot be set directly, only through CreateCluster, UpdateCluster,
// or UndeleteCluster. Calls to these methods will be rejected if
// "current_operation" is already set.
// The descriptive name for this cluster as it appears in UIs.
// Must be unique per zone.
string display_name = 4;
// The number of serve nodes allocated to this cluster.
int32 serve_nodes = 5;
// The maximum HDD storage usage allowed in this cluster, in bytes.
int64 hdd_bytes = 6;
// The maximum SSD storage usage allowed in this cluster, in bytes.
int64 ssd_bytes = 7;
}
================================================
FILE: vendor/google.golang.org/cloud/bigtable/internal/cluster_service_proto/bigtable_cluster_service.pb.go
================================================
// Code generated by protoc-gen-go.
// source: google.golang.org/cloud/bigtable/internal/cluster_service_proto/bigtable_cluster_service.proto
// DO NOT EDIT!
package google_bigtable_admin_cluster_v1
import proto "github.com/golang/protobuf/proto"
import google_bigtable_admin_cluster_v11 "google.golang.org/cloud/bigtable/internal/cluster_data_proto"
import google_protobuf "google.golang.org/cloud/bigtable/internal/empty"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
func init() {
}
// Client API for BigtableClusterService service
type BigtableClusterServiceClient interface {
// Lists the supported zones for the given project.
ListZones(ctx context.Context, in *ListZonesRequest, opts ...grpc.CallOption) (*ListZonesResponse, error)
// Gets information about a particular cluster.
GetCluster(ctx context.Context, in *GetClusterRequest, opts ...grpc.CallOption) (*google_bigtable_admin_cluster_v11.Cluster, error)
// Lists all clusters in the given project, along with any zones for which
// cluster information could not be retrieved.
ListClusters(ctx context.Context, in *ListClustersRequest, opts ...grpc.CallOption) (*ListClustersResponse, error)
// Creates a cluster and begins preparing it to begin serving. The returned
// cluster embeds as its "current_operation" a long-running operation which
// can be used to track the progress of turning up the new cluster.
// Immediately upon completion of this request:
// * The cluster will be readable via the API, with all requested attributes
// but no allocated resources.
// Until completion of the embedded operation:
// * Cancelling the operation will render the cluster immediately unreadable
// via the API.
// * All other attempts to modify or delete the cluster will be rejected.
// Upon completion of the embedded operation:
// * Billing for all successfully-allocated resources will begin (some types
// may have lower than the requested levels).
// * New tables can be created in the cluster.
// * The cluster's allocated resource levels will be readable via the API.
// The embedded operation's "metadata" field type is
// [CreateClusterMetadata][google.bigtable.admin.cluster.v1.CreateClusterMetadata] The embedded operation's "response" field type is
// [Cluster][google.bigtable.admin.cluster.v1.Cluster], if successful.
CreateCluster(ctx context.Context, in *CreateClusterRequest, opts ...grpc.CallOption) (*google_bigtable_admin_cluster_v11.Cluster, error)
// Updates a cluster, and begins allocating or releasing resources as
// requested. The returned cluster embeds as its "current_operation" a
// long-running operation which can be used to track the progress of updating
// the cluster.
// Immediately upon completion of this request:
// * For resource types where a decrease in the cluster's allocation has been
// requested, billing will be based on the newly-requested level.
// Until completion of the embedded operation:
// * Cancelling the operation will set its metadata's "cancelled_at_time",
// and begin restoring resources to their pre-request values. The operation
// is guaranteed to succeed at undoing all resource changes, after which
// point it will terminate with a CANCELLED status.
// * All other attempts to modify or delete the cluster will be rejected.
// * Reading the cluster via the API will continue to give the pre-request
// resource levels.
// Upon completion of the embedded operation:
// * Billing will begin for all successfully-allocated resources (some types
// may have lower than the requested levels).
// * All newly-reserved resources will be available for serving the cluster's
// tables.
// * The cluster's new resource levels will be readable via the API.
// [UpdateClusterMetadata][google.bigtable.admin.cluster.v1.UpdateClusterMetadata] The embedded operation's "response" field type is
// [Cluster][google.bigtable.admin.cluster.v1.Cluster], if successful.
UpdateCluster(ctx context.Context, in *google_bigtable_admin_cluster_v11.Cluster, opts ...grpc.CallOption) (*google_bigtable_admin_cluster_v11.Cluster, error)
// Marks a cluster and all of its tables for permanent deletion in 7 days.
// Immediately upon completion of the request:
// * Billing will cease for all of the cluster's reserved resources.
// * The cluster's "delete_time" field will be set 7 days in the future.
// Soon afterward:
// * All tables within the cluster will become unavailable.
// Prior to the cluster's "delete_time":
// * The cluster can be recovered with a call to UndeleteCluster.
// * All other attempts to modify or delete the cluster will be rejected.
// At the cluster's "delete_time":
// * The cluster and *all of its tables* will immediately and irrevocably
// disappear from the API, and their data will be permanently deleted.
DeleteCluster(ctx context.Context, in *DeleteClusterRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
}
type bigtableClusterServiceClient struct {
cc *grpc.ClientConn
}
func NewBigtableClusterServiceClient(cc *grpc.ClientConn) BigtableClusterServiceClient {
return &bigtableClusterServiceClient{cc}
}
func (c *bigtableClusterServiceClient) ListZones(ctx context.Context, in *ListZonesRequest, opts ...grpc.CallOption) (*ListZonesResponse, error) {
out := new(ListZonesResponse)
err := grpc.Invoke(ctx, "/google.bigtable.admin.cluster.v1.BigtableClusterService/ListZones", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableClusterServiceClient) GetCluster(ctx context.Context, in *GetClusterRequest, opts ...grpc.CallOption) (*google_bigtable_admin_cluster_v11.Cluster, error) {
out := new(google_bigtable_admin_cluster_v11.Cluster)
err := grpc.Invoke(ctx, "/google.bigtable.admin.cluster.v1.BigtableClusterService/GetCluster", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableClusterServiceClient) ListClusters(ctx context.Context, in *ListClustersRequest, opts ...grpc.CallOption) (*ListClustersResponse, error) {
out := new(ListClustersResponse)
err := grpc.Invoke(ctx, "/google.bigtable.admin.cluster.v1.BigtableClusterService/ListClusters", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableClusterServiceClient) CreateCluster(ctx context.Context, in *CreateClusterRequest, opts ...grpc.CallOption) (*google_bigtable_admin_cluster_v11.Cluster, error) {
out := new(google_bigtable_admin_cluster_v11.Cluster)
err := grpc.Invoke(ctx, "/google.bigtable.admin.cluster.v1.BigtableClusterService/CreateCluster", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableClusterServiceClient) UpdateCluster(ctx context.Context, in *google_bigtable_admin_cluster_v11.Cluster, opts ...grpc.CallOption) (*google_bigtable_admin_cluster_v11.Cluster, error) {
out := new(google_bigtable_admin_cluster_v11.Cluster)
err := grpc.Invoke(ctx, "/google.bigtable.admin.cluster.v1.BigtableClusterService/UpdateCluster", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableClusterServiceClient) DeleteCluster(ctx context.Context, in *DeleteClusterRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
out := new(google_protobuf.Empty)
err := grpc.Invoke(ctx, "/google.bigtable.admin.cluster.v1.BigtableClusterService/DeleteCluster", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for BigtableClusterService service
type BigtableClusterServiceServer interface {
// Lists the supported zones for the given project.
ListZones(context.Context, *ListZonesRequest) (*ListZonesResponse, error)
// Gets information about a particular cluster.
GetCluster(context.Context, *GetClusterRequest) (*google_bigtable_admin_cluster_v11.Cluster, error)
// Lists all clusters in the given project, along with any zones for which
// cluster information could not be retrieved.
ListClusters(context.Context, *ListClustersRequest) (*ListClustersResponse, error)
// Creates a cluster and begins preparing it to begin serving. The returned
// cluster embeds as its "current_operation" a long-running operation which
// can be used to track the progress of turning up the new cluster.
// Immediately upon completion of this request:
// * The cluster will be readable via the API, with all requested attributes
// but no allocated resources.
// Until completion of the embedded operation:
// * Cancelling the operation will render the cluster immediately unreadable
// via the API.
// * All other attempts to modify or delete the cluster will be rejected.
// Upon completion of the embedded operation:
// * Billing for all successfully-allocated resources will begin (some types
// may have lower than the requested levels).
// * New tables can be created in the cluster.
// * The cluster's allocated resource levels will be readable via the API.
// The embedded operation's "metadata" field type is
// [CreateClusterMetadata][google.bigtable.admin.cluster.v1.CreateClusterMetadata] The embedded operation's "response" field type is
// [Cluster][google.bigtable.admin.cluster.v1.Cluster], if successful.
CreateCluster(context.Context, *CreateClusterRequest) (*google_bigtable_admin_cluster_v11.Cluster, error)
// Updates a cluster, and begins allocating or releasing resources as
// requested. The returned cluster embeds as its "current_operation" a
// long-running operation which can be used to track the progress of updating
// the cluster.
// Immediately upon completion of this request:
// * For resource types where a decrease in the cluster's allocation has been
// requested, billing will be based on the newly-requested level.
// Until completion of the embedded operation:
// * Cancelling the operation will set its metadata's "cancelled_at_time",
// and begin restoring resources to their pre-request values. The operation
// is guaranteed to succeed at undoing all resource changes, after which
// point it will terminate with a CANCELLED status.
// * All other attempts to modify or delete the cluster will be rejected.
// * Reading the cluster via the API will continue to give the pre-request
// resource levels.
// Upon completion of the embedded operation:
// * Billing will begin for all successfully-allocated resources (some types
// may have lower than the requested levels).
// * All newly-reserved resources will be available for serving the cluster's
// tables.
// * The cluster's new resource levels will be readable via the API.
// [UpdateClusterMetadata][google.bigtable.admin.cluster.v1.UpdateClusterMetadata] The embedded operation's "response" field type is
// [Cluster][google.bigtable.admin.cluster.v1.Cluster], if successful.
UpdateCluster(context.Context, *google_bigtable_admin_cluster_v11.Cluster) (*google_bigtable_admin_cluster_v11.Cluster, error)
// Marks a cluster and all of its tables for permanent deletion in 7 days.
// Immediately upon completion of the request:
// * Billing will cease for all of the cluster's reserved resources.
// * The cluster's "delete_time" field will be set 7 days in the future.
// Soon afterward:
// * All tables within the cluster will become unavailable.
// Prior to the cluster's "delete_time":
// * The cluster can be recovered with a call to UndeleteCluster.
// * All other attempts to modify or delete the cluster will be rejected.
// At the cluster's "delete_time":
// * The cluster and *all of its tables* will immediately and irrevocably
// disappear from the API, and their data will be permanently deleted.
DeleteCluster(context.Context, *DeleteClusterRequest) (*google_protobuf.Empty, error)
}
func RegisterBigtableClusterServiceServer(s *grpc.Server, srv BigtableClusterServiceServer) {
s.RegisterService(&_BigtableClusterService_serviceDesc, srv)
}
func _BigtableClusterService_ListZones_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
in := new(ListZonesRequest)
if err := codec.Unmarshal(buf, in); err != nil {
return nil, err
}
out, err := srv.(BigtableClusterServiceServer).ListZones(ctx, in)
if err != nil {
return nil, err
}
return out, nil
}
func _BigtableClusterService_GetCluster_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
in := new(GetClusterRequest)
if err := codec.Unmarshal(buf, in); err != nil {
return nil, err
}
out, err := srv.(BigtableClusterServiceServer).GetCluster(ctx, in)
if err != nil {
return nil, err
}
return out, nil
}
func _BigtableClusterService_ListClusters_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
in := new(ListClustersRequest)
if err := codec.Unmarshal(buf, in); err != nil {
return nil, err
}
out, err := srv.(BigtableClusterServiceServer).ListClusters(ctx, in)
if err != nil {
return nil, err
}
return out, nil
}
func _BigtableClusterService_CreateCluster_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
in := new(CreateClusterRequest)
if err := codec.Unmarshal(buf, in); err != nil {
return nil, err
}
out, err := srv.(BigtableClusterServiceServer).CreateCluster(ctx, in)
if err != nil {
return nil, err
}
return out, nil
}
func _BigtableClusterService_UpdateCluster_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
in := new(google_bigtable_admin_cluster_v11.Cluster)
if err := codec.Unmarshal(buf, in); err != nil {
return nil, err
}
out, err := srv.(BigtableClusterServiceServer).UpdateCluster(ctx, in)
if err != nil {
return nil, err
}
return out, nil
}
func _BigtableClusterService_DeleteCluster_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
in := new(DeleteClusterRequest)
if err := codec.Unmarshal(buf, in); err != nil {
return nil, err
}
out, err := srv.(BigtableClusterServiceServer).DeleteCluster(ctx, in)
if err != nil {
return nil, err
}
return out, nil
}
var _BigtableClusterService_serviceDesc = grpc.ServiceDesc{
ServiceName: "google.bigtable.admin.cluster.v1.BigtableClusterService",
HandlerType: (*BigtableClusterServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "ListZones",
Handler: _BigtableClusterService_ListZones_Handler,
},
{
MethodName: "GetCluster",
Handler: _BigtableClusterService_GetCluster_Handler,
},
{
MethodName: "ListClusters",
Handler: _BigtableClusterService_ListClusters_Handler,
},
{
MethodName: "CreateCluster",
Handler: _BigtableClusterService_CreateCluster_Handler,
},
{
MethodName: "UpdateCluster",
Handler: _BigtableClusterService_UpdateCluster_Handler,
},
{
MethodName: "DeleteCluster",
Handler: _BigtableClusterService_DeleteCluster_Handler,
},
},
Streams: []grpc.StreamDesc{},
}
================================================
FILE: vendor/google.golang.org/cloud/bigtable/internal/cluster_service_proto/bigtable_cluster_service.proto
================================================
// Copyright (c) 2015, Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
syntax = "proto3";
package google.bigtable.admin.cluster.v1;
import "google.golang.org/cloud/bigtable/internal/cluster_data_proto/bigtable_cluster_data.proto";
import "google.golang.org/cloud/bigtable/internal/cluster_service_proto/bigtable_cluster_service_messages.proto";
import "google.golang.org/cloud/bigtable/internal/empty/empty.proto";
option java_multiple_files = true;
option java_outer_classname = "BigtableClusterServicesProto";
option java_package = "com.google.bigtable.admin.cluster.v1";
// Service for managing zonal Cloud Bigtable resources.
service BigtableClusterService {
// Lists the supported zones for the given project.
rpc ListZones(ListZonesRequest) returns (ListZonesResponse) {
}
// Gets information about a particular cluster.
rpc GetCluster(GetClusterRequest) returns (Cluster) {
}
// Lists all clusters in the given project, along with any zones for which
// cluster information could not be retrieved.
rpc ListClusters(ListClustersRequest) returns (ListClustersResponse) {
}
// Creates a cluster and begins preparing it to begin serving. The returned
// cluster embeds as its "current_operation" a long-running operation which
// can be used to track the progress of turning up the new cluster.
// Immediately upon completion of this request:
// * The cluster will be readable via the API, with all requested attributes
// but no allocated resources.
// Until completion of the embedded operation:
// * Cancelling the operation will render the cluster immediately unreadable
// via the API.
// * All other attempts to modify or delete the cluster will be rejected.
// Upon completion of the embedded operation:
// * Billing for all successfully-allocated resources will begin (some types
// may have lower than the requested levels).
// * New tables can be created in the cluster.
// * The cluster's allocated resource levels will be readable via the API.
// The embedded operation's "metadata" field type is
// [CreateClusterMetadata][google.bigtable.admin.cluster.v1.CreateClusterMetadata] The embedded operation's "response" field type is
// [Cluster][google.bigtable.admin.cluster.v1.Cluster], if successful.
rpc CreateCluster(CreateClusterRequest) returns (Cluster) {
}
// Updates a cluster, and begins allocating or releasing resources as
// requested. The returned cluster embeds as its "current_operation" a
// long-running operation which can be used to track the progress of updating
// the cluster.
// Immediately upon completion of this request:
// * For resource types where a decrease in the cluster's allocation has been
// requested, billing will be based on the newly-requested level.
// Until completion of the embedded operation:
// * Cancelling the operation will set its metadata's "cancelled_at_time",
// and begin restoring resources to their pre-request values. The operation
// is guaranteed to succeed at undoing all resource changes, after which
// point it will terminate with a CANCELLED status.
// * All other attempts to modify or delete the cluster will be rejected.
// * Reading the cluster via the API will continue to give the pre-request
// resource levels.
// Upon completion of the embedded operation:
// * Billing will begin for all successfully-allocated resources (some types
// may have lower than the requested levels).
// * All newly-reserved resources will be available for serving the cluster's
// tables.
// * The cluster's new resource levels will be readable via the API.
// [UpdateClusterMetadata][google.bigtable.admin.cluster.v1.UpdateClusterMetadata] The embedded operation's "response" field type is
// [Cluster][google.bigtable.admin.cluster.v1.Cluster], if successful.
rpc UpdateCluster(Cluster) returns (Cluster) {
}
// Marks a cluster and all of its tables for permanent deletion in 7 days.
// Immediately upon completion of the request:
// * Billing will cease for all of the cluster's reserved resources.
// * The cluster's "delete_time" field will be set 7 days in the future.
// Soon afterward:
// * All tables within the cluster will become unavailable.
// Prior to the cluster's "delete_time":
// * The cluster can be recovered with a call to UndeleteCluster.
// * All other attempts to modify or delete the cluster will be rejected.
// At the cluster's "delete_time":
// * The cluster and *all of its tables* will immediately and irrevocably
// disappear from the API, and their data will be permanently deleted.
rpc DeleteCluster(DeleteClusterRequest) returns (google.protobuf.Empty) {
}
// Cancels the scheduled deletion of an cluster and begins preparing it to
// resume serving. The returned operation will also be embedded as the
// cluster's "current_operation".
// Immediately upon completion of this request:
// * The cluster's "delete_time" field will be unset, protecting it from
// automatic deletion.
// Until completion of the returned operation:
// * The operation cannot be cancelled.
// Upon completion of the returned operation:
// * Billing for the cluster's resources will resume.
// * All tables within the cluster will be available.
// [UndeleteClusterMetadata][google.bigtable.admin.cluster.v1.UndeleteClusterMetadata] The embedded operation's "response" field type is
// [Cluster][google.bigtable.admin.cluster.v1.Cluster], if successful.
}
================================================
FILE: vendor/google.golang.org/cloud/bigtable/internal/cluster_service_proto/bigtable_cluster_service_messages.pb.go
================================================
// Code generated by protoc-gen-go.
// source: google.golang.org/cloud/bigtable/internal/cluster_service_proto/bigtable_cluster_service_messages.proto
// DO NOT EDIT!
/*
Package google_bigtable_admin_cluster_v1 is a generated protocol buffer package.
It is generated from these files:
google.golang.org/cloud/bigtable/internal/cluster_service_proto/bigtable_cluster_service_messages.proto
google.golang.org/cloud/bigtable/internal/cluster_service_proto/bigtable_cluster_service.proto
It has these top-level messages:
ListZonesRequest
ListZonesResponse
GetClusterRequest
ListClustersRequest
ListClustersResponse
CreateClusterRequest
CreateClusterMetadata
UpdateClusterMetadata
DeleteClusterRequest
UndeleteClusterRequest
UndeleteClusterMetadata
*/
package google_bigtable_admin_cluster_v1
import proto "github.com/golang/protobuf/proto"
import google_bigtable_admin_cluster_v11 "google.golang.org/cloud/bigtable/internal/cluster_data_proto"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
// Request message for BigtableClusterService.ListZones.
type ListZonesRequest struct {
// The unique name of the project for which a list of supported zones is
// requested.
// Values are of the form projects/
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}
func (m *ListZonesRequest) Reset() { *m = ListZonesRequest{} }
func (m *ListZonesRequest) String() string { return proto.CompactTextString(m) }
func (*ListZonesRequest) ProtoMessage() {}
// Response message for BigtableClusterService.ListZones.
type ListZonesResponse struct {
// The list of requested zones.
Zones []*google_bigtable_admin_cluster_v11.Zone `protobuf:"bytes,1,rep,name=zones" json:"zones,omitempty"`
}
func (m *ListZonesResponse) Reset() { *m = ListZonesResponse{} }
func (m *ListZonesResponse) String() string { return proto.CompactTextString(m) }
func (*ListZonesResponse) ProtoMessage() {}
func (m *ListZonesResponse) GetZones() []*google_bigtable_admin_cluster_v11.Zone {
if m != nil {
return m.Zones
}
return nil
}
// Request message for BigtableClusterService.GetCluster.
type GetClusterRequest struct {
// The unique name of the requested cluster.
// Values are of the form projects//zones//clusters/
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}
func (m *GetClusterRequest) Reset() { *m = GetClusterRequest{} }
func (m *GetClusterRequest) String() string { return proto.CompactTextString(m) }
func (*GetClusterRequest) ProtoMessage() {}
// Request message for BigtableClusterService.ListClusters.
type ListClustersRequest struct {
// The unique name of the project for which a list of clusters is requested.
// Values are of the form projects/
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}
func (m *ListClustersRequest) Reset() { *m = ListClustersRequest{} }
func (m *ListClustersRequest) String() string { return proto.CompactTextString(m) }
func (*ListClustersRequest) ProtoMessage() {}
// Response message for BigtableClusterService.ListClusters.
type ListClustersResponse struct {
// The list of requested Clusters.
Clusters []*google_bigtable_admin_cluster_v11.Cluster `protobuf:"bytes,1,rep,name=clusters" json:"clusters,omitempty"`
// The zones for which clusters could not be retrieved.
FailedZones []*google_bigtable_admin_cluster_v11.Zone `protobuf:"bytes,2,rep,name=failed_zones" json:"failed_zones,omitempty"`
}
func (m *ListClustersResponse) Reset() { *m = ListClustersResponse{} }
func (m *ListClustersResponse) String() string { return proto.CompactTextString(m) }
func (*ListClustersResponse) ProtoMessage() {}
func (m *ListClustersResponse) GetClusters() []*google_bigtable_admin_cluster_v11.Cluster {
if m != nil {
return m.Clusters
}
return nil
}
func (m *ListClustersResponse) GetFailedZones() []*google_bigtable_admin_cluster_v11.Zone {
if m != nil {
return m.FailedZones
}
return nil
}
// Request message for BigtableClusterService.CreateCluster.
type CreateClusterRequest struct {
// The unique name of the zone in which to create the cluster.
// Values are of the form projects//zones/
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// The id to be used when referring to the new cluster within its zone,
// e.g. just the "test-cluster" section of the full name
// "projects//zones//clusters/test-cluster".
ClusterId string `protobuf:"bytes,2,opt,name=cluster_id" json:"cluster_id,omitempty"`
// The cluster to create.
// The "name", "delete_time", and "current_operation" fields must be left
// blank.
Cluster *google_bigtable_admin_cluster_v11.Cluster `protobuf:"bytes,3,opt,name=cluster" json:"cluster,omitempty"`
}
func (m *CreateClusterRequest) Reset() { *m = CreateClusterRequest{} }
func (m *CreateClusterRequest) String() string { return proto.CompactTextString(m) }
func (*CreateClusterRequest) ProtoMessage() {}
func (m *CreateClusterRequest) GetCluster() *google_bigtable_admin_cluster_v11.Cluster {
if m != nil {
return m.Cluster
}
return nil
}
// Metadata type for the operation returned by
// BigtableClusterService.CreateCluster.
type CreateClusterMetadata struct {
// The request which prompted the creation of this operation.
OriginalRequest *CreateClusterRequest `protobuf:"bytes,1,opt,name=original_request" json:"original_request,omitempty"`
}
func (m *CreateClusterMetadata) Reset() { *m = CreateClusterMetadata{} }
func (m *CreateClusterMetadata) String() string { return proto.CompactTextString(m) }
func (*CreateClusterMetadata) ProtoMessage() {}
func (m *CreateClusterMetadata) GetOriginalRequest() *CreateClusterRequest {
if m != nil {
return m.OriginalRequest
}
return nil
}
// Metadata type for the operation returned by
// BigtableClusterService.UpdateCluster.
type UpdateClusterMetadata struct {
// The request which prompted the creation of this operation.
OriginalRequest *google_bigtable_admin_cluster_v11.Cluster `protobuf:"bytes,1,opt,name=original_request" json:"original_request,omitempty"`
}
func (m *UpdateClusterMetadata) Reset() { *m = UpdateClusterMetadata{} }
func (m *UpdateClusterMetadata) String() string { return proto.CompactTextString(m) }
func (*UpdateClusterMetadata) ProtoMessage() {}
func (m *UpdateClusterMetadata) GetOriginalRequest() *google_bigtable_admin_cluster_v11.Cluster {
if m != nil {
return m.OriginalRequest
}
return nil
}
// Request message for BigtableClusterService.DeleteCluster.
type DeleteClusterRequest struct {
// The unique name of the cluster to be deleted.
// Values are of the form projects//zones//clusters/
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}
func (m *DeleteClusterRequest) Reset() { *m = DeleteClusterRequest{} }
func (m *DeleteClusterRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteClusterRequest) ProtoMessage() {}
// Request message for BigtableClusterService.UndeleteCluster.
type UndeleteClusterRequest struct {
// The unique name of the cluster to be un-deleted.
// Values are of the form projects//zones//clusters/
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}
func (m *UndeleteClusterRequest) Reset() { *m = UndeleteClusterRequest{} }
func (m *UndeleteClusterRequest) String() string { return proto.CompactTextString(m) }
func (*UndeleteClusterRequest) ProtoMessage() {}
// Metadata type for the operation returned by
// BigtableClusterService.UndeleteCluster.
type UndeleteClusterMetadata struct {
}
func (m *UndeleteClusterMetadata) Reset() { *m = UndeleteClusterMetadata{} }
func (m *UndeleteClusterMetadata) String() string { return proto.CompactTextString(m) }
func (*UndeleteClusterMetadata) ProtoMessage() {}
func init() {
}
================================================
FILE: vendor/google.golang.org/cloud/bigtable/internal/cluster_service_proto/bigtable_cluster_service_messages.proto
================================================
// Copyright (c) 2015, Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
syntax = "proto3";
package google.bigtable.admin.cluster.v1;
import "google.golang.org/cloud/bigtable/internal/cluster_data_proto/bigtable_cluster_data.proto";
option java_multiple_files = true;
option java_outer_classname = "BigtableClusterServiceMessagesProto";
option java_package = "com.google.bigtable.admin.cluster.v1";
// Request message for BigtableClusterService.ListZones.
message ListZonesRequest {
// The unique name of the project for which a list of supported zones is
// requested.
// Values are of the form projects/
string name = 1;
}
// Response message for BigtableClusterService.ListZones.
message ListZonesResponse {
// The list of requested zones.
repeated Zone zones = 1;
}
// Request message for BigtableClusterService.GetCluster.
message GetClusterRequest {
// The unique name of the requested cluster.
// Values are of the form projects//zones//clusters/
string name = 1;
}
// Request message for BigtableClusterService.ListClusters.
message ListClustersRequest {
// The unique name of the project for which a list of clusters is requested.
// Values are of the form projects/
string name = 1;
}
// Response message for BigtableClusterService.ListClusters.
message ListClustersResponse {
// The list of requested Clusters.
repeated Cluster clusters = 1;
// The zones for which clusters could not be retrieved.
repeated Zone failed_zones = 2;
}
// Request message for BigtableClusterService.CreateCluster.
message CreateClusterRequest {
// The unique name of the zone in which to create the cluster.
// Values are of the form projects//zones/
string name = 1;
// The id to be used when referring to the new cluster within its zone,
// e.g. just the "test-cluster" section of the full name
// "projects//zones//clusters/test-cluster".
string cluster_id = 2;
// The cluster to create.
// The "name", "delete_time", and "current_operation" fields must be left
// blank.
Cluster cluster = 3;
}
// Metadata type for the operation returned by
// BigtableClusterService.CreateCluster.
message CreateClusterMetadata {
// The request which prompted the creation of this operation.
CreateClusterRequest original_request = 1;
// The time at which original_request was received.
// The time at which this operation failed or was completed successfully.
}
// Metadata type for the operation returned by
// BigtableClusterService.UpdateCluster.
message UpdateClusterMetadata {
// The request which prompted the creation of this operation.
Cluster original_request = 1;
// The time at which original_request was received.
// The time at which this operation was cancelled. If set, this operation is
// in the process of undoing itself (which is guaranteed to succeed) and
// cannot be cancelled again.
// The time at which this operation failed or was completed successfully.
}
// Request message for BigtableClusterService.DeleteCluster.
message DeleteClusterRequest {
// The unique name of the cluster to be deleted.
// Values are of the form projects//zones//clusters/
string name = 1;
}
// Request message for BigtableClusterService.UndeleteCluster.
message UndeleteClusterRequest {
// The unique name of the cluster to be un-deleted.
// Values are of the form projects//zones//clusters/
string name = 1;
}
// Metadata type for the operation returned by
// BigtableClusterService.UndeleteCluster.
message UndeleteClusterMetadata {
// The time at which the original request was received.
// The time at which this operation failed or was completed successfully.
}
================================================
FILE: vendor/google.golang.org/cloud/bigtable/internal/data_proto/bigtable_data.pb.go
================================================
// Code generated by protoc-gen-go.
// source: google.golang.org/cloud/bigtable/internal/data_proto/bigtable_data.proto
// DO NOT EDIT!
/*
Package google_bigtable_v1 is a generated protocol buffer package.
It is generated from these files:
google.golang.org/cloud/bigtable/internal/data_proto/bigtable_data.proto
It has these top-level messages:
Row
Family
Column
Cell
RowRange
ColumnRange
TimestampRange
ValueRange
RowFilter
Mutation
ReadModifyWriteRule
*/
package google_bigtable_v1
import proto "github.com/golang/protobuf/proto"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
// Specifies the complete (requested) contents of a single row of a table.
// Rows which exceed 256MiB in size cannot be read in full.
type Row struct {
// The unique key which identifies this row within its table. This is the same
// key that's used to identify the row in, for example, a MutateRowRequest.
// May contain any non-empty byte string up to 16KiB in length.
Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
// May be empty, but only if the entire row is empty.
// The mutual ordering of column families is not specified.
Families []*Family `protobuf:"bytes,2,rep,name=families" json:"families,omitempty"`
}
func (m *Row) Reset() { *m = Row{} }
func (m *Row) String() string { return proto.CompactTextString(m) }
func (*Row) ProtoMessage() {}
func (m *Row) GetFamilies() []*Family {
if m != nil {
return m.Families
}
return nil
}
// Specifies (some of) the contents of a single row/column family of a table.
type Family struct {
// The unique key which identifies this family within its row. This is the
// same key that's used to identify the family in, for example, a RowFilter
// which sets its "family_name_regex_filter" field.
// Must match [-_.a-zA-Z0-9]+, except that AggregatingRowProcessors may
// produce cells in a sentinel family with an empty name.
// Must be no greater than 64 characters in length.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// Must not be empty. Sorted in order of increasing "qualifier".
Columns []*Column `protobuf:"bytes,2,rep,name=columns" json:"columns,omitempty"`
}
func (m *Family) Reset() { *m = Family{} }
func (m *Family) String() string { return proto.CompactTextString(m) }
func (*Family) ProtoMessage() {}
func (m *Family) GetColumns() []*Column {
if m != nil {
return m.Columns
}
return nil
}
// Specifies (some of) the contents of a single row/column of a table.
type Column struct {
// The unique key which identifies this column within its family. This is the
// same key that's used to identify the column in, for example, a RowFilter
// which sets its "column_qualifier_regex_filter" field.
// May contain any byte string, including the empty string, up to 16kiB in
// length.
Qualifier []byte `protobuf:"bytes,1,opt,name=qualifier,proto3" json:"qualifier,omitempty"`
// Must not be empty. Sorted in order of decreasing "timestamp_micros".
Cells []*Cell `protobuf:"bytes,2,rep,name=cells" json:"cells,omitempty"`
}
func (m *Column) Reset() { *m = Column{} }
func (m *Column) String() string { return proto.CompactTextString(m) }
func (*Column) ProtoMessage() {}
func (m *Column) GetCells() []*Cell {
if m != nil {
return m.Cells
}
return nil
}
// Specifies (some of) the contents of a single row/column/timestamp of a table.
type Cell struct {
// The cell's stored timestamp, which also uniquely identifies it within
// its column.
// Values are always expressed in microseconds, but individual tables may set
// a coarser "granularity" to further restrict the allowed values. For
// example, a table which specifies millisecond granularity will only allow
// values of "timestamp_micros" which are multiples of 1000.
TimestampMicros int64 `protobuf:"varint,1,opt,name=timestamp_micros" json:"timestamp_micros,omitempty"`
// The value stored in the cell.
// May contain any byte string, including the empty string, up to 100MiB in
// length.
Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
}
func (m *Cell) Reset() { *m = Cell{} }
func (m *Cell) String() string { return proto.CompactTextString(m) }
func (*Cell) ProtoMessage() {}
// Specifies a contiguous range of rows.
type RowRange struct {
// Inclusive lower bound. If left empty, interpreted as the empty string.
StartKey []byte `protobuf:"bytes,2,opt,name=start_key,proto3" json:"start_key,omitempty"`
// Exclusive upper bound. If left empty, interpreted as infinity.
EndKey []byte `protobuf:"bytes,3,opt,name=end_key,proto3" json:"end_key,omitempty"`
}
func (m *RowRange) Reset() { *m = RowRange{} }
func (m *RowRange) String() string { return proto.CompactTextString(m) }
func (*RowRange) ProtoMessage() {}
// Specifies a contiguous range of columns within a single column family.
// The range spans from : to
// :, where both bounds can be either inclusive or
// exclusive.
type ColumnRange struct {
// The name of the column family within which this range falls.
FamilyName string `protobuf:"bytes,1,opt,name=family_name" json:"family_name,omitempty"`
// Used when giving an inclusive lower bound for the range.
StartQualifierInclusive []byte `protobuf:"bytes,2,opt,name=start_qualifier_inclusive,proto3" json:"start_qualifier_inclusive,omitempty"`
// Used when giving an exclusive lower bound for the range.
StartQualifierExclusive []byte `protobuf:"bytes,3,opt,name=start_qualifier_exclusive,proto3" json:"start_qualifier_exclusive,omitempty"`
// Used when giving an inclusive upper bound for the range.
EndQualifierInclusive []byte `protobuf:"bytes,4,opt,name=end_qualifier_inclusive,proto3" json:"end_qualifier_inclusive,omitempty"`
// Used when giving an exclusive upper bound for the range.
EndQualifierExclusive []byte `protobuf:"bytes,5,opt,name=end_qualifier_exclusive,proto3" json:"end_qualifier_exclusive,omitempty"`
}
func (m *ColumnRange) Reset() { *m = ColumnRange{} }
func (m *ColumnRange) String() string { return proto.CompactTextString(m) }
func (*ColumnRange) ProtoMessage() {}
// Specified a contiguous range of microsecond timestamps.
type TimestampRange struct {
// Inclusive lower bound. If left empty, interpreted as 0.
StartTimestampMicros int64 `protobuf:"varint,1,opt,name=start_timestamp_micros" json:"start_timestamp_micros,omitempty"`
// Exclusive upper bound. If left empty, interpreted as infinity.
EndTimestampMicros int64 `protobuf:"varint,2,opt,name=end_timestamp_micros" json:"end_timestamp_micros,omitempty"`
}
func (m *TimestampRange) Reset() { *m = TimestampRange{} }
func (m *TimestampRange) String() string { return proto.CompactTextString(m) }
func (*TimestampRange) ProtoMessage() {}
// Specifies a contiguous range of raw byte values.
type ValueRange struct {
// Used when giving an inclusive lower bound for the range.
StartValueInclusive []byte `protobuf:"bytes,1,opt,name=start_value_inclusive,proto3" json:"start_value_inclusive,omitempty"`
// Used when giving an exclusive lower bound for the range.
StartValueExclusive []byte `protobuf:"bytes,2,opt,name=start_value_exclusive,proto3" json:"start_value_exclusive,omitempty"`
// Used when giving an inclusive upper bound for the range.
EndValueInclusive []byte `protobuf:"bytes,3,opt,name=end_value_inclusive,proto3" json:"end_value_inclusive,omitempty"`
// Used when giving an exclusive upper bound for the range.
EndValueExclusive []byte `protobuf:"bytes,4,opt,name=end_value_exclusive,proto3" json:"end_value_exclusive,omitempty"`
}
func (m *ValueRange) Reset() { *m = ValueRange{} }
func (m *ValueRange) String() string { return proto.CompactTextString(m) }
func (*ValueRange) ProtoMessage() {}
// Takes a row as input and produces an alternate view of the row based on
// specified rules. For example, a RowFilter might trim down a row to include
// just the cells from columns matching a given regular expression, or might
// return all the cells of a row but not their values. More complicated filters
// can be composed out of these components to express requests such as, "within
// every column of a particular family, give just the two most recent cells
// which are older than timestamp X."
//
// There are two broad categories of RowFilters (true filters and transformers),
// as well as two ways to compose simple filters into more complex ones
// (chains and interleaves). They work as follows:
//
// * True filters alter the input row by excluding some of its cells wholesale
// from the output row. An example of a true filter is the "value_regex_filter",
// which excludes cells whose values don't match the specified pattern. All
// regex true filters use RE2 syntax (https://github.com/google/re2/wiki/Syntax)
// in raw byte mode (RE2::Latin1), and are evaluated as full matches. An
// important point to keep in mind is that RE2(.) is equivalent by default to
// RE2([^\n]), meaning that it does not match newlines. When attempting to match
// an arbitrary byte, you should therefore use the escape sequence '\C', which
// may need to be further escaped as '\\C' in your client language.
//
// * Transformers alter the input row by changing the values of some of its
// cells in the output, without excluding them completely. Currently, the only
// supported transformer is the "strip_value_transformer", which replaces every
// cell's value with the empty string.
//
// * Chains and interleaves are described in more detail in the
// RowFilter.Chain and RowFilter.Interleave documentation.
//
// The total serialized size of a RowFilter message must not
// exceed 4096 bytes, and RowFilters may not be nested within each other
// (in Chains or Interleaves) to a depth of more than 20.
type RowFilter struct {
// Applies several RowFilters to the data in sequence, progressively
// narrowing the results.
Chain *RowFilter_Chain `protobuf:"bytes,1,opt,name=chain" json:"chain,omitempty"`
// Applies several RowFilters to the data in parallel and combines the
// results.
Interleave *RowFilter_Interleave `protobuf:"bytes,2,opt,name=interleave" json:"interleave,omitempty"`
// Applies one of two possible RowFilters to the data based on the output of
// a predicate RowFilter.
Condition *RowFilter_Condition `protobuf:"bytes,3,opt,name=condition" json:"condition,omitempty"`
// Matches only cells from rows whose keys satisfy the given RE2 regex. In
// other words, passes through the entire row when the key matches, and
// otherwise produces an empty row.
// Note that, since row keys can contain arbitrary bytes, the '\C' escape
// sequence must be used if a true wildcard is desired. The '.' character
// will not match the new line character '\n', which may be present in a
// binary key.
RowKeyRegexFilter []byte `protobuf:"bytes,4,opt,name=row_key_regex_filter,proto3" json:"row_key_regex_filter,omitempty"`
// Matches all cells from a row with probability p, and matches no cells
// from the row with probability 1-p.
RowSampleFilter float64 `protobuf:"fixed64,14,opt,name=row_sample_filter" json:"row_sample_filter,omitempty"`
// Matches only cells from columns whose families satisfy the given RE2
// regex. For technical reasons, the regex must not contain the ':'
// character, even if it is not being used as a literal.
// Note that, since column families cannot contain the new line character
// '\n', it is sufficient to use '.' as a full wildcard when matching
// column family names.
FamilyNameRegexFilter string `protobuf:"bytes,5,opt,name=family_name_regex_filter" json:"family_name_regex_filter,omitempty"`
// Matches only cells from columns whose qualifiers satisfy the given RE2
// regex.
// Note that, since column qualifiers can contain arbitrary bytes, the '\C'
// escape sequence must be used if a true wildcard is desired. The '.'
// character will not match the new line character '\n', which may be
// present in a binary qualifier.
ColumnQualifierRegexFilter []byte `protobuf:"bytes,6,opt,name=column_qualifier_regex_filter,proto3" json:"column_qualifier_regex_filter,omitempty"`
// Matches only cells from columns within the given range.
ColumnRangeFilter *ColumnRange `protobuf:"bytes,7,opt,name=column_range_filter" json:"column_range_filter,omitempty"`
// Matches only cells with timestamps within the given range.
TimestampRangeFilter *TimestampRange `protobuf:"bytes,8,opt,name=timestamp_range_filter" json:"timestamp_range_filter,omitempty"`
// Matches only cells with values that satisfy the given regular expression.
// Note that, since cell values can contain arbitrary bytes, the '\C' escape
// sequence must be used if a true wildcard is desired. The '.' character
// will not match the new line character '\n', which may be present in a
// binary value.
ValueRegexFilter []byte `protobuf:"bytes,9,opt,name=value_regex_filter,proto3" json:"value_regex_filter,omitempty"`
// Matches only cells with values that fall within the given range.
ValueRangeFilter *ValueRange `protobuf:"bytes,15,opt,name=value_range_filter" json:"value_range_filter,omitempty"`
// Skips the first N cells of each row, matching all subsequent cells.
CellsPerRowOffsetFilter int32 `protobuf:"varint,10,opt,name=cells_per_row_offset_filter" json:"cells_per_row_offset_filter,omitempty"`
// Matches only the first N cells of each row.
CellsPerRowLimitFilter int32 `protobuf:"varint,11,opt,name=cells_per_row_limit_filter" json:"cells_per_row_limit_filter,omitempty"`
// Matches only the most recent N cells within each column. For example,
// if N=2, this filter would match column "foo:bar" at timestamps 10 and 9,
// skip all earlier cells in "foo:bar", and then begin matching again in
// column "foo:bar2".
CellsPerColumnLimitFilter int32 `protobuf:"varint,12,opt,name=cells_per_column_limit_filter" json:"cells_per_column_limit_filter,omitempty"`
// Replaces each cell's value with the empty string.
StripValueTransformer bool `protobuf:"varint,13,opt,name=strip_value_transformer" json:"strip_value_transformer,omitempty"`
}
func (m *RowFilter) Reset() { *m = RowFilter{} }
func (m *RowFilter) String() string { return proto.CompactTextString(m) }
func (*RowFilter) ProtoMessage() {}
func (m *RowFilter) GetChain() *RowFilter_Chain {
if m != nil {
return m.Chain
}
return nil
}
func (m *RowFilter) GetInterleave() *RowFilter_Interleave {
if m != nil {
return m.Interleave
}
return nil
}
func (m *RowFilter) GetCondition() *RowFilter_Condition {
if m != nil {
return m.Condition
}
return nil
}
func (m *RowFilter) GetColumnRangeFilter() *ColumnRange {
if m != nil {
return m.ColumnRangeFilter
}
return nil
}
func (m *RowFilter) GetTimestampRangeFilter() *TimestampRange {
if m != nil {
return m.TimestampRangeFilter
}
return nil
}
func (m *RowFilter) GetValueRangeFilter() *ValueRange {
if m != nil {
return m.ValueRangeFilter
}
return nil
}
// A RowFilter which sends rows through several RowFilters in sequence.
type RowFilter_Chain struct {
// The elements of "filters" are chained together to process the input row:
// in row -> f(0) -> intermediate row -> f(1) -> ... -> f(N) -> out row
// The full chain is executed atomically.
Filters []*RowFilter `protobuf:"bytes,1,rep,name=filters" json:"filters,omitempty"`
}
func (m *RowFilter_Chain) Reset() { *m = RowFilter_Chain{} }
func (m *RowFilter_Chain) String() string { return proto.CompactTextString(m) }
func (*RowFilter_Chain) ProtoMessage() {}
func (m *RowFilter_Chain) GetFilters() []*RowFilter {
if m != nil {
return m.Filters
}
return nil
}
// A RowFilter which sends each row to each of several component
// RowFilters and interleaves the results.
type RowFilter_Interleave struct {
// The elements of "filters" all process a copy of the input row, and the
// results are pooled, sorted, and combined into a single output row.
// If multiple cells are produced with the same column and timestamp,
// they will all appear in the output row in an unspecified mutual order.
// Consider the following example, with three filters:
//
// input row
// |
// -----------------------------------------------------
// | | |
// f(0) f(1) f(2)
// | | |
// 1: foo,bar,10,x foo,bar,10,z far,bar,7,a
// 2: foo,blah,11,z far,blah,5,x far,blah,5,x
// | | |
// -----------------------------------------------------
// |
// 1: foo,bar,10,z // could have switched with #2
// 2: foo,bar,10,x // could have switched with #1
// 3: foo,blah,11,z
// 4: far,bar,7,a
// 5: far,blah,5,x // identical to #6
// 6: far,blah,5,x // identical to #5
// All interleaved filters are executed atomically.
Filters []*RowFilter `protobuf:"bytes,1,rep,name=filters" json:"filters,omitempty"`
}
func (m *RowFilter_Interleave) Reset() { *m = RowFilter_Interleave{} }
func (m *RowFilter_Interleave) String() string { return proto.CompactTextString(m) }
func (*RowFilter_Interleave) ProtoMessage() {}
func (m *RowFilter_Interleave) GetFilters() []*RowFilter {
if m != nil {
return m.Filters
}
return nil
}
// A RowFilter which evaluates one of two possible RowFilters, depending on
// whether or not a predicate RowFilter outputs any cells from the input row.
//
// IMPORTANT NOTE: The predicate filter does not execute atomically with the
// true and false filters, which may lead to inconsistent or unexpected
// results. Additionally, Condition filters have poor performance, especially
// when filters are set for the false condition.
type RowFilter_Condition struct {
// If "predicate_filter" outputs any cells, then "true_filter" will be
// evaluated on the input row. Otherwise, "false_filter" will be evaluated.
PredicateFilter *RowFilter `protobuf:"bytes,1,opt,name=predicate_filter" json:"predicate_filter,omitempty"`
// The filter to apply to the input row if "predicate_filter" returns any
// results. If not provided, no results will be returned in the true case.
TrueFilter *RowFilter `protobuf:"bytes,2,opt,name=true_filter" json:"true_filter,omitempty"`
// The filter to apply to the input row if "predicate_filter" does not
// return any results. If not provided, no results will be returned in the
// false case.
FalseFilter *RowFilter `protobuf:"bytes,3,opt,name=false_filter" json:"false_filter,omitempty"`
}
func (m *RowFilter_Condition) Reset() { *m = RowFilter_Condition{} }
func (m *RowFilter_Condition) String() string { return proto.CompactTextString(m) }
func (*RowFilter_Condition) ProtoMessage() {}
func (m *RowFilter_Condition) GetPredicateFilter() *RowFilter {
if m != nil {
return m.PredicateFilter
}
return nil
}
func (m *RowFilter_Condition) GetTrueFilter() *RowFilter {
if m != nil {
return m.TrueFilter
}
return nil
}
func (m *RowFilter_Condition) GetFalseFilter() *RowFilter {
if m != nil {
return m.FalseFilter
}
return nil
}
// Specifies a particular change to be made to the contents of a row.
type Mutation struct {
// Set a cell's value.
SetCell *Mutation_SetCell `protobuf:"bytes,1,opt,name=set_cell" json:"set_cell,omitempty"`
// Deletes cells from a column.
DeleteFromColumn *Mutation_DeleteFromColumn `protobuf:"bytes,2,opt,name=delete_from_column" json:"delete_from_column,omitempty"`
// Deletes cells from a column family.
DeleteFromFamily *Mutation_DeleteFromFamily `protobuf:"bytes,3,opt,name=delete_from_family" json:"delete_from_family,omitempty"`
// Deletes cells from the entire row.
DeleteFromRow *Mutation_DeleteFromRow `protobuf:"bytes,4,opt,name=delete_from_row" json:"delete_from_row,omitempty"`
}
func (m *Mutation) Reset() { *m = Mutation{} }
func (m *Mutation) String() string { return proto.CompactTextString(m) }
func (*Mutation) ProtoMessage() {}
func (m *Mutation) GetSetCell() *Mutation_SetCell {
if m != nil {
return m.SetCell
}
return nil
}
func (m *Mutation) GetDeleteFromColumn() *Mutation_DeleteFromColumn {
if m != nil {
return m.DeleteFromColumn
}
return nil
}
func (m *Mutation) GetDeleteFromFamily() *Mutation_DeleteFromFamily {
if m != nil {
return m.DeleteFromFamily
}
return nil
}
func (m *Mutation) GetDeleteFromRow() *Mutation_DeleteFromRow {
if m != nil {
return m.DeleteFromRow
}
return nil
}
// A Mutation which sets the value of the specified cell.
type Mutation_SetCell struct {
// The name of the family into which new data should be written.
// Must match [-_.a-zA-Z0-9]+
FamilyName string `protobuf:"bytes,1,opt,name=family_name" json:"family_name,omitempty"`
// The qualifier of the column into which new data should be written.
// Can be any byte string, including the empty string.
ColumnQualifier []byte `protobuf:"bytes,2,opt,name=column_qualifier,proto3" json:"column_qualifier,omitempty"`
// The timestamp of the cell into which new data should be written.
// Use -1 for current Bigtable server time.
// Otherwise, the client should set this value itself, noting that the
// default value is a timestamp of zero if the field is left unspecified.
// Values must match the "granularity" of the table (e.g. micros, millis).
TimestampMicros int64 `protobuf:"varint,3,opt,name=timestamp_micros" json:"timestamp_micros,omitempty"`
// The value to be written into the specified cell.
Value []byte `protobuf:"bytes,4,opt,name=value,proto3" json:"value,omitempty"`
}
func (m *Mutation_SetCell) Reset() { *m = Mutation_SetCell{} }
func (m *Mutation_SetCell) String() string { return proto.CompactTextString(m) }
func (*Mutation_SetCell) ProtoMessage() {}
// A Mutation which deletes cells from the specified column, optionally
// restricting the deletions to a given timestamp range.
type Mutation_DeleteFromColumn struct {
// The name of the family from which cells should be deleted.
// Must match [-_.a-zA-Z0-9]+
FamilyName string `protobuf:"bytes,1,opt,name=family_name" json:"family_name,omitempty"`
// The qualifier of the column from which cells should be deleted.
// Can be any byte string, including the empty string.
ColumnQualifier []byte `protobuf:"bytes,2,opt,name=column_qualifier,proto3" json:"column_qualifier,omitempty"`
// The range of timestamps within which cells should be deleted.
TimeRange *TimestampRange `protobuf:"bytes,3,opt,name=time_range" json:"time_range,omitempty"`
}
func (m *Mutation_DeleteFromColumn) Reset() { *m = Mutation_DeleteFromColumn{} }
func (m *Mutation_DeleteFromColumn) String() string { return proto.CompactTextString(m) }
func (*Mutation_DeleteFromColumn) ProtoMessage() {}
func (m *Mutation_DeleteFromColumn) GetTimeRange() *TimestampRange {
if m != nil {
return m.TimeRange
}
return nil
}
// A Mutation which deletes all cells from the specified column family.
type Mutation_DeleteFromFamily struct {
// The name of the family from which cells should be deleted.
// Must match [-_.a-zA-Z0-9]+
FamilyName string `protobuf:"bytes,1,opt,name=family_name" json:"family_name,omitempty"`
}
func (m *Mutation_DeleteFromFamily) Reset() { *m = Mutation_DeleteFromFamily{} }
func (m *Mutation_DeleteFromFamily) String() string { return proto.CompactTextString(m) }
func (*Mutation_DeleteFromFamily) ProtoMessage() {}
// A Mutation which deletes all cells from the containing row.
type Mutation_DeleteFromRow struct {
}
func (m *Mutation_DeleteFromRow) Reset() { *m = Mutation_DeleteFromRow{} }
func (m *Mutation_DeleteFromRow) String() string { return proto.CompactTextString(m) }
func (*Mutation_DeleteFromRow) ProtoMessage() {}
// Specifies an atomic read/modify/write operation on the latest value of the
// specified column.
type ReadModifyWriteRule struct {
// The name of the family to which the read/modify/write should be applied.
// Must match [-_.a-zA-Z0-9]+
FamilyName string `protobuf:"bytes,1,opt,name=family_name" json:"family_name,omitempty"`
// The qualifier of the column to which the read/modify/write should be
// applied.
// Can be any byte string, including the empty string.
ColumnQualifier []byte `protobuf:"bytes,2,opt,name=column_qualifier,proto3" json:"column_qualifier,omitempty"`
// Rule specifying that "append_value" be appended to the existing value.
// If the targeted cell is unset, it will be treated as containing the
// empty string.
AppendValue []byte `protobuf:"bytes,3,opt,name=append_value,proto3" json:"append_value,omitempty"`
// Rule specifying that "increment_amount" be added to the existing value.
// If the targeted cell is unset, it will be treated as containing a zero.
// Otherwise, the targeted cell must contain an 8-byte value (interpreted
// as a 64-bit big-endian signed integer), or the entire request will fail.
IncrementAmount int64 `protobuf:"varint,4,opt,name=increment_amount" json:"increment_amount,omitempty"`
}
func (m *ReadModifyWriteRule) Reset() { *m = ReadModifyWriteRule{} }
func (m *ReadModifyWriteRule) String() string { return proto.CompactTextString(m) }
func (*ReadModifyWriteRule) ProtoMessage() {}
func init() {
}
================================================
FILE: vendor/google.golang.org/cloud/bigtable/internal/data_proto/bigtable_data.proto
================================================
// Copyright (c) 2015, Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
syntax = "proto3";
package google.bigtable.v1;
option java_multiple_files = true;
option java_outer_classname = "BigtableDataProto";
option java_package = "com.google.bigtable.v1";
// Specifies the complete (requested) contents of a single row of a table.
// Rows which exceed 256MiB in size cannot be read in full.
message Row {
// The unique key which identifies this row within its table. This is the same
// key that's used to identify the row in, for example, a MutateRowRequest.
// May contain any non-empty byte string up to 16KiB in length.
bytes key = 1;
// May be empty, but only if the entire row is empty.
// The mutual ordering of column families is not specified.
repeated Family families = 2;
}
// Specifies (some of) the contents of a single row/column family of a table.
message Family {
// The unique key which identifies this family within its row. This is the
// same key that's used to identify the family in, for example, a RowFilter
// which sets its "family_name_regex_filter" field.
// Must match [-_.a-zA-Z0-9]+, except that AggregatingRowProcessors may
// produce cells in a sentinel family with an empty name.
// Must be no greater than 64 characters in length.
string name = 1;
// Must not be empty. Sorted in order of increasing "qualifier".
repeated Column columns = 2;
}
// Specifies (some of) the contents of a single row/column of a table.
message Column {
// The unique key which identifies this column within its family. This is the
// same key that's used to identify the column in, for example, a RowFilter
// which sets its "column_qualifier_regex_filter" field.
// May contain any byte string, including the empty string, up to 16kiB in
// length.
bytes qualifier = 1;
// Must not be empty. Sorted in order of decreasing "timestamp_micros".
repeated Cell cells = 2;
}
// Specifies (some of) the contents of a single row/column/timestamp of a table.
message Cell {
// The cell's stored timestamp, which also uniquely identifies it within
// its column.
// Values are always expressed in microseconds, but individual tables may set
// a coarser "granularity" to further restrict the allowed values. For
// example, a table which specifies millisecond granularity will only allow
// values of "timestamp_micros" which are multiples of 1000.
int64 timestamp_micros = 1;
// The value stored in the cell.
// May contain any byte string, including the empty string, up to 100MiB in
// length.
bytes value = 2;
}
// Specifies a contiguous range of rows.
message RowRange {
// Inclusive lower bound. If left empty, interpreted as the empty string.
bytes start_key = 2;
// Exclusive upper bound. If left empty, interpreted as infinity.
bytes end_key = 3;
}
// Specifies a contiguous range of columns within a single column family.
// The range spans from : to
// :, where both bounds can be either inclusive or
// exclusive.
message ColumnRange {
// The name of the column family within which this range falls.
string family_name = 1;
oneof start_qualifier {
// Used when giving an inclusive lower bound for the range.
bytes start_qualifier_inclusive = 2;
// Used when giving an exclusive lower bound for the range.
bytes start_qualifier_exclusive = 3;
}
oneof end_qualifier {
// Used when giving an inclusive upper bound for the range.
bytes end_qualifier_inclusive = 4;
// Used when giving an exclusive upper bound for the range.
bytes end_qualifier_exclusive = 5;
}
}
// Specified a contiguous range of microsecond timestamps.
message TimestampRange {
// Inclusive lower bound. If left empty, interpreted as 0.
int64 start_timestamp_micros = 1;
// Exclusive upper bound. If left empty, interpreted as infinity.
int64 end_timestamp_micros = 2;
}
// Specifies a contiguous range of raw byte values.
message ValueRange {
oneof start_value {
// Used when giving an inclusive lower bound for the range.
bytes start_value_inclusive = 1;
// Used when giving an exclusive lower bound for the range.
bytes start_value_exclusive = 2;
}
oneof end_value {
// Used when giving an inclusive upper bound for the range.
bytes end_value_inclusive = 3;
// Used when giving an exclusive upper bound for the range.
bytes end_value_exclusive = 4;
}
}
// Takes a row as input and produces an alternate view of the row based on
// specified rules. For example, a RowFilter might trim down a row to include
// just the cells from columns matching a given regular expression, or might
// return all the cells of a row but not their values. More complicated filters
// can be composed out of these components to express requests such as, "within
// every column of a particular family, give just the two most recent cells
// which are older than timestamp X."
//
// There are two broad categories of RowFilters (true filters and transformers),
// as well as two ways to compose simple filters into more complex ones
// (chains and interleaves). They work as follows:
//
// * True filters alter the input row by excluding some of its cells wholesale
// from the output row. An example of a true filter is the "value_regex_filter",
// which excludes cells whose values don't match the specified pattern. All
// regex true filters use RE2 syntax (https://github.com/google/re2/wiki/Syntax)
// in raw byte mode (RE2::Latin1), and are evaluated as full matches. An
// important point to keep in mind is that RE2(.) is equivalent by default to
// RE2([^\n]), meaning that it does not match newlines. When attempting to match
// an arbitrary byte, you should therefore use the escape sequence '\C', which
// may need to be further escaped as '\\C' in your client language.
//
// * Transformers alter the input row by changing the values of some of its
// cells in the output, without excluding them completely. Currently, the only
// supported transformer is the "strip_value_transformer", which replaces every
// cell's value with the empty string.
//
// * Chains and interleaves are described in more detail in the
// RowFilter.Chain and RowFilter.Interleave documentation.
//
// The total serialized size of a RowFilter message must not
// exceed 4096 bytes, and RowFilters may not be nested within each other
// (in Chains or Interleaves) to a depth of more than 20.
message RowFilter {
// A RowFilter which sends rows through several RowFilters in sequence.
message Chain {
// The elements of "filters" are chained together to process the input row:
// in row -> f(0) -> intermediate row -> f(1) -> ... -> f(N) -> out row
// The full chain is executed atomically.
repeated RowFilter filters = 1;
}
// A RowFilter which sends each row to each of several component
// RowFilters and interleaves the results.
message Interleave {
// The elements of "filters" all process a copy of the input row, and the
// results are pooled, sorted, and combined into a single output row.
// If multiple cells are produced with the same column and timestamp,
// they will all appear in the output row in an unspecified mutual order.
// Consider the following example, with three filters:
//
// input row
// |
// -----------------------------------------------------
// | | |
// f(0) f(1) f(2)
// | | |
// 1: foo,bar,10,x foo,bar,10,z far,bar,7,a
// 2: foo,blah,11,z far,blah,5,x far,blah,5,x
// | | |
// -----------------------------------------------------
// |
// 1: foo,bar,10,z // could have switched with #2
// 2: foo,bar,10,x // could have switched with #1
// 3: foo,blah,11,z
// 4: far,bar,7,a
// 5: far,blah,5,x // identical to #6
// 6: far,blah,5,x // identical to #5
// All interleaved filters are executed atomically.
repeated RowFilter filters = 1;
}
// A RowFilter which evaluates one of two possible RowFilters, depending on
// whether or not a predicate RowFilter outputs any cells from the input row.
//
// IMPORTANT NOTE: The predicate filter does not execute atomically with the
// true and false filters, which may lead to inconsistent or unexpected
// results. Additionally, Condition filters have poor performance, especially
// when filters are set for the false condition.
message Condition {
// If "predicate_filter" outputs any cells, then "true_filter" will be
// evaluated on the input row. Otherwise, "false_filter" will be evaluated.
RowFilter predicate_filter = 1;
// The filter to apply to the input row if "predicate_filter" returns any
// results. If not provided, no results will be returned in the true case.
RowFilter true_filter = 2;
// The filter to apply to the input row if "predicate_filter" does not
// return any results. If not provided, no results will be returned in the
// false case.
RowFilter false_filter = 3;
}
oneof filter {
// Applies several RowFilters to the data in sequence, progressively
// narrowing the results.
Chain chain = 1;
// Applies several RowFilters to the data in parallel and combines the
// results.
Interleave interleave = 2;
// Applies one of two possible RowFilters to the data based on the output of
// a predicate RowFilter.
Condition condition = 3;
// Matches only cells from rows whose keys satisfy the given RE2 regex. In
// other words, passes through the entire row when the key matches, and
// otherwise produces an empty row.
// Note that, since row keys can contain arbitrary bytes, the '\C' escape
// sequence must be used if a true wildcard is desired. The '.' character
// will not match the new line character '\n', which may be present in a
// binary key.
bytes row_key_regex_filter = 4;
// Matches all cells from a row with probability p, and matches no cells
// from the row with probability 1-p.
double row_sample_filter = 14;
// Matches only cells from columns whose families satisfy the given RE2
// regex. For technical reasons, the regex must not contain the ':'
// character, even if it is not being used as a literal.
// Note that, since column families cannot contain the new line character
// '\n', it is sufficient to use '.' as a full wildcard when matching
// column family names.
string family_name_regex_filter = 5;
// Matches only cells from columns whose qualifiers satisfy the given RE2
// regex.
// Note that, since column qualifiers can contain arbitrary bytes, the '\C'
// escape sequence must be used if a true wildcard is desired. The '.'
// character will not match the new line character '\n', which may be
// present in a binary qualifier.
bytes column_qualifier_regex_filter = 6;
// Matches only cells from columns within the given range.
ColumnRange column_range_filter = 7;
// Matches only cells with timestamps within the given range.
TimestampRange timestamp_range_filter = 8;
// Matches only cells with values that satisfy the given regular expression.
// Note that, since cell values can contain arbitrary bytes, the '\C' escape
// sequence must be used if a true wildcard is desired. The '.' character
// will not match the new line character '\n', which may be present in a
// binary value.
bytes value_regex_filter = 9;
// Matches only cells with values that fall within the given range.
ValueRange value_range_filter = 15;
// Skips the first N cells of each row, matching all subsequent cells.
int32 cells_per_row_offset_filter = 10;
// Matches only the first N cells of each row.
int32 cells_per_row_limit_filter = 11;
// Matches only the most recent N cells within each column. For example,
// if N=2, this filter would match column "foo:bar" at timestamps 10 and 9,
// skip all earlier cells in "foo:bar", and then begin matching again in
// column "foo:bar2".
int32 cells_per_column_limit_filter = 12;
// Replaces each cell's value with the empty string.
bool strip_value_transformer = 13;
}
}
// Specifies a particular change to be made to the contents of a row.
message Mutation {
// A Mutation which sets the value of the specified cell.
message SetCell {
// The name of the family into which new data should be written.
// Must match [-_.a-zA-Z0-9]+
string family_name = 1;
// The qualifier of the column into which new data should be written.
// Can be any byte string, including the empty string.
bytes column_qualifier = 2;
// The timestamp of the cell into which new data should be written.
// Use -1 for current Bigtable server time.
// Otherwise, the client should set this value itself, noting that the
// default value is a timestamp of zero if the field is left unspecified.
// Values must match the "granularity" of the table (e.g. micros, millis).
int64 timestamp_micros = 3;
// The value to be written into the specified cell.
bytes value = 4;
}
// A Mutation which deletes cells from the specified column, optionally
// restricting the deletions to a given timestamp range.
message DeleteFromColumn {
// The name of the family from which cells should be deleted.
// Must match [-_.a-zA-Z0-9]+
string family_name = 1;
// The qualifier of the column from which cells should be deleted.
// Can be any byte string, including the empty string.
bytes column_qualifier = 2;
// The range of timestamps within which cells should be deleted.
TimestampRange time_range = 3;
}
// A Mutation which deletes all cells from the specified column family.
message DeleteFromFamily {
// The name of the family from which cells should be deleted.
// Must match [-_.a-zA-Z0-9]+
string family_name = 1;
}
// A Mutation which deletes all cells from the containing row.
message DeleteFromRow {
}
oneof mutation {
// Set a cell's value.
SetCell set_cell = 1;
// Deletes cells from a column.
DeleteFromColumn delete_from_column = 2;
// Deletes cells from a column family.
DeleteFromFamily delete_from_family = 3;
// Deletes cells from the entire row.
DeleteFromRow delete_from_row = 4;
}
}
// Specifies an atomic read/modify/write operation on the latest value of the
// specified column.
message ReadModifyWriteRule {
// The name of the family to which the read/modify/write should be applied.
// Must match [-_.a-zA-Z0-9]+
string family_name = 1;
// The qualifier of the column to which the read/modify/write should be
// applied.
// Can be any byte string, including the empty string.
bytes column_qualifier = 2;
oneof rule {
// Rule specifying that "append_value" be appended to the existing value.
// If the targeted cell is unset, it will be treated as containing the
// empty string.
bytes append_value = 3;
// Rule specifying that "increment_amount" be added to the existing value.
// If the targeted cell is unset, it will be treated as containing a zero.
// Otherwise, the targeted cell must contain an 8-byte value (interpreted
// as a 64-bit big-endian signed integer), or the entire request will fail.
int64 increment_amount = 4;
}
}
================================================
FILE: vendor/google.golang.org/cloud/bigtable/internal/empty/empty.pb.go
================================================
// Code generated by protoc-gen-go.
// source: google.golang.org/cloud/bigtable/internal/empty/empty.proto
// DO NOT EDIT!
/*
Package google_protobuf is a generated protocol buffer package.
It is generated from these files:
google.golang.org/cloud/bigtable/internal/empty/empty.proto
It has these top-level messages:
Empty
*/
package google_protobuf
import proto "github.com/golang/protobuf/proto"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
// A generic empty message that you can re-use to avoid defining duplicated
// empty messages in your APIs. A typical example is to use it as the request
// or the response type of an API method. For instance:
//
// service Foo {
// rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
// }
//
type Empty struct {
}
func (m *Empty) Reset() { *m = Empty{} }
func (m *Empty) String() string { return proto.CompactTextString(m) }
func (*Empty) ProtoMessage() {}
func init() {
}
================================================
FILE: vendor/google.golang.org/cloud/bigtable/internal/empty/empty.proto
================================================
// Copyright (c) 2015, Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
syntax = "proto3";
package google.protobuf;
option java_multiple_files = true;
option java_outer_classname = "EmptyProto";
option java_package = "com.google.protobuf";
// A generic empty message that you can re-use to avoid defining duplicated
// empty messages in your APIs. A typical example is to use it as the request
// or the response type of an API method. For instance:
//
// service Foo {
// rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
// }
//
message Empty {
}
================================================
FILE: vendor/google.golang.org/cloud/bigtable/internal/regen.sh
================================================
#!/bin/bash -e
#
# This script rebuilds the generated code for the protocol buffers.
# To run this you will need protoc and goprotobuf installed;
# see https://github.com/golang/protobuf for instructions.
# You also need Go and Git installed.
PKG=google.golang.org/cloud/bigtable
UPSTREAM=https://github.com/GoogleCloudPlatform/cloud-bigtable-client
UPSTREAM_SUBDIR=bigtable-protos/src/main/proto
function die() {
echo 1>&2 $*
exit 1
}
# Sanity check that the right tools are accessible.
for tool in go git protoc protoc-gen-go; do
q=$(which $tool) || die "didn't find $tool"
echo 1>&2 "$tool: $q"
done
tmpdir=$(mktemp -d -t regen-cbt.XXXXXX)
trap 'rm -rf $tmpdir' EXIT
echo -n 1>&2 "finding package dir... "
pkgdir=$(go list -f '{{.Dir}}' $PKG)
echo 1>&2 $pkgdir
base=$(echo $pkgdir | sed "s,/$PKG\$,,")
echo 1>&2 "base: $base"
cd $base
echo 1>&2 "fetching latest protos... "
git clone -q $UPSTREAM $tmpdir
# Pass 1: build mapping from upstream filename to our filename.
declare -A filename_map
for f in $(cd $PKG && find internal -name '*.proto'); do
echo -n 1>&2 "looking for latest version of $f... "
up=$(cd $tmpdir/$UPSTREAM_SUBDIR && find * -name $(basename $f))
echo 1>&2 $up
if [ $(echo $up | wc -w) != "1" ]; then
die "not exactly one match"
fi
filename_map[$up]=$f
done
# Pass 2: build sed script for fixing imports.
import_fixes=$tmpdir/fix_imports.sed
for up in "${!filename_map[@]}"; do
f=${filename_map[$up]}
echo >>$import_fixes "s,\"$up\",\"$PKG/$f\","
done
cat $import_fixes | sed 's,^,### ,' 1>&2
# Pass 3: copy files, making necessary adjustments.
for up in "${!filename_map[@]}"; do
f=${filename_map[$up]}
cat $tmpdir/$UPSTREAM_SUBDIR/$up |
# Adjust proto imports.
sed -f $import_fixes |
# Drop the UndeleteCluster RPC method. It returns a google.longrunning.Operation.
sed '/^ rpc UndeleteCluster(/,/^ }$/d' |
# Drop annotations, long-running operations and timestamps. They aren't supported (yet).
sed '/"google\/longrunning\/operations.proto"/d' |
sed '/google.longrunning.Operation/d' |
sed '/"google\/protobuf\/timestamp.proto"/d' |
sed '/google\.protobuf\.Timestamp/d' |
sed '/"google\/api\/annotations.proto"/d' |
sed '/option.*google\.api\.http.*{.*};$/d' |
cat > $PKG/$f
done
# Run protoc once per package.
for dir in $(find $PKG/internal -name '*.proto' | xargs dirname | sort | uniq); do
echo 1>&2 "* $dir"
protoc --go_out=plugins=grpc:. $dir/*.proto
done
echo 1>&2 "All OK"
================================================
FILE: vendor/google.golang.org/cloud/bigtable/internal/service_proto/bigtable_service.pb.go
================================================
// Code generated by protoc-gen-go.
// source: google.golang.org/cloud/bigtable/internal/service_proto/bigtable_service.proto
// DO NOT EDIT!
package google_bigtable_v1
import proto "github.com/golang/protobuf/proto"
import google_bigtable_v11 "google.golang.org/cloud/bigtable/internal/data_proto"
import google_protobuf "google.golang.org/cloud/bigtable/internal/empty"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
func init() {
}
// Client API for BigtableService service
type BigtableServiceClient interface {
// Streams back the contents of all requested rows, optionally applying
// the same Reader filter to each. Depending on their size, rows may be
// broken up across multiple responses, but atomicity of each row will still
// be preserved.
ReadRows(ctx context.Context, in *ReadRowsRequest, opts ...grpc.CallOption) (BigtableService_ReadRowsClient, error)
// Returns a sample of row keys in the table. The returned row keys will
// delimit contiguous sections of the table of approximately equal size,
// which can be used to break up the data for distributed tasks like
// mapreduces.
SampleRowKeys(ctx context.Context, in *SampleRowKeysRequest, opts ...grpc.CallOption) (BigtableService_SampleRowKeysClient, error)
// Mutates a row atomically. Cells already present in the row are left
// unchanged unless explicitly changed by 'mutation'.
MutateRow(ctx context.Context, in *MutateRowRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
// Mutates a row atomically based on the output of a predicate Reader filter.
CheckAndMutateRow(ctx context.Context, in *CheckAndMutateRowRequest, opts ...grpc.CallOption) (*CheckAndMutateRowResponse, error)
// Modifies a row atomically, reading the latest existing timestamp/value from
// the specified columns and writing a new value at
// max(existing timestamp, current server time) based on pre-defined
// read/modify/write rules. Returns the new contents of all modified cells.
ReadModifyWriteRow(ctx context.Context, in *ReadModifyWriteRowRequest, opts ...grpc.CallOption) (*google_bigtable_v11.Row, error)
}
type bigtableServiceClient struct {
cc *grpc.ClientConn
}
func NewBigtableServiceClient(cc *grpc.ClientConn) BigtableServiceClient {
return &bigtableServiceClient{cc}
}
func (c *bigtableServiceClient) ReadRows(ctx context.Context, in *ReadRowsRequest, opts ...grpc.CallOption) (BigtableService_ReadRowsClient, error) {
stream, err := grpc.NewClientStream(ctx, &_BigtableService_serviceDesc.Streams[0], c.cc, "/google.bigtable.v1.BigtableService/ReadRows", opts...)
if err != nil {
return nil, err
}
x := &bigtableServiceReadRowsClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type BigtableService_ReadRowsClient interface {
Recv() (*ReadRowsResponse, error)
grpc.ClientStream
}
type bigtableServiceReadRowsClient struct {
grpc.ClientStream
}
func (x *bigtableServiceReadRowsClient) Recv() (*ReadRowsResponse, error) {
m := new(ReadRowsResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *bigtableServiceClient) SampleRowKeys(ctx context.Context, in *SampleRowKeysRequest, opts ...grpc.CallOption) (BigtableService_SampleRowKeysClient, error) {
stream, err := grpc.NewClientStream(ctx, &_BigtableService_serviceDesc.Streams[1], c.cc, "/google.bigtable.v1.BigtableService/SampleRowKeys", opts...)
if err != nil {
return nil, err
}
x := &bigtableServiceSampleRowKeysClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type BigtableService_SampleRowKeysClient interface {
Recv() (*SampleRowKeysResponse, error)
grpc.ClientStream
}
type bigtableServiceSampleRowKeysClient struct {
grpc.ClientStream
}
func (x *bigtableServiceSampleRowKeysClient) Recv() (*SampleRowKeysResponse, error) {
m := new(SampleRowKeysResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *bigtableServiceClient) MutateRow(ctx context.Context, in *MutateRowRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
out := new(google_protobuf.Empty)
err := grpc.Invoke(ctx, "/google.bigtable.v1.BigtableService/MutateRow", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableServiceClient) CheckAndMutateRow(ctx context.Context, in *CheckAndMutateRowRequest, opts ...grpc.CallOption) (*CheckAndMutateRowResponse, error) {
out := new(CheckAndMutateRowResponse)
err := grpc.Invoke(ctx, "/google.bigtable.v1.BigtableService/CheckAndMutateRow", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableServiceClient) ReadModifyWriteRow(ctx context.Context, in *ReadModifyWriteRowRequest, opts ...grpc.CallOption) (*google_bigtable_v11.Row, error) {
out := new(google_bigtable_v11.Row)
err := grpc.Invoke(ctx, "/google.bigtable.v1.BigtableService/ReadModifyWriteRow", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for BigtableService service
type BigtableServiceServer interface {
// Streams back the contents of all requested rows, optionally applying
// the same Reader filter to each. Depending on their size, rows may be
// broken up across multiple responses, but atomicity of each row will still
// be preserved.
ReadRows(*ReadRowsRequest, BigtableService_ReadRowsServer) error
// Returns a sample of row keys in the table. The returned row keys will
// delimit contiguous sections of the table of approximately equal size,
// which can be used to break up the data for distributed tasks like
// mapreduces.
SampleRowKeys(*SampleRowKeysRequest, BigtableService_SampleRowKeysServer) error
// Mutates a row atomically. Cells already present in the row are left
// unchanged unless explicitly changed by 'mutation'.
MutateRow(context.Context, *MutateRowRequest) (*google_protobuf.Empty, error)
// Mutates a row atomically based on the output of a predicate Reader filter.
CheckAndMutateRow(context.Context, *CheckAndMutateRowRequest) (*CheckAndMutateRowResponse, error)
// Modifies a row atomically, reading the latest existing timestamp/value from
// the specified columns and writing a new value at
// max(existing timestamp, current server time) based on pre-defined
// read/modify/write rules. Returns the new contents of all modified cells.
ReadModifyWriteRow(context.Context, *ReadModifyWriteRowRequest) (*google_bigtable_v11.Row, error)
}
func RegisterBigtableServiceServer(s *grpc.Server, srv BigtableServiceServer) {
s.RegisterService(&_BigtableService_serviceDesc, srv)
}
func _BigtableService_ReadRows_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(ReadRowsRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(BigtableServiceServer).ReadRows(m, &bigtableServiceReadRowsServer{stream})
}
type BigtableService_ReadRowsServer interface {
Send(*ReadRowsResponse) error
grpc.ServerStream
}
type bigtableServiceReadRowsServer struct {
grpc.ServerStream
}
func (x *bigtableServiceReadRowsServer) Send(m *ReadRowsResponse) error {
return x.ServerStream.SendMsg(m)
}
func _BigtableService_SampleRowKeys_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(SampleRowKeysRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(BigtableServiceServer).SampleRowKeys(m, &bigtableServiceSampleRowKeysServer{stream})
}
type BigtableService_SampleRowKeysServer interface {
Send(*SampleRowKeysResponse) error
grpc.ServerStream
}
type bigtableServiceSampleRowKeysServer struct {
grpc.ServerStream
}
func (x *bigtableServiceSampleRowKeysServer) Send(m *SampleRowKeysResponse) error {
return x.ServerStream.SendMsg(m)
}
func _BigtableService_MutateRow_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
in := new(MutateRowRequest)
if err := codec.Unmarshal(buf, in); err != nil {
return nil, err
}
out, err := srv.(BigtableServiceServer).MutateRow(ctx, in)
if err != nil {
return nil, err
}
return out, nil
}
func _BigtableService_CheckAndMutateRow_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
in := new(CheckAndMutateRowRequest)
if err := codec.Unmarshal(buf, in); err != nil {
return nil, err
}
out, err := srv.(BigtableServiceServer).CheckAndMutateRow(ctx, in)
if err != nil {
return nil, err
}
return out, nil
}
func _BigtableService_ReadModifyWriteRow_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
in := new(ReadModifyWriteRowRequest)
if err := codec.Unmarshal(buf, in); err != nil {
return nil, err
}
out, err := srv.(BigtableServiceServer).ReadModifyWriteRow(ctx, in)
if err != nil {
return nil, err
}
return out, nil
}
var _BigtableService_serviceDesc = grpc.ServiceDesc{
ServiceName: "google.bigtable.v1.BigtableService",
HandlerType: (*BigtableServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "MutateRow",
Handler: _BigtableService_MutateRow_Handler,
},
{
MethodName: "CheckAndMutateRow",
Handler: _BigtableService_CheckAndMutateRow_Handler,
},
{
MethodName: "ReadModifyWriteRow",
Handler: _BigtableService_ReadModifyWriteRow_Handler,
},
},
Streams: []grpc.StreamDesc{
{
StreamName: "ReadRows",
Handler: _BigtableService_ReadRows_Handler,
ServerStreams: true,
},
{
StreamName: "SampleRowKeys",
Handler: _BigtableService_SampleRowKeys_Handler,
ServerStreams: true,
},
},
}
================================================
FILE: vendor/google.golang.org/cloud/bigtable/internal/service_proto/bigtable_service.proto
================================================
// Copyright (c) 2015, Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
syntax = "proto3";
package google.bigtable.v1;
import "google.golang.org/cloud/bigtable/internal/data_proto/bigtable_data.proto";
import "google.golang.org/cloud/bigtable/internal/service_proto/bigtable_service_messages.proto";
import "google.golang.org/cloud/bigtable/internal/empty/empty.proto";
option java_generic_services = true;
option java_multiple_files = true;
option java_outer_classname = "BigtableServicesProto";
option java_package = "com.google.bigtable.v1";
// Service for reading from and writing to existing Bigtables.
service BigtableService {
// Streams back the contents of all requested rows, optionally applying
// the same Reader filter to each. Depending on their size, rows may be
// broken up across multiple responses, but atomicity of each row will still
// be preserved.
rpc ReadRows(ReadRowsRequest) returns (stream ReadRowsResponse) {
}
// Returns a sample of row keys in the table. The returned row keys will
// delimit contiguous sections of the table of approximately equal size,
// which can be used to break up the data for distributed tasks like
// mapreduces.
rpc SampleRowKeys(SampleRowKeysRequest) returns (stream SampleRowKeysResponse) {
}
// Mutates a row atomically. Cells already present in the row are left
// unchanged unless explicitly changed by 'mutation'.
rpc MutateRow(MutateRowRequest) returns (google.protobuf.Empty) {
}
// Mutates a row atomically based on the output of a predicate Reader filter.
rpc CheckAndMutateRow(CheckAndMutateRowRequest) returns (CheckAndMutateRowResponse) {
}
// Modifies a row atomically, reading the latest existing timestamp/value from
// the specified columns and writing a new value at
// max(existing timestamp, current server time) based on pre-defined
// read/modify/write rules. Returns the new contents of all modified cells.
rpc ReadModifyWriteRow(ReadModifyWriteRowRequest) returns (Row) {
}
}
================================================
FILE: vendor/google.golang.org/cloud/bigtable/internal/service_proto/bigtable_service_messages.pb.go
================================================
// Code generated by protoc-gen-go.
// source: google.golang.org/cloud/bigtable/internal/service_proto/bigtable_service_messages.proto
// DO NOT EDIT!
/*
Package google_bigtable_v1 is a generated protocol buffer package.
It is generated from these files:
google.golang.org/cloud/bigtable/internal/service_proto/bigtable_service_messages.proto
google.golang.org/cloud/bigtable/internal/service_proto/bigtable_service.proto
It has these top-level messages:
ReadRowsRequest
ReadRowsResponse
SampleRowKeysRequest
SampleRowKeysResponse
MutateRowRequest
CheckAndMutateRowRequest
CheckAndMutateRowResponse
ReadModifyWriteRowRequest
*/
package google_bigtable_v1
import proto "github.com/golang/protobuf/proto"
import google_bigtable_v11 "google.golang.org/cloud/bigtable/internal/data_proto"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
// Request message for BigtableServer.ReadRows.
type ReadRowsRequest struct {
// The unique name of the table from which to read.
TableName string `protobuf:"bytes,1,opt,name=table_name" json:"table_name,omitempty"`
// The key of a single row from which to read.
RowKey []byte `protobuf:"bytes,2,opt,name=row_key,proto3" json:"row_key,omitempty"`
// A range of rows from which to read.
RowRange *google_bigtable_v11.RowRange `protobuf:"bytes,3,opt,name=row_range" json:"row_range,omitempty"`
// The filter to apply to the contents of the specified row(s), in the
// deprecated string format. If unset, reads the most recent value from all
// readable columns.
DEPRECATEDStringFilter string `protobuf:"bytes,4,opt,name=DEPRECATED_string_filter" json:"DEPRECATED_string_filter,omitempty"`
// The filter to apply to the contents of the specified row(s). If unset,
// reads the entire table.
Filter *google_bigtable_v11.RowFilter `protobuf:"bytes,5,opt,name=filter" json:"filter,omitempty"`
// By default, rows are read sequentially, producing results which are
// guaranteed to arrive in increasing row order. Setting
// "allow_row_interleaving" to true allows multiple rows to be interleaved in
// the response stream, which increases throughput but breaks this guarantee,
// and may force the client to use more memory to buffer partially-received
// rows.
AllowRowInterleaving bool `protobuf:"varint,6,opt,name=allow_row_interleaving" json:"allow_row_interleaving,omitempty"`
// The read will terminate after committing to N rows' worth of results. The
// default (zero) is to return all results.
// Note that if "allow_row_interleaving" is set to true, partial results may
// be returned for more than N rows. However, only N "commit_row" chunks will
// be sent.
NumRowsLimit int64 `protobuf:"varint,7,opt,name=num_rows_limit" json:"num_rows_limit,omitempty"`
}
func (m *ReadRowsRequest) Reset() { *m = ReadRowsRequest{} }
func (m *ReadRowsRequest) String() string { return proto.CompactTextString(m) }
func (*ReadRowsRequest) ProtoMessage() {}
func (m *ReadRowsRequest) GetRowRange() *google_bigtable_v11.RowRange {
if m != nil {
return m.RowRange
}
return nil
}
func (m *ReadRowsRequest) GetFilter() *google_bigtable_v11.RowFilter {
if m != nil {
return m.Filter
}
return nil
}
// Response message for BigtableService.ReadRows.
type ReadRowsResponse struct {
// The key of the row for which we're receiving data.
// Results will be received in increasing row key order, unless
// "allow_row_interleaving" was specified in the request.
RowKey []byte `protobuf:"bytes,1,opt,name=row_key,proto3" json:"row_key,omitempty"`
// One or more chunks of the row specified by "row_key".
Chunks []*ReadRowsResponse_Chunk `protobuf:"bytes,2,rep,name=chunks" json:"chunks,omitempty"`
}
func (m *ReadRowsResponse) Reset() { *m = ReadRowsResponse{} }
func (m *ReadRowsResponse) String() string { return proto.CompactTextString(m) }
func (*ReadRowsResponse) ProtoMessage() {}
func (m *ReadRowsResponse) GetChunks() []*ReadRowsResponse_Chunk {
if m != nil {
return m.Chunks
}
return nil
}
// Specifies a piece of a row's contents returned as part of the read
// response stream.
type ReadRowsResponse_Chunk struct {
// A subset of the data from a particular row. As long as no "reset_row"
// is received in between, multiple "row_contents" from the same row are
// from the same atomic view of that row, and will be received in the
// expected family/column/timestamp order.
RowContents *google_bigtable_v11.Family `protobuf:"bytes,1,opt,name=row_contents" json:"row_contents,omitempty"`
// Indicates that the client should drop all previous chunks for
// "row_key", as it will be re-read from the beginning.
ResetRow bool `protobuf:"varint,2,opt,name=reset_row" json:"reset_row,omitempty"`
// Indicates that the client can safely process all previous chunks for
// "row_key", as its data has been fully read.
CommitRow bool `protobuf:"varint,3,opt,name=commit_row" json:"commit_row,omitempty"`
}
func (m *ReadRowsResponse_Chunk) Reset() { *m = ReadRowsResponse_Chunk{} }
func (m *ReadRowsResponse_Chunk) String() string { return proto.CompactTextString(m) }
func (*ReadRowsResponse_Chunk) ProtoMessage() {}
func (m *ReadRowsResponse_Chunk) GetRowContents() *google_bigtable_v11.Family {
if m != nil {
return m.RowContents
}
return nil
}
// Request message for BigtableService.SampleRowKeys.
type SampleRowKeysRequest struct {
// The unique name of the table from which to sample row keys.
TableName string `protobuf:"bytes,1,opt,name=table_name" json:"table_name,omitempty"`
}
func (m *SampleRowKeysRequest) Reset() { *m = SampleRowKeysRequest{} }
func (m *SampleRowKeysRequest) String() string { return proto.CompactTextString(m) }
func (*SampleRowKeysRequest) ProtoMessage() {}
// Response message for BigtableService.SampleRowKeys.
type SampleRowKeysResponse struct {
// Sorted streamed sequence of sample row keys in the table. The table might
// have contents before the first row key in the list and after the last one,
// but a key containing the empty string indicates "end of table" and will be
// the last response given, if present.
// Note that row keys in this list may not have ever been written to or read
// from, and users should therefore not make any assumptions about the row key
// structure that are specific to their use case.
RowKey []byte `protobuf:"bytes,1,opt,name=row_key,proto3" json:"row_key,omitempty"`
// Approximate total storage space used by all rows in the table which precede
// "row_key". Buffering the contents of all rows between two subsequent
// samples would require space roughly equal to the difference in their
// "offset_bytes" fields.
OffsetBytes int64 `protobuf:"varint,2,opt,name=offset_bytes" json:"offset_bytes,omitempty"`
}
func (m *SampleRowKeysResponse) Reset() { *m = SampleRowKeysResponse{} }
func (m *SampleRowKeysResponse) String() string { return proto.CompactTextString(m) }
func (*SampleRowKeysResponse) ProtoMessage() {}
// Request message for BigtableService.MutateRow.
type MutateRowRequest struct {
// The unique name of the table to which the mutation should be applied.
TableName string `protobuf:"bytes,1,opt,name=table_name" json:"table_name,omitempty"`
// The key of the row to which the mutation should be applied.
RowKey []byte `protobuf:"bytes,2,opt,name=row_key,proto3" json:"row_key,omitempty"`
// Changes to be atomically applied to the specified row. Entries are applied
// in order, meaning that earlier mutations can be masked by later ones.
Mutations []*google_bigtable_v11.Mutation `protobuf:"bytes,3,rep,name=mutations" json:"mutations,omitempty"`
}
func (m *MutateRowRequest) Reset() { *m = MutateRowRequest{} }
func (m *MutateRowRequest) String() string { return proto.CompactTextString(m) }
func (*MutateRowRequest) ProtoMessage() {}
func (m *MutateRowRequest) GetMutations() []*google_bigtable_v11.Mutation {
if m != nil {
return m.Mutations
}
return nil
}
// Request message for BigtableService.CheckAndMutateRowRequest
type CheckAndMutateRowRequest struct {
// The unique name of the table to which the conditional mutation should be
// applied.
TableName string `protobuf:"bytes,1,opt,name=table_name" json:"table_name,omitempty"`
// The key of the row to which the conditional mutation should be applied.
RowKey []byte `protobuf:"bytes,2,opt,name=row_key,proto3" json:"row_key,omitempty"`
// Changes to be atomically applied to the specified row if "predicate_filter"
// yields at least one cell when applied to "row_key". Entries are applied in
// order, meaning that earlier mutations can be masked by later ones.
// Must contain at least one entry if "false_mutations" is empty.
TrueMutations []*google_bigtable_v11.Mutation `protobuf:"bytes,4,rep,name=true_mutations" json:"true_mutations,omitempty"`
// Changes to be atomically applied to the specified row if "predicate_filter"
// does not yield any cells when applied to "row_key". Entries are applied in
// order, meaning that earlier mutations can be masked by later ones.
// Must contain at least one entry if "true_mutations" is empty.
FalseMutations []*google_bigtable_v11.Mutation `protobuf:"bytes,5,rep,name=false_mutations" json:"false_mutations,omitempty"`
// The filter to be applied to the contents of the specified row, in the
// deprecated string format. Depending on whether or not any results are
// yielded, either "true_mutations" or "false_mutations" will be executed. If
// unset, checks that the row contains any values at all.
DEPRECATEDField_3 string `protobuf:"bytes,3,opt,name=DEPRECATED_field_3" json:"DEPRECATED_field_3,omitempty"`
// The filter to be applied to the contents of the specified row. Depending
// on whether or not any results are yielded, either "true_mutations" or
// "false_mutations" will be executed. If unset, checks that the row contains
// any values at all.
PredicateFilter *google_bigtable_v11.RowFilter `protobuf:"bytes,6,opt,name=predicate_filter" json:"predicate_filter,omitempty"`
}
func (m *CheckAndMutateRowRequest) Reset() { *m = CheckAndMutateRowRequest{} }
func (m *CheckAndMutateRowRequest) String() string { return proto.CompactTextString(m) }
func (*CheckAndMutateRowRequest) ProtoMessage() {}
func (m *CheckAndMutateRowRequest) GetTrueMutations() []*google_bigtable_v11.Mutation {
if m != nil {
return m.TrueMutations
}
return nil
}
func (m *CheckAndMutateRowRequest) GetFalseMutations() []*google_bigtable_v11.Mutation {
if m != nil {
return m.FalseMutations
}
return nil
}
func (m *CheckAndMutateRowRequest) GetPredicateFilter() *google_bigtable_v11.RowFilter {
if m != nil {
return m.PredicateFilter
}
return nil
}
// Response message for BigtableService.CheckAndMutateRowRequest.
type CheckAndMutateRowResponse struct {
// Whether or not the request's "predicate_filter" yielded any results for
// the specified row.
PredicateMatched bool `protobuf:"varint,1,opt,name=predicate_matched" json:"predicate_matched,omitempty"`
}
func (m *CheckAndMutateRowResponse) Reset() { *m = CheckAndMutateRowResponse{} }
func (m *CheckAndMutateRowResponse) String() string { return proto.CompactTextString(m) }
func (*CheckAndMutateRowResponse) ProtoMessage() {}
// Request message for BigtableService.ReadModifyWriteRowRequest.
type ReadModifyWriteRowRequest struct {
// The unique name of the table to which the read/modify/write rules should be
// applied.
TableName string `protobuf:"bytes,1,opt,name=table_name" json:"table_name,omitempty"`
// The key of the row to which the read/modify/write rules should be applied.
RowKey []byte `protobuf:"bytes,2,opt,name=row_key,proto3" json:"row_key,omitempty"`
// Rules specifying how the specified row's contents are to be transformed
// into writes. Entries are applied in order, meaning that earlier rules will
// affect the results of later ones.
Rules []*google_bigtable_v11.ReadModifyWriteRule `protobuf:"bytes,3,rep,name=rules" json:"rules,omitempty"`
}
func (m *ReadModifyWriteRowRequest) Reset() { *m = ReadModifyWriteRowRequest{} }
func (m *ReadModifyWriteRowRequest) String() string { return proto.CompactTextString(m) }
func (*ReadModifyWriteRowRequest) ProtoMessage() {}
func (m *ReadModifyWriteRowRequest) GetRules() []*google_bigtable_v11.ReadModifyWriteRule {
if m != nil {
return m.Rules
}
return nil
}
func init() {
}
================================================
FILE: vendor/google.golang.org/cloud/bigtable/internal/service_proto/bigtable_service_messages.proto
================================================
// Copyright (c) 2015, Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
syntax = "proto3";
package google.bigtable.v1;
import "google.golang.org/cloud/bigtable/internal/data_proto/bigtable_data.proto";
option java_multiple_files = true;
option java_outer_classname = "BigtableServiceMessagesProto";
option java_package = "com.google.bigtable.v1";
// Request message for BigtableServer.ReadRows.
message ReadRowsRequest {
// The unique name of the table from which to read.
string table_name = 1;
oneof target {
// The key of a single row from which to read.
bytes row_key = 2;
// A range of rows from which to read.
RowRange row_range = 3;
}
// The filter to apply to the contents of the specified row(s), in the
// deprecated string format. If unset, reads the most recent value from all
// readable columns.
string DEPRECATED_string_filter = 4;
// The filter to apply to the contents of the specified row(s). If unset,
// reads the entire table.
RowFilter filter = 5;
// By default, rows are read sequentially, producing results which are
// guaranteed to arrive in increasing row order. Setting
// "allow_row_interleaving" to true allows multiple rows to be interleaved in
// the response stream, which increases throughput but breaks this guarantee,
// and may force the client to use more memory to buffer partially-received
// rows.
bool allow_row_interleaving = 6;
// The read will terminate after committing to N rows' worth of results. The
// default (zero) is to return all results.
// Note that if "allow_row_interleaving" is set to true, partial results may
// be returned for more than N rows. However, only N "commit_row" chunks will
// be sent.
int64 num_rows_limit = 7;
}
// Response message for BigtableService.ReadRows.
message ReadRowsResponse {
// Specifies a piece of a row's contents returned as part of the read
// response stream.
message Chunk {
oneof chunk {
// A subset of the data from a particular row. As long as no "reset_row"
// is received in between, multiple "row_contents" from the same row are
// from the same atomic view of that row, and will be received in the
// expected family/column/timestamp order.
Family row_contents = 1;
// Indicates that the client should drop all previous chunks for
// "row_key", as it will be re-read from the beginning.
bool reset_row = 2;
// Indicates that the client can safely process all previous chunks for
// "row_key", as its data has been fully read.
bool commit_row = 3;
}
}
// The key of the row for which we're receiving data.
// Results will be received in increasing row key order, unless
// "allow_row_interleaving" was specified in the request.
bytes row_key = 1;
// One or more chunks of the row specified by "row_key".
repeated Chunk chunks = 2;
}
// Request message for BigtableService.SampleRowKeys.
message SampleRowKeysRequest {
// The unique name of the table from which to sample row keys.
string table_name = 1;
}
// Response message for BigtableService.SampleRowKeys.
message SampleRowKeysResponse {
// Sorted streamed sequence of sample row keys in the table. The table might
// have contents before the first row key in the list and after the last one,
// but a key containing the empty string indicates "end of table" and will be
// the last response given, if present.
// Note that row keys in this list may not have ever been written to or read
// from, and users should therefore not make any assumptions about the row key
// structure that are specific to their use case.
bytes row_key = 1;
// Approximate total storage space used by all rows in the table which precede
// "row_key". Buffering the contents of all rows between two subsequent
// samples would require space roughly equal to the difference in their
// "offset_bytes" fields.
int64 offset_bytes = 2;
}
// Request message for BigtableService.MutateRow.
message MutateRowRequest {
// The unique name of the table to which the mutation should be applied.
string table_name = 1;
// The key of the row to which the mutation should be applied.
bytes row_key = 2;
// Changes to be atomically applied to the specified row. Entries are applied
// in order, meaning that earlier mutations can be masked by later ones.
repeated Mutation mutations = 3;
}
// Request message for BigtableService.CheckAndMutateRowRequest
message CheckAndMutateRowRequest {
// The unique name of the table to which the conditional mutation should be
// applied.
string table_name = 1;
// The key of the row to which the conditional mutation should be applied.
bytes row_key = 2;
// Changes to be atomically applied to the specified row if "predicate_filter"
// yields at least one cell when applied to "row_key". Entries are applied in
// order, meaning that earlier mutations can be masked by later ones.
// Must contain at least one entry if "false_mutations" is empty.
repeated Mutation true_mutations = 4;
// Changes to be atomically applied to the specified row if "predicate_filter"
// does not yield any cells when applied to "row_key". Entries are applied in
// order, meaning that earlier mutations can be masked by later ones.
// Must contain at least one entry if "true_mutations" is empty.
repeated Mutation false_mutations = 5;
// The filter to be applied to the contents of the specified row, in the
// deprecated string format. Depending on whether or not any results are
// yielded, either "true_mutations" or "false_mutations" will be executed. If
// unset, checks that the row contains any values at all.
string DEPRECATED_field_3 = 3;
// The filter to be applied to the contents of the specified row. Depending
// on whether or not any results are yielded, either "true_mutations" or
// "false_mutations" will be executed. If unset, checks that the row contains
// any values at all.
RowFilter predicate_filter = 6;
}
// Response message for BigtableService.CheckAndMutateRowRequest.
message CheckAndMutateRowResponse {
// Whether or not the request's "predicate_filter" yielded any results for
// the specified row.
bool predicate_matched = 1;
}
// Request message for BigtableService.ReadModifyWriteRowRequest.
message ReadModifyWriteRowRequest {
// The unique name of the table to which the read/modify/write rules should be
// applied.
string table_name = 1;
// The key of the row to which the read/modify/write rules should be applied.
bytes row_key = 2;
// Rules specifying how the specified row's contents are to be transformed
// into writes. Entries are applied in order, meaning that earlier rules will
// affect the results of later ones.
repeated ReadModifyWriteRule rules = 3;
}
================================================
FILE: vendor/google.golang.org/cloud/bigtable/internal/table_data_proto/bigtable_table_data.pb.go
================================================
// Code generated by protoc-gen-go.
// source: google.golang.org/cloud/bigtable/internal/table_data_proto/bigtable_table_data.proto
// DO NOT EDIT!
/*
Package google_bigtable_admin_table_v1 is a generated protocol buffer package.
It is generated from these files:
google.golang.org/cloud/bigtable/internal/table_data_proto/bigtable_table_data.proto
It has these top-level messages:
Table
ColumnFamily
*/
package google_bigtable_admin_table_v1
import proto "github.com/golang/protobuf/proto"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
type Table_TimestampGranularity int32
const (
Table_MILLIS Table_TimestampGranularity = 0
)
var Table_TimestampGranularity_name = map[int32]string{
0: "MILLIS",
}
var Table_TimestampGranularity_value = map[string]int32{
"MILLIS": 0,
}
func (x Table_TimestampGranularity) String() string {
return proto.EnumName(Table_TimestampGranularity_name, int32(x))
}
// A collection of user data indexed by row, column, and timestamp.
// Each table is served using the resources of its parent cluster.
type Table struct {
// A unique identifier of the form
// /tables/[_a-zA-Z0-9][-_.a-zA-Z0-9]*
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// The column families configured for this table, mapped by column family id.
ColumnFamilies map[string]*ColumnFamily `protobuf:"bytes,3,rep,name=column_families" json:"column_families,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
// The granularity (e.g. MILLIS, MICROS) at which timestamps are stored in
// this table. Timestamps not matching the granularity will be rejected.
// Cannot be changed once the table is created.
Granularity Table_TimestampGranularity `protobuf:"varint,4,opt,name=granularity,enum=google.bigtable.admin.table.v1.Table_TimestampGranularity" json:"granularity,omitempty"`
}
func (m *Table) Reset() { *m = Table{} }
func (m *Table) String() string { return proto.CompactTextString(m) }
func (*Table) ProtoMessage() {}
func (m *Table) GetColumnFamilies() map[string]*ColumnFamily {
if m != nil {
return m.ColumnFamilies
}
return nil
}
// A set of columns within a table which share a common configuration.
type ColumnFamily struct {
// A unique identifier of the form /families/[-_.a-zA-Z0-9]+
// The last segment is the same as the "name" field in
// google.bigtable.v1.Family.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// Garbage collection expression specified by the following grammar:
// GC = EXPR
// | "" ;
// EXPR = EXPR, "||", EXPR (* lowest precedence *)
// | EXPR, "&&", EXPR
// | "(", EXPR, ")" (* highest precedence *)
// | PROP ;
// PROP = "version() >", NUM32
// | "age() >", NUM64, [ UNIT ] ;
// NUM32 = non-zero-digit { digit } ; (* # NUM32 <= 2^32 - 1 *)
// NUM64 = non-zero-digit { digit } ; (* # NUM64 <= 2^63 - 1 *)
// UNIT = "d" | "h" | "m" (* d=days, h=hours, m=minutes, else micros *)
// GC expressions can be up to 500 characters in length
//
// The different types of PROP are defined as follows:
// version() - cell index, counting from most recent and starting at 1
// age() - age of the cell (current time minus cell timestamp)
//
// Example: "version() > 3 || (age() > 3d && version() > 1)"
// drop cells beyond the most recent three, and drop cells older than three
// days unless they're the most recent cell in the row/column
//
// Garbage collection executes opportunistically in the background, and so
// it's possible for reads to return a cell even if it matches the active GC
// expression for its family.
GcExpression string `protobuf:"bytes,2,opt,name=gc_expression" json:"gc_expression,omitempty"`
}
func (m *ColumnFamily) Reset() { *m = ColumnFamily{} }
func (m *ColumnFamily) String() string { return proto.CompactTextString(m) }
func (*ColumnFamily) ProtoMessage() {}
func init() {
proto.RegisterEnum("google.bigtable.admin.table.v1.Table_TimestampGranularity", Table_TimestampGranularity_name, Table_TimestampGranularity_value)
}
================================================
FILE: vendor/google.golang.org/cloud/bigtable/internal/table_data_proto/bigtable_table_data.proto
================================================
// Copyright (c) 2015, Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
syntax = "proto3";
package google.bigtable.admin.table.v1;
option java_multiple_files = true;
option java_outer_classname = "BigtableTableDataProto";
option java_package = "com.google.bigtable.admin.table.v1";
// A collection of user data indexed by row, column, and timestamp.
// Each table is served using the resources of its parent cluster.
message Table {
enum TimestampGranularity {
MILLIS = 0;
}
// A unique identifier of the form
// /tables/[_a-zA-Z0-9][-_.a-zA-Z0-9]*
string name = 1;
// If this Table is in the process of being created, the Operation used to
// track its progress. As long as this operation is present, the Table will
// not accept any Table Admin or Read/Write requests.
// The column families configured for this table, mapped by column family id.
map column_families = 3;
// The granularity (e.g. MILLIS, MICROS) at which timestamps are stored in
// this table. Timestamps not matching the granularity will be rejected.
// Cannot be changed once the table is created.
TimestampGranularity granularity = 4;
}
// A set of columns within a table which share a common configuration.
message ColumnFamily {
// A unique identifier of the form /families/[-_.a-zA-Z0-9]+
// The last segment is the same as the "name" field in
// google.bigtable.v1.Family.
string name = 1;
// Garbage collection expression specified by the following grammar:
// GC = EXPR
// | "" ;
// EXPR = EXPR, "||", EXPR (* lowest precedence *)
// | EXPR, "&&", EXPR
// | "(", EXPR, ")" (* highest precedence *)
// | PROP ;
// PROP = "version() >", NUM32
// | "age() >", NUM64, [ UNIT ] ;
// NUM32 = non-zero-digit { digit } ; (* # NUM32 <= 2^32 - 1 *)
// NUM64 = non-zero-digit { digit } ; (* # NUM64 <= 2^63 - 1 *)
// UNIT = "d" | "h" | "m" (* d=days, h=hours, m=minutes, else micros *)
// GC expressions can be up to 500 characters in length
//
// The different types of PROP are defined as follows:
// version() - cell index, counting from most recent and starting at 1
// age() - age of the cell (current time minus cell timestamp)
//
// Example: "version() > 3 || (age() > 3d && version() > 1)"
// drop cells beyond the most recent three, and drop cells older than three
// days unless they're the most recent cell in the row/column
//
// Garbage collection executes opportunistically in the background, and so
// it's possible for reads to return a cell even if it matches the active GC
// expression for its family.
string gc_expression = 2;
}
================================================
FILE: vendor/google.golang.org/cloud/bigtable/internal/table_service_proto/bigtable_table_service.pb.go
================================================
// Code generated by protoc-gen-go.
// source: google.golang.org/cloud/bigtable/internal/table_service_proto/bigtable_table_service.proto
// DO NOT EDIT!
package google_bigtable_admin_table_v1
import proto "github.com/golang/protobuf/proto"
import google_bigtable_admin_table_v11 "google.golang.org/cloud/bigtable/internal/table_data_proto"
import google_protobuf "google.golang.org/cloud/bigtable/internal/empty"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
func init() {
}
// Client API for BigtableTableService service
type BigtableTableServiceClient interface {
// Creates a new table, to be served from a specified cluster.
// The table can be created with a full set of initial column families,
// specified in the request.
CreateTable(ctx context.Context, in *CreateTableRequest, opts ...grpc.CallOption) (*google_bigtable_admin_table_v11.Table, error)
// Lists the names of all tables served from a specified cluster.
ListTables(ctx context.Context, in *ListTablesRequest, opts ...grpc.CallOption) (*ListTablesResponse, error)
// Gets the schema of the specified table, including its column families.
GetTable(ctx context.Context, in *GetTableRequest, opts ...grpc.CallOption) (*google_bigtable_admin_table_v11.Table, error)
// Permanently deletes a specified table and all of its data.
DeleteTable(ctx context.Context, in *DeleteTableRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
// Changes the name of a specified table.
// Cannot be used to move tables between clusters, zones, or projects.
RenameTable(ctx context.Context, in *RenameTableRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
// Creates a new column family within a specified table.
CreateColumnFamily(ctx context.Context, in *CreateColumnFamilyRequest, opts ...grpc.CallOption) (*google_bigtable_admin_table_v11.ColumnFamily, error)
// Changes the configuration of a specified column family.
UpdateColumnFamily(ctx context.Context, in *google_bigtable_admin_table_v11.ColumnFamily, opts ...grpc.CallOption) (*google_bigtable_admin_table_v11.ColumnFamily, error)
// Permanently deletes a specified column family and all of its data.
DeleteColumnFamily(ctx context.Context, in *DeleteColumnFamilyRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error)
}
type bigtableTableServiceClient struct {
cc *grpc.ClientConn
}
func NewBigtableTableServiceClient(cc *grpc.ClientConn) BigtableTableServiceClient {
return &bigtableTableServiceClient{cc}
}
func (c *bigtableTableServiceClient) CreateTable(ctx context.Context, in *CreateTableRequest, opts ...grpc.CallOption) (*google_bigtable_admin_table_v11.Table, error) {
out := new(google_bigtable_admin_table_v11.Table)
err := grpc.Invoke(ctx, "/google.bigtable.admin.table.v1.BigtableTableService/CreateTable", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableTableServiceClient) ListTables(ctx context.Context, in *ListTablesRequest, opts ...grpc.CallOption) (*ListTablesResponse, error) {
out := new(ListTablesResponse)
err := grpc.Invoke(ctx, "/google.bigtable.admin.table.v1.BigtableTableService/ListTables", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableTableServiceClient) GetTable(ctx context.Context, in *GetTableRequest, opts ...grpc.CallOption) (*google_bigtable_admin_table_v11.Table, error) {
out := new(google_bigtable_admin_table_v11.Table)
err := grpc.Invoke(ctx, "/google.bigtable.admin.table.v1.BigtableTableService/GetTable", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableTableServiceClient) DeleteTable(ctx context.Context, in *DeleteTableRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
out := new(google_protobuf.Empty)
err := grpc.Invoke(ctx, "/google.bigtable.admin.table.v1.BigtableTableService/DeleteTable", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableTableServiceClient) RenameTable(ctx context.Context, in *RenameTableRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
out := new(google_protobuf.Empty)
err := grpc.Invoke(ctx, "/google.bigtable.admin.table.v1.BigtableTableService/RenameTable", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableTableServiceClient) CreateColumnFamily(ctx context.Context, in *CreateColumnFamilyRequest, opts ...grpc.CallOption) (*google_bigtable_admin_table_v11.ColumnFamily, error) {
out := new(google_bigtable_admin_table_v11.ColumnFamily)
err := grpc.Invoke(ctx, "/google.bigtable.admin.table.v1.BigtableTableService/CreateColumnFamily", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableTableServiceClient) UpdateColumnFamily(ctx context.Context, in *google_bigtable_admin_table_v11.ColumnFamily, opts ...grpc.CallOption) (*google_bigtable_admin_table_v11.ColumnFamily, error) {
out := new(google_bigtable_admin_table_v11.ColumnFamily)
err := grpc.Invoke(ctx, "/google.bigtable.admin.table.v1.BigtableTableService/UpdateColumnFamily", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *bigtableTableServiceClient) DeleteColumnFamily(ctx context.Context, in *DeleteColumnFamilyRequest, opts ...grpc.CallOption) (*google_protobuf.Empty, error) {
out := new(google_protobuf.Empty)
err := grpc.Invoke(ctx, "/google.bigtable.admin.table.v1.BigtableTableService/DeleteColumnFamily", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
// Server API for BigtableTableService service
type BigtableTableServiceServer interface {
// Creates a new table, to be served from a specified cluster.
// The table can be created with a full set of initial column families,
// specified in the request.
CreateTable(context.Context, *CreateTableRequest) (*google_bigtable_admin_table_v11.Table, error)
// Lists the names of all tables served from a specified cluster.
ListTables(context.Context, *ListTablesRequest) (*ListTablesResponse, error)
// Gets the schema of the specified table, including its column families.
GetTable(context.Context, *GetTableRequest) (*google_bigtable_admin_table_v11.Table, error)
// Permanently deletes a specified table and all of its data.
DeleteTable(context.Context, *DeleteTableRequest) (*google_protobuf.Empty, error)
// Changes the name of a specified table.
// Cannot be used to move tables between clusters, zones, or projects.
RenameTable(context.Context, *RenameTableRequest) (*google_protobuf.Empty, error)
// Creates a new column family within a specified table.
CreateColumnFamily(context.Context, *CreateColumnFamilyRequest) (*google_bigtable_admin_table_v11.ColumnFamily, error)
// Changes the configuration of a specified column family.
UpdateColumnFamily(context.Context, *google_bigtable_admin_table_v11.ColumnFamily) (*google_bigtable_admin_table_v11.ColumnFamily, error)
// Permanently deletes a specified column family and all of its data.
DeleteColumnFamily(context.Context, *DeleteColumnFamilyRequest) (*google_protobuf.Empty, error)
}
func RegisterBigtableTableServiceServer(s *grpc.Server, srv BigtableTableServiceServer) {
s.RegisterService(&_BigtableTableService_serviceDesc, srv)
}
func _BigtableTableService_CreateTable_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
in := new(CreateTableRequest)
if err := codec.Unmarshal(buf, in); err != nil {
return nil, err
}
out, err := srv.(BigtableTableServiceServer).CreateTable(ctx, in)
if err != nil {
return nil, err
}
return out, nil
}
func _BigtableTableService_ListTables_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
in := new(ListTablesRequest)
if err := codec.Unmarshal(buf, in); err != nil {
return nil, err
}
out, err := srv.(BigtableTableServiceServer).ListTables(ctx, in)
if err != nil {
return nil, err
}
return out, nil
}
func _BigtableTableService_GetTable_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
in := new(GetTableRequest)
if err := codec.Unmarshal(buf, in); err != nil {
return nil, err
}
out, err := srv.(BigtableTableServiceServer).GetTable(ctx, in)
if err != nil {
return nil, err
}
return out, nil
}
func _BigtableTableService_DeleteTable_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
in := new(DeleteTableRequest)
if err := codec.Unmarshal(buf, in); err != nil {
return nil, err
}
out, err := srv.(BigtableTableServiceServer).DeleteTable(ctx, in)
if err != nil {
return nil, err
}
return out, nil
}
func _BigtableTableService_RenameTable_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
in := new(RenameTableRequest)
if err := codec.Unmarshal(buf, in); err != nil {
return nil, err
}
out, err := srv.(BigtableTableServiceServer).RenameTable(ctx, in)
if err != nil {
return nil, err
}
return out, nil
}
func _BigtableTableService_CreateColumnFamily_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
in := new(CreateColumnFamilyRequest)
if err := codec.Unmarshal(buf, in); err != nil {
return nil, err
}
out, err := srv.(BigtableTableServiceServer).CreateColumnFamily(ctx, in)
if err != nil {
return nil, err
}
return out, nil
}
func _BigtableTableService_UpdateColumnFamily_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
in := new(google_bigtable_admin_table_v11.ColumnFamily)
if err := codec.Unmarshal(buf, in); err != nil {
return nil, err
}
out, err := srv.(BigtableTableServiceServer).UpdateColumnFamily(ctx, in)
if err != nil {
return nil, err
}
return out, nil
}
func _BigtableTableService_DeleteColumnFamily_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
in := new(DeleteColumnFamilyRequest)
if err := codec.Unmarshal(buf, in); err != nil {
return nil, err
}
out, err := srv.(BigtableTableServiceServer).DeleteColumnFamily(ctx, in)
if err != nil {
return nil, err
}
return out, nil
}
var _BigtableTableService_serviceDesc = grpc.ServiceDesc{
ServiceName: "google.bigtable.admin.table.v1.BigtableTableService",
HandlerType: (*BigtableTableServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "CreateTable",
Handler: _BigtableTableService_CreateTable_Handler,
},
{
MethodName: "ListTables",
Handler: _BigtableTableService_ListTables_Handler,
},
{
MethodName: "GetTable",
Handler: _BigtableTableService_GetTable_Handler,
},
{
MethodName: "DeleteTable",
Handler: _BigtableTableService_DeleteTable_Handler,
},
{
MethodName: "RenameTable",
Handler: _BigtableTableService_RenameTable_Handler,
},
{
MethodName: "CreateColumnFamily",
Handler: _BigtableTableService_CreateColumnFamily_Handler,
},
{
MethodName: "UpdateColumnFamily",
Handler: _BigtableTableService_UpdateColumnFamily_Handler,
},
{
MethodName: "DeleteColumnFamily",
Handler: _BigtableTableService_DeleteColumnFamily_Handler,
},
},
Streams: []grpc.StreamDesc{},
}
================================================
FILE: vendor/google.golang.org/cloud/bigtable/internal/table_service_proto/bigtable_table_service.proto
================================================
// Copyright (c) 2015, Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
syntax = "proto3";
package google.bigtable.admin.table.v1;
import "google.golang.org/cloud/bigtable/internal/table_data_proto/bigtable_table_data.proto";
import "google.golang.org/cloud/bigtable/internal/table_service_proto/bigtable_table_service_messages.proto";
import "google.golang.org/cloud/bigtable/internal/empty/empty.proto";
option java_generic_services = true;
option java_multiple_files = true;
option java_outer_classname = "BigtableTableServicesProto";
option java_package = "com.google.bigtable.admin.table.v1";
// Service for creating, configuring, and deleting Cloud Bigtable tables.
// Provides access to the table schemas only, not the data stored within the tables.
service BigtableTableService {
// Creates a new table, to be served from a specified cluster.
// The table can be created with a full set of initial column families,
// specified in the request.
rpc CreateTable(CreateTableRequest) returns (Table) {
}
// Lists the names of all tables served from a specified cluster.
rpc ListTables(ListTablesRequest) returns (ListTablesResponse) {
}
// Gets the schema of the specified table, including its column families.
rpc GetTable(GetTableRequest) returns (Table) {
}
// Permanently deletes a specified table and all of its data.
rpc DeleteTable(DeleteTableRequest) returns (google.protobuf.Empty) {
}
// Changes the name of a specified table.
// Cannot be used to move tables between clusters, zones, or projects.
rpc RenameTable(RenameTableRequest) returns (google.protobuf.Empty) {
}
// Creates a new column family within a specified table.
rpc CreateColumnFamily(CreateColumnFamilyRequest) returns (ColumnFamily) {
}
// Changes the configuration of a specified column family.
rpc UpdateColumnFamily(ColumnFamily) returns (ColumnFamily) {
}
// Permanently deletes a specified column family and all of its data.
rpc DeleteColumnFamily(DeleteColumnFamilyRequest) returns (google.protobuf.Empty) {
}
}
================================================
FILE: vendor/google.golang.org/cloud/bigtable/internal/table_service_proto/bigtable_table_service_messages.pb.go
================================================
// Code generated by protoc-gen-go.
// source: google.golang.org/cloud/bigtable/internal/table_service_proto/bigtable_table_service_messages.proto
// DO NOT EDIT!
/*
Package google_bigtable_admin_table_v1 is a generated protocol buffer package.
It is generated from these files:
google.golang.org/cloud/bigtable/internal/table_service_proto/bigtable_table_service_messages.proto
google.golang.org/cloud/bigtable/internal/table_service_proto/bigtable_table_service.proto
It has these top-level messages:
CreateTableRequest
ListTablesRequest
ListTablesResponse
GetTableRequest
DeleteTableRequest
RenameTableRequest
CreateColumnFamilyRequest
DeleteColumnFamilyRequest
*/
package google_bigtable_admin_table_v1
import proto "github.com/golang/protobuf/proto"
import google_bigtable_admin_table_v11 "google.golang.org/cloud/bigtable/internal/table_data_proto"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
type CreateTableRequest struct {
// The unique name of the cluster in which to create the new table.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// The name by which the new table should be referred to within the cluster,
// e.g. "foobar" rather than "/tables/foobar".
TableId string `protobuf:"bytes,2,opt,name=table_id" json:"table_id,omitempty"`
// The Table to create. The `name` field of the Table and all of its
// ColumnFamilies must be left blank, and will be populated in the response.
Table *google_bigtable_admin_table_v11.Table `protobuf:"bytes,3,opt,name=table" json:"table,omitempty"`
}
func (m *CreateTableRequest) Reset() { *m = CreateTableRequest{} }
func (m *CreateTableRequest) String() string { return proto.CompactTextString(m) }
func (*CreateTableRequest) ProtoMessage() {}
func (m *CreateTableRequest) GetTable() *google_bigtable_admin_table_v11.Table {
if m != nil {
return m.Table
}
return nil
}
type ListTablesRequest struct {
// The unique name of the cluster for which tables should be listed.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}
func (m *ListTablesRequest) Reset() { *m = ListTablesRequest{} }
func (m *ListTablesRequest) String() string { return proto.CompactTextString(m) }
func (*ListTablesRequest) ProtoMessage() {}
type ListTablesResponse struct {
// The tables present in the requested cluster.
// At present, only the names of the tables are populated.
Tables []*google_bigtable_admin_table_v11.Table `protobuf:"bytes,1,rep,name=tables" json:"tables,omitempty"`
}
func (m *ListTablesResponse) Reset() { *m = ListTablesResponse{} }
func (m *ListTablesResponse) String() string { return proto.CompactTextString(m) }
func (*ListTablesResponse) ProtoMessage() {}
func (m *ListTablesResponse) GetTables() []*google_bigtable_admin_table_v11.Table {
if m != nil {
return m.Tables
}
return nil
}
type GetTableRequest struct {
// The unique name of the requested table.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}
func (m *GetTableRequest) Reset() { *m = GetTableRequest{} }
func (m *GetTableRequest) String() string { return proto.CompactTextString(m) }
func (*GetTableRequest) ProtoMessage() {}
type DeleteTableRequest struct {
// The unique name of the table to be deleted.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}
func (m *DeleteTableRequest) Reset() { *m = DeleteTableRequest{} }
func (m *DeleteTableRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteTableRequest) ProtoMessage() {}
type RenameTableRequest struct {
// The current unique name of the table.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// The new name by which the table should be referred to within its containing
// cluster, e.g. "foobar" rather than "/tables/foobar".
NewId string `protobuf:"bytes,2,opt,name=new_id" json:"new_id,omitempty"`
}
func (m *RenameTableRequest) Reset() { *m = RenameTableRequest{} }
func (m *RenameTableRequest) String() string { return proto.CompactTextString(m) }
func (*RenameTableRequest) ProtoMessage() {}
type CreateColumnFamilyRequest struct {
// The unique name of the table in which to create the new column family.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// The name by which the new column family should be referred to within the
// table, e.g. "foobar" rather than "/columnFamilies/foobar".
ColumnFamilyId string `protobuf:"bytes,2,opt,name=column_family_id" json:"column_family_id,omitempty"`
// The column family to create. The `name` field must be left blank.
ColumnFamily *google_bigtable_admin_table_v11.ColumnFamily `protobuf:"bytes,3,opt,name=column_family" json:"column_family,omitempty"`
}
func (m *CreateColumnFamilyRequest) Reset() { *m = CreateColumnFamilyRequest{} }
func (m *CreateColumnFamilyRequest) String() string { return proto.CompactTextString(m) }
func (*CreateColumnFamilyRequest) ProtoMessage() {}
func (m *CreateColumnFamilyRequest) GetColumnFamily() *google_bigtable_admin_table_v11.ColumnFamily {
if m != nil {
return m.ColumnFamily
}
return nil
}
type DeleteColumnFamilyRequest struct {
// The unique name of the column family to be deleted.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
}
func (m *DeleteColumnFamilyRequest) Reset() { *m = DeleteColumnFamilyRequest{} }
func (m *DeleteColumnFamilyRequest) String() string { return proto.CompactTextString(m) }
func (*DeleteColumnFamilyRequest) ProtoMessage() {}
func init() {
}
================================================
FILE: vendor/google.golang.org/cloud/bigtable/internal/table_service_proto/bigtable_table_service_messages.proto
================================================
// Copyright (c) 2015, Google Inc.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
syntax = "proto3";
package google.bigtable.admin.table.v1;
import "google.golang.org/cloud/bigtable/internal/table_data_proto/bigtable_table_data.proto";
option java_multiple_files = true;
option java_outer_classname = "BigtableTableServiceMessagesProto";
option java_package = "com.google.bigtable.admin.table.v1";
message CreateTableRequest {
// The unique name of the cluster in which to create the new table.
string name = 1;
// The name by which the new table should be referred to within the cluster,
// e.g. "foobar" rather than "/tables/foobar".
string table_id = 2;
// The Table to create. The `name` field of the Table and all of its
// ColumnFamilies must be left blank, and will be populated in the response.
Table table = 3;
}
message ListTablesRequest {
// The unique name of the cluster for which tables should be listed.
string name = 1;
}
message ListTablesResponse {
// The tables present in the requested cluster.
// At present, only the names of the tables are populated.
repeated Table tables = 1;
}
message GetTableRequest {
// The unique name of the requested table.
string name = 1;
}
message DeleteTableRequest {
// The unique name of the table to be deleted.
string name = 1;
}
message RenameTableRequest {
// The current unique name of the table.
string name = 1;
// The new name by which the table should be referred to within its containing
// cluster, e.g. "foobar" rather than "/tables/foobar".
string new_id = 2;
}
message CreateColumnFamilyRequest {
// The unique name of the table in which to create the new column family.
string name = 1;
// The name by which the new column family should be referred to within the
// table, e.g. "foobar" rather than "/columnFamilies/foobar".
string column_family_id = 2;
// The column family to create. The `name` field must be left blank.
ColumnFamily column_family = 3;
}
message DeleteColumnFamilyRequest {
// The unique name of the column family to be deleted.
string name = 1;
}
================================================
FILE: vendor/google.golang.org/cloud/bigtable/sample/search.go
================================================
/*
Copyright 2015 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
// This is a sample web server that uses Cloud Bigtable as the storage layer
// for a simple document-storage and full-text-search service.
// It has three functions:
// - Add a document. This adds the content of a user-supplied document to the
// Bigtable, and adds references to the document to an index in the Bigtable.
// The document is indexed under each unique word in the document.
// - Search the index. This returns documents containing each word in a user
// query, with snippets and links to view the whole document.
// - Clear the table. This deletes and recreates the Bigtable,
package main
import (
"bytes"
"flag"
"fmt"
"html/template"
"io"
"log"
"net/http"
"os"
"strings"
"sync"
"time"
"unicode"
"golang.org/x/net/context"
"google.golang.org/cloud/bigtable"
)
var (
project = flag.String("project", "", "The name of the project.")
zone = flag.String("zone", "", "The zone of the project.")
cluster = flag.String("cluster", "", "The name of the Cloud Bigtable cluster.")
tableName = flag.String("table", "docindex", "The name of the table containing the documents and index.")
credFile = flag.String("creds", "", "File containing credentials")
rebuild = flag.Bool("rebuild", false, "Rebuild the table from scratch on startup.")
client *bigtable.Client
adminClient *bigtable.AdminClient
table *bigtable.Table
addTemplate = template.Must(template.New("").Parse(`
Added {{.Title}}
`))
contentTemplate = template.Must(template.New("").Parse(`
{{.Title}}
{{.Content}}
`))
searchTemplate = template.Must(template.New("").Parse(`
Results for {{.Query}}:
{{range .Results}}
{{.Title}}
{{.Snippet}}
{{end}}
`))
)
const (
// prototypeTableName is an existing table containing some documents.
// Rebuilding a table will populate it with the data from this table.
prototypeTableName = "shakespearetemplate"
indexColumnFamily = "i"
contentColumnFamily = "c"
mainPage = `
Document Search
Search for documents:
Add a document:
Rebuild table:
`
)
func main() {
flag.Parse()
if *tableName == prototypeTableName {
log.Fatal("Can't use " + prototypeTableName + " as your table.")
}
// Let the library get credentials from file.
os.Setenv("GOOGLE_APPLICATION_CREDENTIALS", *credFile)
// Make an admin client.
var err error
if adminClient, err = bigtable.NewAdminClient(context.Background(), *project, *zone, *cluster); err != nil {
log.Fatal("Bigtable NewAdminClient:", err)
}
// Make a regular client.
client, err = bigtable.NewClient(context.Background(), *project, *zone, *cluster)
if err != nil {
log.Fatal("Bigtable NewClient:", err)
}
// Open the table.
table = client.Open(*tableName)
// Rebuild the table if the command-line flag is set.
if *rebuild {
if err := rebuildTable(); err != nil {
log.Fatal(err)
}
}
// Set up HTML handlers, and start the web server.
http.HandleFunc("/search", handleSearch)
http.HandleFunc("/content", handleContent)
http.HandleFunc("/add", handleAddDoc)
http.HandleFunc("/clearindex", handleClear)
http.HandleFunc("/", handleMain)
log.Fatal(http.ListenAndServe(":8080", nil))
}
// handleMain outputs the home page, containing a search box, an "add document" box, and "clear table" button.
func handleMain(w http.ResponseWriter, r *http.Request) {
io.WriteString(w, mainPage)
}
// tokenize splits a string into tokens.
// This is very simple, it's not a good tokenization function.
func tokenize(s string) []string {
wordMap := make(map[string]bool)
f := strings.FieldsFunc(s, func(r rune) bool { return !unicode.IsLetter(r) })
for _, word := range f {
word = strings.ToLower(word)
wordMap[word] = true
}
words := make([]string, 0, len(wordMap))
for word := range wordMap {
words = append(words, word)
}
return words
}
// handleContent fetches the content of a document from the Bigtable and returns it.
func handleContent(w http.ResponseWriter, r *http.Request) {
ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)
name := r.FormValue("name")
if len(name) == 0 {
http.Error(w, "No document name supplied.", http.StatusBadRequest)
return
}
row, err := table.ReadRow(ctx, name)
if err != nil {
http.Error(w, "Error reading content: "+err.Error(), http.StatusInternalServerError)
return
}
content := row[contentColumnFamily]
if len(content) == 0 {
http.Error(w, "Document not found.", http.StatusNotFound)
return
}
var buf bytes.Buffer
if err := contentTemplate.ExecuteTemplate(&buf, "", struct{ Title, Content string }{name, string(content[0].Value)}); err != nil {
http.Error(w, "Error executing HTML template: "+err.Error(), http.StatusInternalServerError)
return
}
io.Copy(w, &buf)
}
// handleSearch responds to search queries, returning links and snippets for matching documents.
func handleSearch(w http.ResponseWriter, r *http.Request) {
ctx, _ := context.WithTimeout(context.Background(), 10*time.Second)
query := r.FormValue("q")
// Split the query into words.
words := tokenize(query)
if len(words) == 0 {
http.Error(w, "Empty query.", http.StatusBadRequest)
return
}
// readRows reads from many rows concurrently.
readRows := func(rows []string) ([]bigtable.Row, error) {
results := make([]bigtable.Row, len(rows))
errors := make([]error, len(rows))
var wg sync.WaitGroup
for i, row := range rows {
wg.Add(1)
go func(i int, row string) {
defer wg.Done()
results[i], errors[i] = table.ReadRow(ctx, row)
}(i, row)
}
wg.Wait()
for _, err := range errors {
if err != nil {
return nil, err
}
}
return results, nil
}
// For each query word, get the list of documents containing it.
results, err := readRows(words)
if err != nil {
http.Error(w, "Error reading index: "+err.Error(), http.StatusInternalServerError)
return
}
// Count how many of the query words each result contained.
hits := make(map[string]int)
for _, r := range results {
for _, r := range r[indexColumnFamily] {
hits[r.Column]++
}
}
// Build a slice of all the documents that matched every query word.
var matches []string
for doc, count := range hits {
if count == len(words) {
matches = append(matches, doc[len(indexColumnFamily+":"):])
}
}
// Fetch the content of those documents from the Bigtable.
content, err := readRows(matches)
if err != nil {
http.Error(w, "Error reading results: "+err.Error(), http.StatusInternalServerError)
return
}
type result struct{ Title, Snippet string }
data := struct {
Query string
Results []result
}{query, nil}
// Output links and snippets.
for i, doc := range matches {
var text string
c := content[i][contentColumnFamily]
if len(c) > 0 {
text = string(c[0].Value)
}
if len(text) > 100 {
text = text[:100] + "..."
}
data.Results = append(data.Results, result{doc, text})
}
var buf bytes.Buffer
if err := searchTemplate.ExecuteTemplate(&buf, "", data); err != nil {
http.Error(w, "Error executing HTML template: "+err.Error(), http.StatusInternalServerError)
return
}
io.Copy(w, &buf)
}
// handleAddDoc adds a document to the index.
func handleAddDoc(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
http.Error(w, "POST requests only", http.StatusMethodNotAllowed)
return
}
ctx, _ := context.WithTimeout(context.Background(), time.Minute)
name := r.FormValue("name")
if len(name) == 0 {
http.Error(w, "Empty document name!", http.StatusBadRequest)
return
}
content := r.FormValue("content")
if len(content) == 0 {
http.Error(w, "Empty document content!", http.StatusBadRequest)
return
}
var (
writeErr error // Set if any write fails.
mu sync.Mutex // Protects writeErr
wg sync.WaitGroup // Used to wait for all writes to finish.
)
// writeOneColumn writes one column in one row, updates err if there is an error,
// and signals wg that one operation has finished.
writeOneColumn := func(row, family, column, value string, ts bigtable.Timestamp) {
mut := bigtable.NewMutation()
mut.Set(family, column, ts, []byte(value))
err := table.Apply(ctx, row, mut)
if err != nil {
mu.Lock()
writeErr = err
mu.Unlock()
}
}
// Start a write to store the document content.
wg.Add(1)
go func() {
writeOneColumn(name, contentColumnFamily, "", content, bigtable.Now())
wg.Done()
}()
// Start writes to store the document name in the index for each word in the document.
words := tokenize(content)
for _, word := range words {
var (
row = word
family = indexColumnFamily
column = name
value = ""
ts = bigtable.Now()
)
wg.Add(1)
go func() {
// TODO: should use a semaphore to limit the number of concurrent writes.
writeOneColumn(row, family, column, value, ts)
wg.Done()
}()
}
wg.Wait()
if writeErr != nil {
http.Error(w, "Error writing to Bigtable: "+writeErr.Error(), http.StatusInternalServerError)
return
}
var buf bytes.Buffer
if err := addTemplate.ExecuteTemplate(&buf, "", struct{ Title string }{name}); err != nil {
http.Error(w, "Error executing HTML template: "+err.Error(), http.StatusInternalServerError)
return
}
io.Copy(w, &buf)
}
// rebuildTable deletes the table if it exists, then creates the table, with the index column family.
func rebuildTable() error {
ctx, _ := context.WithTimeout(context.Background(), 5*time.Minute)
adminClient.DeleteTable(ctx, *tableName)
if err := adminClient.CreateTable(ctx, *tableName); err != nil {
return fmt.Errorf("CreateTable: %v", err)
}
time.Sleep(20 * time.Second)
if err := adminClient.CreateColumnFamily(ctx, *tableName, indexColumnFamily); err != nil {
return fmt.Errorf("CreateColumnFamily: %v", err)
}
if err := adminClient.CreateColumnFamily(ctx, *tableName, contentColumnFamily); err != nil {
return fmt.Errorf("CreateColumnFamily: %v", err)
}
// Open the prototype table. It contains a number of documents to get started with.
prototypeTable := client.Open(prototypeTableName)
var (
writeErr error // Set if any write fails.
mu sync.Mutex // Protects writeErr
wg sync.WaitGroup // Used to wait for all writes to finish.
)
copyRowToTable := func(row bigtable.Row) bool {
mu.Lock()
failed := writeErr != nil
mu.Unlock()
if failed {
return false
}
mut := bigtable.NewMutation()
for family, items := range row {
for _, item := range items {
// Get the column name, excluding the column family name and ':' character.
columnWithoutFamily := item.Column[len(family)+1:]
mut.Set(family, columnWithoutFamily, bigtable.Now(), item.Value)
}
}
wg.Add(1)
go func() {
// TODO: should use a semaphore to limit the number of concurrent writes.
if err := table.Apply(ctx, row.Key(), mut); err != nil {
mu.Lock()
writeErr = err
mu.Unlock()
}
wg.Done()
}()
return true
}
// Create a filter that only accepts the column families we're interested in.
filter := bigtable.FamilyFilter(indexColumnFamily + "|" + contentColumnFamily)
// Read every row from prototypeTable, and call copyRowToTable to copy it to our table.
err := prototypeTable.ReadRows(ctx, bigtable.InfiniteRange(""), copyRowToTable, bigtable.RowFilter(filter))
wg.Wait()
if err != nil {
return err
}
return writeErr
}
// handleClear calls rebuildTable
func handleClear(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
http.Error(w, "POST requests only", http.StatusMethodNotAllowed)
return
}
if err := rebuildTable(); err != nil {
http.Error(w, "Failed to rebuild index: "+err.Error(), http.StatusInternalServerError)
return
}
fmt.Fprint(w, "Rebuilt index.\n")
}
================================================
FILE: vendor/google.golang.org/cloud/cloud.go
================================================
// Copyright 2014 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Package cloud contains Google Cloud Platform APIs related types
// and common functions.
package cloud
import (
"net/http"
"golang.org/x/net/context"
"google.golang.org/cloud/internal"
)
// NewContext returns a new context that uses the provided http.Client.
// Provided http.Client is responsible to authorize and authenticate
// the requests made to the Google Cloud APIs.
// It mutates the client's original Transport to append the cloud
// package's user-agent to the outgoing requests.
// You can obtain the project ID from the Google Developers Console,
// https://console.developers.google.com.
func NewContext(projID string, c *http.Client) context.Context {
if c == nil {
panic("invalid nil *http.Client passed to NewContext")
}
return WithContext(context.Background(), projID, c)
}
// WithContext returns a new context in a similar way NewContext does,
// but initiates the new context with the specified parent.
func WithContext(parent context.Context, projID string, c *http.Client) context.Context {
// TODO(bradfitz): delete internal.Transport. It's too wrappy for what it does.
// Do User-Agent some other way.
if _, ok := c.Transport.(*internal.Transport); !ok {
c.Transport = &internal.Transport{Base: c.Transport}
}
return internal.WithContext(parent, projID, c)
}
================================================
FILE: vendor/google.golang.org/cloud/compute/metadata/metadata.go
================================================
// Copyright 2014 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Package metadata provides access to Google Compute Engine (GCE)
// metadata and API service accounts.
//
// This package is a wrapper around the GCE metadata service,
// as documented at https://developers.google.com/compute/docs/metadata.
package metadata
import (
"encoding/json"
"fmt"
"io/ioutil"
"net"
"net/http"
"os"
"strings"
"sync"
"time"
"google.golang.org/cloud/internal"
)
type cachedValue struct {
k string
trim bool
mu sync.Mutex
v string
}
var (
projID = &cachedValue{k: "project/project-id", trim: true}
projNum = &cachedValue{k: "project/numeric-project-id", trim: true}
instID = &cachedValue{k: "instance/id", trim: true}
)
var metaClient = &http.Client{
Transport: &internal.Transport{
Base: &http.Transport{
Dial: (&net.Dialer{
Timeout: 750 * time.Millisecond,
KeepAlive: 30 * time.Second,
}).Dial,
ResponseHeaderTimeout: 750 * time.Millisecond,
},
},
}
// NotDefinedError is returned when requested metadata is not defined.
//
// The underlying string is the suffix after "/computeMetadata/v1/".
//
// This error is not returned if the value is defined to be the empty
// string.
type NotDefinedError string
func (suffix NotDefinedError) Error() string {
return fmt.Sprintf("metadata: GCE metadata %q not defined", string(suffix))
}
// Get returns a value from the metadata service.
// The suffix is appended to "http://${GCE_METADATA_HOST}/computeMetadata/v1/".
//
// If the GCE_METADATA_HOST environment variable is not defined, a default of
// 169.254.169.254 will be used instead.
//
// If the requested metadata is not defined, the returned error will
// be of type NotDefinedError.
func Get(suffix string) (string, error) {
// Using a fixed IP makes it very difficult to spoof the metadata service in
// a container, which is an important use-case for local testing of cloud
// deployments. To enable spoofing of the metadata service, the environment
// variable GCE_METADATA_HOST is first inspected to decide where metadata
// requests shall go.
host := os.Getenv("GCE_METADATA_HOST")
if host == "" {
// Using 169.254.169.254 instead of "metadata" here because Go
// binaries built with the "netgo" tag and without cgo won't
// know the search suffix for "metadata" is
// ".google.internal", and this IP address is documented as
// being stable anyway.
host = "169.254.169.254"
}
url := "http://" + host + "/computeMetadata/v1/" + suffix
req, _ := http.NewRequest("GET", url, nil)
req.Header.Set("Metadata-Flavor", "Google")
res, err := metaClient.Do(req)
if err != nil {
return "", err
}
defer res.Body.Close()
if res.StatusCode == http.StatusNotFound {
return "", NotDefinedError(suffix)
}
if res.StatusCode != 200 {
return "", fmt.Errorf("status code %d trying to fetch %s", res.StatusCode, url)
}
all, err := ioutil.ReadAll(res.Body)
if err != nil {
return "", err
}
return string(all), nil
}
func getTrimmed(suffix string) (s string, err error) {
s, err = Get(suffix)
s = strings.TrimSpace(s)
return
}
func (c *cachedValue) get() (v string, err error) {
defer c.mu.Unlock()
c.mu.Lock()
if c.v != "" {
return c.v, nil
}
if c.trim {
v, err = getTrimmed(c.k)
} else {
v, err = Get(c.k)
}
if err == nil {
c.v = v
}
return
}
var onGCE struct {
sync.Mutex
set bool
v bool
}
// OnGCE reports whether this process is running on Google Compute Engine.
func OnGCE() bool {
defer onGCE.Unlock()
onGCE.Lock()
if onGCE.set {
return onGCE.v
}
onGCE.set = true
// We use the DNS name of the metadata service here instead of the IP address
// because we expect that to fail faster in the not-on-GCE case.
res, err := metaClient.Get("http://metadata.google.internal")
if err != nil {
return false
}
onGCE.v = res.Header.Get("Metadata-Flavor") == "Google"
return onGCE.v
}
// ProjectID returns the current instance's project ID string.
func ProjectID() (string, error) { return projID.get() }
// NumericProjectID returns the current instance's numeric project ID.
func NumericProjectID() (string, error) { return projNum.get() }
// InternalIP returns the instance's primary internal IP address.
func InternalIP() (string, error) {
return getTrimmed("instance/network-interfaces/0/ip")
}
// ExternalIP returns the instance's primary external (public) IP address.
func ExternalIP() (string, error) {
return getTrimmed("instance/network-interfaces/0/access-configs/0/external-ip")
}
// Hostname returns the instance's hostname. This will be of the form
// ".c..internal".
func Hostname() (string, error) {
return getTrimmed("instance/hostname")
}
// InstanceTags returns the list of user-defined instance tags,
// assigned when initially creating a GCE instance.
func InstanceTags() ([]string, error) {
var s []string
j, err := Get("instance/tags")
if err != nil {
return nil, err
}
if err := json.NewDecoder(strings.NewReader(j)).Decode(&s); err != nil {
return nil, err
}
return s, nil
}
// InstanceID returns the current VM's numeric instance ID.
func InstanceID() (string, error) {
return instID.get()
}
// InstanceName returns the current VM's instance ID string.
func InstanceName() (string, error) {
host, err := Hostname()
if err != nil {
return "", err
}
return strings.Split(host, ".")[0], nil
}
// Zone returns the current VM's zone, such as "us-central1-b".
func Zone() (string, error) {
zone, err := getTrimmed("instance/zone")
// zone is of the form "projects//zones/".
if err != nil {
return "", err
}
return zone[strings.LastIndex(zone, "/")+1:], nil
}
// InstanceAttributes returns the list of user-defined attributes,
// assigned when initially creating a GCE VM instance. The value of an
// attribute can be obtained with InstanceAttributeValue.
func InstanceAttributes() ([]string, error) { return lines("instance/attributes/") }
// ProjectAttributes returns the list of user-defined attributes
// applying to the project as a whole, not just this VM. The value of
// an attribute can be obtained with ProjectAttributeValue.
func ProjectAttributes() ([]string, error) { return lines("project/attributes/") }
func lines(suffix string) ([]string, error) {
j, err := Get(suffix)
if err != nil {
return nil, err
}
s := strings.Split(strings.TrimSpace(j), "\n")
for i := range s {
s[i] = strings.TrimSpace(s[i])
}
return s, nil
}
// InstanceAttributeValue returns the value of the provided VM
// instance attribute.
//
// If the requested attribute is not defined, the returned error will
// be of type NotDefinedError.
//
// InstanceAttributeValue may return ("", nil) if the attribute was
// defined to be the empty string.
func InstanceAttributeValue(attr string) (string, error) {
return Get("instance/attributes/" + attr)
}
// ProjectAttributeValue returns the value of the provided
// project attribute.
//
// If the requested attribute is not defined, the returned error will
// be of type NotDefinedError.
//
// ProjectAttributeValue may return ("", nil) if the attribute was
// defined to be the empty string.
func ProjectAttributeValue(attr string) (string, error) {
return Get("project/attributes/" + attr)
}
// Scopes returns the service account scopes for the given account.
// The account may be empty or the string "default" to use the instance's
// main account.
func Scopes(serviceAccount string) ([]string, error) {
if serviceAccount == "" {
serviceAccount = "default"
}
return lines("instance/service-accounts/" + serviceAccount + "/scopes")
}
================================================
FILE: vendor/google.golang.org/cloud/container/container.go
================================================
// Copyright 2014 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Package container contains a Google Container Engine client.
//
// For more information about the API,
// see https://cloud.google.com/container-engine/docs
package container
import (
"errors"
"net/http"
"time"
"golang.org/x/net/context"
raw "google.golang.org/api/container/v1beta1"
"google.golang.org/cloud/internal"
)
type Type string
var (
TypeCreate Type = Type("createCluster")
TypeDelete Type = Type("deleteCluster")
)
type Status string
var (
Done = Status("done")
Pending = Status("pending")
Running = Status("running")
Error = Status("error")
Provisioning = Status("provisioning")
Stopping = Status("stopping")
)
// Resource is a Google Container Engine cluster resource.
type Resource struct {
// Name is the name of this cluster. The name must be unique
// within this project and zone, and can be up to 40 characters.
Name string
// Description is the description of the cluster. Optional.
Description string
// Zone is the Google Compute Engine zone in which the cluster resides.
Zone string
// Status is the current status of the cluster. It could either be
// StatusError, StatusProvisioning, StatusRunning or StatusStopping.
Status Status
// Num is the number of the nodes in this cluster resource.
Num int64
// APIVersion is the version of the Kubernetes master and kubelets running
// in this cluster. Allowed value is 0.4.2, or leave blank to
// pick up the latest stable release.
APIVersion string
// Endpoint is the IP address of this cluster's Kubernetes master.
// The endpoint can be accessed at https://username:password@endpoint/.
// See Username and Password fields for the username and password information.
Endpoint string
// Username is the username to use when accessing the Kubernetes master endpoint.
Username string
// Password is the password to use when accessing the Kubernetes master endpoint.
Password string
// ContainerIPv4CIDR is the IP addresses of the container pods in
// this cluster, in CIDR notation (e.g. 1.2.3.4/29).
ContainerIPv4CIDR string
// ServicesIPv4CIDR is the IP addresses of the Kubernetes services in this
// cluster, in CIDR notation (e.g. 1.2.3.4/29). Service addresses are
// always in the 10.0.0.0/16 range.
ServicesIPv4CIDR string
// MachineType is a Google Compute Engine machine type (e.g. n1-standard-1).
// If none set, the default type is used while creating a new cluster.
MachineType string
// SourceImage is the fully-specified name of a Google Compute Engine image.
// For example: https://www.googleapis.com/compute/v1/projects/debian-cloud/global/images/backports-debian-7-wheezy-vYYYYMMDD.
SourceImage string
// Created is the creation time of this cluster.
Created time.Time
}
func resourceFromRaw(c *raw.Cluster) *Resource {
if c == nil {
return nil
}
r := &Resource{
Name: c.Name,
Description: c.Description,
Zone: c.Zone,
Status: Status(c.Status),
Num: c.NumNodes,
APIVersion: c.ClusterApiVersion,
Endpoint: c.Endpoint,
Username: c.MasterAuth.User,
Password: c.MasterAuth.Password,
ContainerIPv4CIDR: c.ContainerIpv4Cidr,
ServicesIPv4CIDR: c.ServicesIpv4Cidr,
MachineType: c.NodeConfig.MachineType,
SourceImage: c.NodeConfig.SourceImage,
}
r.Created, _ = time.Parse(time.RFC3339, c.CreationTimestamp)
return r
}
func resourcesFromRaw(c []*raw.Cluster) []*Resource {
r := make([]*Resource, len(c))
for i, val := range c {
r[i] = resourceFromRaw(val)
}
return r
}
// Op represents a Google Container Engine API operation.
type Op struct {
// Name is the name of the operation.
Name string
// Zone is the Google Compute Engine zone.
Zone string
// TargetURL is the URL of the cluster resource
// that this operation is associated with.
TargetURL string
// Type is the operation type. It could be either be TypeCreate or TypeDelete.
Type Type
// Status is the current status of this operation. It could be either
// OpDone or OpPending.
Status Status
}
func opFromRaw(o *raw.Operation) *Op {
if o == nil {
return nil
}
return &Op{
Name: o.Name,
Zone: o.Zone,
TargetURL: o.Target,
Type: Type(o.OperationType),
Status: Status(o.Status),
}
}
func opsFromRaw(o []*raw.Operation) []*Op {
ops := make([]*Op, len(o))
for i, val := range o {
ops[i] = opFromRaw(val)
}
return ops
}
// Clusters returns a list of cluster resources from the specified zone.
// If no zone is specified, it returns all clusters under the user project.
func Clusters(ctx context.Context, zone string) ([]*Resource, error) {
s := rawService(ctx)
if zone == "" {
resp, err := s.Projects.Clusters.List(internal.ProjID(ctx)).Do()
if err != nil {
return nil, err
}
return resourcesFromRaw(resp.Clusters), nil
}
resp, err := s.Projects.Zones.Clusters.List(internal.ProjID(ctx), zone).Do()
if err != nil {
return nil, err
}
return resourcesFromRaw(resp.Clusters), nil
}
// Cluster returns metadata about the specified cluster.
func Cluster(ctx context.Context, zone, name string) (*Resource, error) {
s := rawService(ctx)
resp, err := s.Projects.Zones.Clusters.Get(internal.ProjID(ctx), zone, name).Do()
if err != nil {
return nil, err
}
return resourceFromRaw(resp), nil
}
// CreateCluster creates a new cluster with the provided metadata
// in the specified zone.
func CreateCluster(ctx context.Context, zone string, resource *Resource) (*Resource, error) {
panic("not implemented")
}
// DeleteCluster deletes a cluster.
func DeleteCluster(ctx context.Context, zone, name string) error {
s := rawService(ctx)
_, err := s.Projects.Zones.Clusters.Delete(internal.ProjID(ctx), zone, name).Do()
return err
}
// Operations returns a list of operations from the specified zone.
// If no zone is specified, it looks up for all of the operations
// that are running under the user's project.
func Operations(ctx context.Context, zone string) ([]*Op, error) {
s := rawService(ctx)
if zone == "" {
resp, err := s.Projects.Operations.List(internal.ProjID(ctx)).Do()
if err != nil {
return nil, err
}
return opsFromRaw(resp.Operations), nil
}
resp, err := s.Projects.Zones.Operations.List(internal.ProjID(ctx), zone).Do()
if err != nil {
return nil, err
}
return opsFromRaw(resp.Operations), nil
}
// Operation returns an operation.
func Operation(ctx context.Context, zone, name string) (*Op, error) {
s := rawService(ctx)
resp, err := s.Projects.Zones.Operations.Get(internal.ProjID(ctx), zone, name).Do()
if err != nil {
return nil, err
}
if resp.ErrorMessage != "" {
return nil, errors.New(resp.ErrorMessage)
}
return opFromRaw(resp), nil
}
func rawService(ctx context.Context) *raw.Service {
return internal.Service(ctx, "container", func(hc *http.Client) interface{} {
svc, _ := raw.New(hc)
return svc
}).(*raw.Service)
}
================================================
FILE: vendor/google.golang.org/cloud/datastore/datastore.go
================================================
// Copyright 2014 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Package datastore contains a Google Cloud Datastore client.
//
// This package is experimental and may make backwards-incompatible changes.
package datastore
import (
"bytes"
"errors"
"fmt"
"io/ioutil"
"net/http"
"reflect"
"github.com/golang/protobuf/proto"
"golang.org/x/net/context"
"google.golang.org/cloud/internal"
pb "google.golang.org/cloud/internal/datastore"
)
// ContextKey represents a context key specific to the datastore
type ContextKey string
const (
// ScopeDatastore grants permissions to view and/or manage datastore entities
ScopeDatastore = "https://www.googleapis.com/auth/datastore"
// ScopeUserEmail grants permission to view the user's email address.
// It is required to access the datastore
ScopeUserEmail = "https://www.googleapis.com/auth/userinfo.email"
)
var (
// ErrInvalidEntityType is returned when functions like Get or Next are
// passed a dst or src argument of invalid type.
ErrInvalidEntityType = errors.New("datastore: invalid entity type")
// ErrInvalidKey is returned when an invalid key is presented.
ErrInvalidKey = errors.New("datastore: invalid key")
// ErrNoSuchEntity is returned when no entity was found for a given key.
ErrNoSuchEntity = errors.New("datastore: no such entity")
)
type multiArgType int
const (
multiArgTypeInvalid multiArgType = iota
multiArgTypePropertyLoadSaver
multiArgTypeStruct
multiArgTypeStructPtr
multiArgTypeInterface
)
// nsKey is the type of the context.Context key to store the datastore
// namespace.
type nsKey struct{}
// WithNamespace returns a new context that limits the scope its parent
// context with a Datastore namespace.
func WithNamespace(parent context.Context, namespace string) context.Context {
return context.WithValue(parent, nsKey{}, namespace)
}
// ctxNamespace returns the active namespace for a context.
// It defaults to "" if no namespace was specified.
func ctxNamespace(ctx context.Context) string {
v, _ := ctx.Value(nsKey{}).(string)
return v
}
// ErrFieldMismatch is returned when a field is to be loaded into a different
// type than the one it was stored from, or when a field is missing or
// unexported in the destination struct.
// StructType is the type of the struct pointed to by the destination argument
// passed to Get or to Iterator.Next.
type ErrFieldMismatch struct {
StructType reflect.Type
FieldName string
Reason string
}
// errHTTP is returned when responds is a non-200 HTTP response.
type errHTTP struct {
StatusCode int
Body string
err error
}
func (e *errHTTP) Error() string {
if e.err == nil {
return fmt.Sprintf("error during call, http status code: %v %s", e.StatusCode, e.Body)
}
return e.err.Error()
}
func (e *ErrFieldMismatch) Error() string {
return fmt.Sprintf("datastore: cannot load field %q into a %q: %s",
e.FieldName, e.StructType, e.Reason)
}
// baseUrl gets the base url active for the datastore service
// defaults to "https://www.googleapis.com/datastore/v1beta2/datasets/" if none was specified
func baseUrl(ctx context.Context) string {
v := ctx.Value(ContextKey("base_url"))
if v == nil {
return "https://www.googleapis.com/datastore/v1beta2/datasets/"
} else {
return v.(string)
}
}
func call(ctx context.Context, method string, req proto.Message, resp proto.Message) error {
payload, err := proto.Marshal(req)
if err != nil {
return err
}
url := baseUrl(ctx) + internal.ProjID(ctx) + "/" + method
r, err := internal.HTTPClient(ctx).Post(url, "application/x-protobuf", bytes.NewReader(payload))
if err != nil {
return err
}
defer r.Body.Close()
all, err := ioutil.ReadAll(r.Body)
if r.StatusCode != http.StatusOK {
e := &errHTTP{
StatusCode: r.StatusCode,
err: err,
}
if err == nil {
e.Body = string(all)
}
return e
}
if err != nil {
return err
}
if err = proto.Unmarshal(all, resp); err != nil {
return err
}
return nil
}
func keyToProto(k *Key) *pb.Key {
if k == nil {
return nil
}
// TODO(jbd): Eliminate unrequired allocations.
path := []*pb.Key_PathElement(nil)
for {
el := &pb.Key_PathElement{
Kind: proto.String(k.kind),
}
if k.id != 0 {
el.Id = proto.Int64(k.id)
}
if k.name != "" {
el.Name = proto.String(k.name)
}
path = append([]*pb.Key_PathElement{el}, path...)
if k.parent == nil {
break
}
k = k.parent
}
key := &pb.Key{
PathElement: path,
}
if k.namespace != "" {
key.PartitionId = &pb.PartitionId{
Namespace: proto.String(k.namespace),
}
}
return key
}
func protoToKey(p *pb.Key) *Key {
keys := make([]*Key, len(p.GetPathElement()))
for i, el := range p.GetPathElement() {
keys[i] = &Key{
namespace: p.GetPartitionId().GetNamespace(),
kind: el.GetKind(),
id: el.GetId(),
name: el.GetName(),
}
}
for i := 0; i < len(keys)-1; i++ {
keys[i+1].parent = keys[i]
}
return keys[len(keys)-1]
}
// multiKeyToProto is a batch version of keyToProto.
func multiKeyToProto(keys []*Key) []*pb.Key {
ret := make([]*pb.Key, len(keys))
for i, k := range keys {
ret[i] = keyToProto(k)
}
return ret
}
// multiKeyToProto is a batch version of keyToProto.
func multiProtoToKey(keys []*pb.Key) []*Key {
ret := make([]*Key, len(keys))
for i, k := range keys {
ret[i] = protoToKey(k)
}
return ret
}
// multiValid is a batch version of Key.valid. It returns an error, not a
// []bool.
func multiValid(key []*Key) error {
invalid := false
for _, k := range key {
if !k.valid() {
invalid = true
break
}
}
if !invalid {
return nil
}
err := make(MultiError, len(key))
for i, k := range key {
if !k.valid() {
err[i] = ErrInvalidKey
}
}
return err
}
// checkMultiArg checks that v has type []S, []*S, []I, or []P, for some struct
// type S, for some interface type I, or some non-interface non-pointer type P
// such that P or *P implements PropertyLoadSaver.
//
// It returns what category the slice's elements are, and the reflect.Type
// that represents S, I or P.
//
// As a special case, PropertyList is an invalid type for v.
func checkMultiArg(v reflect.Value) (m multiArgType, elemType reflect.Type) {
if v.Kind() != reflect.Slice {
return multiArgTypeInvalid, nil
}
if v.Type() == typeOfPropertyList {
return multiArgTypeInvalid, nil
}
elemType = v.Type().Elem()
if reflect.PtrTo(elemType).Implements(typeOfPropertyLoadSaver) {
return multiArgTypePropertyLoadSaver, elemType
}
switch elemType.Kind() {
case reflect.Struct:
return multiArgTypeStruct, elemType
case reflect.Interface:
return multiArgTypeInterface, elemType
case reflect.Ptr:
elemType = elemType.Elem()
if elemType.Kind() == reflect.Struct {
return multiArgTypeStructPtr, elemType
}
}
return multiArgTypeInvalid, nil
}
// Get loads the entity stored for key into dst, which must be a struct pointer
// or implement PropertyLoadSaver. If there is no such entity for the key, Get
// returns ErrNoSuchEntity.
//
// The values of dst's unmatched struct fields are not modified, and matching
// slice-typed fields are not reset before appending to them. In particular, it
// is recommended to pass a pointer to a zero valued struct on each Get call.
//
// ErrFieldMismatch is returned when a field is to be loaded into a different
// type than the one it was stored from, or when a field is missing or
// unexported in the destination struct. ErrFieldMismatch is only returned if
// dst is a struct pointer.
func Get(ctx context.Context, key *Key, dst interface{}) error {
err := get(ctx, []*Key{key}, []interface{}{dst}, nil)
if me, ok := err.(MultiError); ok {
return me[0]
}
return err
}
// GetMulti is a batch version of Get.
//
// dst must be a []S, []*S, []I or []P, for some struct type S, some interface
// type I, or some non-interface non-pointer type P such that P or *P
// implements PropertyLoadSaver. If an []I, each element must be a valid dst
// for Get: it must be a struct pointer or implement PropertyLoadSaver.
//
// As a special case, PropertyList is an invalid type for dst, even though a
// PropertyList is a slice of structs. It is treated as invalid to avoid being
// mistakenly passed when []PropertyList was intended.
func GetMulti(ctx context.Context, keys []*Key, dst interface{}) error {
return get(ctx, keys, dst, nil)
}
func get(ctx context.Context, keys []*Key, dst interface{}, opts *pb.ReadOptions) error {
v := reflect.ValueOf(dst)
multiArgType, _ := checkMultiArg(v)
// Sanity checks
if multiArgType == multiArgTypeInvalid {
return errors.New("datastore: dst has invalid type")
}
if len(keys) != v.Len() {
return errors.New("datastore: keys and dst slices have different length")
}
if len(keys) == 0 {
return nil
}
// Go through keys, validate them, serialize then, and create a dict mapping them to their index
multiErr, any := make(MultiError, len(keys)), false
keyMap := make(map[string]int)
pbKeys := make([]*pb.Key, len(keys))
for i, k := range keys {
if !k.valid() {
multiErr[i] = ErrInvalidKey
any = true
} else {
keyMap[k.String()] = i
pbKeys[i] = keyToProto(k)
}
}
if any {
return multiErr
}
req := &pb.LookupRequest{
Key: pbKeys,
ReadOptions: opts,
}
resp := &pb.LookupResponse{}
if err := call(ctx, "lookup", req, resp); err != nil {
return err
}
if len(resp.Deferred) > 0 {
// TODO(jbd): Assess whether we should retry the deferred keys.
return errors.New("datastore: some entities temporarily unavailable")
}
if len(keys) != len(resp.Found)+len(resp.Missing) {
return errors.New("datastore: internal error: server returned the wrong number of entities")
}
for _, e := range resp.Found {
k := protoToKey(e.Entity.Key)
index := keyMap[k.String()]
elem := v.Index(index)
if multiArgType == multiArgTypePropertyLoadSaver || multiArgType == multiArgTypeStruct {
elem = elem.Addr()
}
err := loadEntity(elem.Interface(), e.Entity)
if err != nil {
multiErr[index] = err
any = true
}
}
for _, e := range resp.Missing {
k := protoToKey(e.Entity.Key)
multiErr[keyMap[k.String()]] = ErrNoSuchEntity
any = true
}
if any {
return multiErr
}
return nil
}
// Put saves the entity src into the datastore with key k. src must be a struct
// pointer or implement PropertyLoadSaver; if a struct pointer then any
// unexported fields of that struct will be skipped. If k is an incomplete key,
// the returned key will be a unique key generated by the datastore.
func Put(ctx context.Context, key *Key, src interface{}) (*Key, error) {
k, err := PutMulti(ctx, []*Key{key}, []interface{}{src})
if err != nil {
if me, ok := err.(MultiError); ok {
return nil, me[0]
}
return nil, err
}
return k[0], nil
}
// PutMulti is a batch version of Put.
//
// src must satisfy the same conditions as the dst argument to GetMulti.
func PutMulti(ctx context.Context, keys []*Key, src interface{}) ([]*Key, error) {
mutation, err := putMutation(keys, src)
if err != nil {
return nil, err
}
// Make the request.
req := &pb.CommitRequest{
Mutation: mutation,
Mode: pb.CommitRequest_NON_TRANSACTIONAL.Enum(),
}
resp := &pb.CommitResponse{}
if err := call(ctx, "commit", req, resp); err != nil {
return nil, err
}
// Copy any newly minted keys into the returned keys.
newKeys := make(map[int]int) // Map of index in returned slice to index in response.
ret := make([]*Key, len(keys))
var idx int
for i, key := range keys {
if key.Incomplete() {
// This key will be in the mutation result.
newKeys[i] = idx
idx++
} else {
ret[i] = key
}
}
if len(newKeys) != len(resp.MutationResult.InsertAutoIdKey) {
return nil, errors.New("datastore: internal error: server returned the wrong number of keys")
}
for retI, respI := range newKeys {
ret[retI] = protoToKey(resp.MutationResult.InsertAutoIdKey[respI])
}
return ret, nil
}
func putMutation(keys []*Key, src interface{}) (*pb.Mutation, error) {
v := reflect.ValueOf(src)
multiArgType, _ := checkMultiArg(v)
if multiArgType == multiArgTypeInvalid {
return nil, errors.New("datastore: src has invalid type")
}
if len(keys) != v.Len() {
return nil, errors.New("datastore: key and src slices have different length")
}
if len(keys) == 0 {
return nil, nil
}
if err := multiValid(keys); err != nil {
return nil, err
}
var upsert, insert []*pb.Entity
for i, k := range keys {
val := reflect.ValueOf(src).Index(i)
// If src is an interface slice []interface{}{ent1, ent2}
if val.Kind() == reflect.Interface && val.Elem().Kind() == reflect.Slice {
val = val.Elem()
}
// If src is a slice of ptrs []*T{ent1, ent2}
if val.Kind() == reflect.Ptr && val.Elem().Kind() == reflect.Slice {
val = val.Elem()
}
p, err := saveEntity(k, val.Interface())
if err != nil {
return nil, fmt.Errorf("datastore: Error while saving %v: %v", k.String(), err)
}
if k.Incomplete() {
insert = append(insert, p)
} else {
upsert = append(upsert, p)
}
}
return &pb.Mutation{
InsertAutoId: insert,
Upsert: upsert,
}, nil
}
// Delete deletes the entity for the given key.
func Delete(ctx context.Context, key *Key) error {
err := DeleteMulti(ctx, []*Key{key})
if me, ok := err.(MultiError); ok {
return me[0]
}
return err
}
// DeleteMulti is a batch version of Delete.
func DeleteMulti(ctx context.Context, keys []*Key) error {
mutation, err := deleteMutation(keys)
if err != nil {
return err
}
req := &pb.CommitRequest{
Mutation: mutation,
Mode: pb.CommitRequest_NON_TRANSACTIONAL.Enum(),
}
resp := &pb.CommitResponse{}
return call(ctx, "commit", req, resp)
}
func deleteMutation(keys []*Key) (*pb.Mutation, error) {
protoKeys := make([]*pb.Key, len(keys))
for i, k := range keys {
if k.Incomplete() {
return nil, fmt.Errorf("datastore: can't delete the incomplete key: %v", k)
}
protoKeys[i] = keyToProto(k)
}
return &pb.Mutation{
Delete: protoKeys,
}, nil
}
================================================
FILE: vendor/google.golang.org/cloud/datastore/errors.go
================================================
// Copyright 2014 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// This file provides error functions for common API failure modes.
package datastore
import (
"fmt"
)
// MultiError is returned by batch operations when there are errors with
// particular elements. Errors will be in a one-to-one correspondence with
// the input elements; successful elements will have a nil entry.
type MultiError []error
func (m MultiError) Error() string {
s, n := "", 0
for _, e := range m {
if e != nil {
if n == 0 {
s = e.Error()
}
n++
}
}
switch n {
case 0:
return "(0 errors)"
case 1:
return s
case 2:
return s + " (and 1 other error)"
}
return fmt.Sprintf("%s (and %d other errors)", s, n-1)
}
================================================
FILE: vendor/google.golang.org/cloud/datastore/key.go
================================================
// Copyright 2014 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package datastore
import (
"bytes"
"encoding/base64"
"encoding/gob"
"errors"
"strconv"
"strings"
"github.com/golang/protobuf/proto"
"golang.org/x/net/context"
pb "google.golang.org/cloud/internal/datastore"
)
// Key represents the datastore key for a stored entity, and is immutable.
type Key struct {
kind string
id int64
name string
parent *Key
namespace string
}
func (k *Key) Kind() string {
return k.kind
}
func (k *Key) ID() int64 {
return k.id
}
func (k *Key) Name() string {
return k.name
}
func (k *Key) Parent() *Key {
return k.parent
}
func (k *Key) SetParent(v *Key) {
if v.Incomplete() {
panic("can't set an incomplete key as parent")
}
k.parent = v
}
func (k *Key) Namespace() string {
return k.namespace
}
// Complete returns whether the key does not refer to a stored entity.
func (k *Key) Incomplete() bool {
return k.name == "" && k.id == 0
}
// valid returns whether the key is valid.
func (k *Key) valid() bool {
if k == nil {
return false
}
for ; k != nil; k = k.parent {
if k.kind == "" {
return false
}
if k.name != "" && k.id != 0 {
return false
}
if k.parent != nil {
if k.parent.Incomplete() {
return false
}
if k.parent.namespace != k.namespace {
return false
}
}
}
return true
}
func (k *Key) Equal(o *Key) bool {
for {
if k == nil || o == nil {
return k == o // if either is nil, both must be nil
}
if k.namespace != o.namespace || k.name != o.name || k.id != o.id || k.kind != o.kind {
return false
}
if k.parent == nil && o.parent == nil {
return true
}
k = k.parent
o = o.parent
}
}
// marshal marshals the key's string representation to the buffer.
func (k *Key) marshal(b *bytes.Buffer) {
if k.parent != nil {
k.parent.marshal(b)
}
b.WriteByte('/')
b.WriteString(k.kind)
b.WriteByte(',')
if k.name != "" {
b.WriteString(k.name)
} else {
b.WriteString(strconv.FormatInt(k.id, 10))
}
}
// String returns a string representation of the key.
func (k *Key) String() string {
if k == nil {
return ""
}
b := bytes.NewBuffer(make([]byte, 0, 512))
k.marshal(b)
return b.String()
}
// Note: Fields not renamed compared to appengine gobKey struct
// This ensures gobs created by appengine can be read here, and vice/versa
type gobKey struct {
Kind string
StringID string
IntID int64
Parent *gobKey
AppID string
Namespace string
}
func keyToGobKey(k *Key) *gobKey {
if k == nil {
return nil
}
return &gobKey{
Kind: k.kind,
StringID: k.name,
IntID: k.id,
Parent: keyToGobKey(k.parent),
Namespace: k.namespace,
}
}
func gobKeyToKey(gk *gobKey) *Key {
if gk == nil {
return nil
}
return &Key{
kind: gk.Kind,
name: gk.StringID,
id: gk.IntID,
parent: gobKeyToKey(gk.Parent),
namespace: gk.Namespace,
}
}
func (k *Key) GobEncode() ([]byte, error) {
buf := new(bytes.Buffer)
if err := gob.NewEncoder(buf).Encode(keyToGobKey(k)); err != nil {
return nil, err
}
return buf.Bytes(), nil
}
func (k *Key) GobDecode(buf []byte) error {
gk := new(gobKey)
if err := gob.NewDecoder(bytes.NewBuffer(buf)).Decode(gk); err != nil {
return err
}
*k = *gobKeyToKey(gk)
return nil
}
func (k *Key) MarshalJSON() ([]byte, error) {
return []byte(`"` + k.Encode() + `"`), nil
}
func (k *Key) UnmarshalJSON(buf []byte) error {
if len(buf) < 2 || buf[0] != '"' || buf[len(buf)-1] != '"' {
return errors.New("datastore: bad JSON key")
}
k2, err := DecodeKey(string(buf[1 : len(buf)-1]))
if err != nil {
return err
}
*k = *k2
return nil
}
// Encode returns an opaque representation of the key
// suitable for use in HTML and URLs.
// This is compatible with the Python and Java runtimes.
func (k *Key) Encode() string {
pKey := keyToProto(k)
b, err := proto.Marshal(pKey)
if err != nil {
panic(err)
}
// Trailing padding is stripped.
return strings.TrimRight(base64.URLEncoding.EncodeToString(b), "=")
}
// DecodeKey decodes a key from the opaque representation returned by Encode.
func DecodeKey(encoded string) (*Key, error) {
// Re-add padding.
if m := len(encoded) % 4; m != 0 {
encoded += strings.Repeat("=", 4-m)
}
b, err := base64.URLEncoding.DecodeString(encoded)
if err != nil {
return nil, err
}
pKey := new(pb.Key)
if err := proto.Unmarshal(b, pKey); err != nil {
return nil, err
}
return protoToKey(pKey), nil
}
// NewIncompleteKey creates a new incomplete key.
// kind cannot be empty.
func NewIncompleteKey(ctx context.Context, kind string, parent *Key) *Key {
return NewKey(ctx, kind, "", 0, parent)
}
// NewKey creates a new key.
// kind cannot be empty.
// Either one or both of stringID and intID must be zero. If both are zero,
// the key returned is incomplete.
// parent must either be a complete key or nil.
func NewKey(ctx context.Context, kind, name string, id int64, parent *Key) *Key {
return &Key{
kind: kind,
name: name,
id: id,
parent: parent,
namespace: ctxNamespace(ctx),
}
}
// AllocateIDs accepts a slice of incomplete keys and returns a
// slice of complete keys that are guaranteed to be valid in the datastore
func AllocateIDs(ctx context.Context, keys []*Key) ([]*Key, error) {
if keys == nil {
return nil, nil
}
req := &pb.AllocateIdsRequest{Key: multiKeyToProto(keys)}
res := &pb.AllocateIdsResponse{}
if err := call(ctx, "allocateIds", req, res); err != nil {
return nil, err
}
return multiProtoToKey(res.Key), nil
}
================================================
FILE: vendor/google.golang.org/cloud/datastore/load.go
================================================
// Copyright 2014 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package datastore
import (
"fmt"
"reflect"
"time"
pb "google.golang.org/cloud/internal/datastore"
)
var (
typeOfByteSlice = reflect.TypeOf([]byte(nil))
typeOfTime = reflect.TypeOf(time.Time{})
)
// typeMismatchReason returns a string explaining why the property p could not
// be stored in an entity field of type v.Type().
func typeMismatchReason(p Property, v reflect.Value) string {
entityType := "empty"
switch p.Value.(type) {
case int64:
entityType = "int"
case bool:
entityType = "bool"
case string:
entityType = "string"
case float64:
entityType = "float"
case *Key:
entityType = "*datastore.Key"
case time.Time:
entityType = "time.Time"
case []byte:
entityType = "[]byte"
}
return fmt.Sprintf("type mismatch: %s versus %v", entityType, v.Type())
}
type propertyLoader struct {
// m holds the number of times a substruct field like "Foo.Bar.Baz" has
// been seen so far. The map is constructed lazily.
m map[string]int
}
func (l *propertyLoader) load(codec *structCodec, structValue reflect.Value, p Property, prev map[string]struct{}) string {
var sliceOk bool
var v reflect.Value
// Traverse a struct's struct-typed fields.
for name := p.Name; ; {
decoder, ok := codec.byName[name]
if !ok {
return "no such struct field"
}
v = structValue.Field(decoder.index)
if !v.IsValid() {
return "no such struct field"
}
if !v.CanSet() {
return "cannot set struct field"
}
if decoder.substructCodec == nil {
break
}
if v.Kind() == reflect.Slice {
if l.m == nil {
l.m = make(map[string]int)
}
index := l.m[p.Name]
l.m[p.Name] = index + 1
for v.Len() <= index {
v.Set(reflect.Append(v, reflect.New(v.Type().Elem()).Elem()))
}
structValue = v.Index(index)
sliceOk = true
} else {
structValue = v
}
// Strip the "I." from "I.X".
name = name[len(codec.byIndex[decoder.index].name):]
codec = decoder.substructCodec
}
var slice reflect.Value
if v.Kind() == reflect.Slice && v.Type().Elem().Kind() != reflect.Uint8 {
slice = v
v = reflect.New(v.Type().Elem()).Elem()
} else if _, ok := prev[p.Name]; ok && !sliceOk {
// Zero the field back out that was set previously, turns out its a slice and we don't know what to do with it
v.Set(reflect.Zero(v.Type()))
return "multiple-valued property requires a slice field type"
}
prev[p.Name] = struct{}{}
pValue := p.Value
switch v.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
x, ok := pValue.(int64)
if !ok && pValue != nil {
return typeMismatchReason(p, v)
}
if v.OverflowInt(x) {
return fmt.Sprintf("value %v overflows struct field of type %v", x, v.Type())
}
v.SetInt(x)
case reflect.Bool:
x, ok := pValue.(bool)
if !ok && pValue != nil {
return typeMismatchReason(p, v)
}
v.SetBool(x)
case reflect.String:
x, ok := pValue.(string)
if !ok && pValue != nil {
return typeMismatchReason(p, v)
}
v.SetString(x)
case reflect.Float32, reflect.Float64:
x, ok := pValue.(float64)
if !ok && pValue != nil {
return typeMismatchReason(p, v)
}
if v.OverflowFloat(x) {
return fmt.Sprintf("value %v overflows struct field of type %v", x, v.Type())
}
v.SetFloat(x)
case reflect.Ptr:
x, ok := pValue.(*Key)
if !ok && pValue != nil {
return typeMismatchReason(p, v)
}
if _, ok := v.Interface().(*Key); !ok {
return typeMismatchReason(p, v)
}
v.Set(reflect.ValueOf(x))
case reflect.Struct:
switch v.Type() {
case typeOfTime:
x, ok := pValue.(time.Time)
if !ok && pValue != nil {
return typeMismatchReason(p, v)
}
v.Set(reflect.ValueOf(x))
default:
return typeMismatchReason(p, v)
}
case reflect.Slice:
x, ok := pValue.([]byte)
if !ok && pValue != nil {
return typeMismatchReason(p, v)
}
if v.Type().Elem().Kind() != reflect.Uint8 {
return typeMismatchReason(p, v)
}
v.SetBytes(x)
default:
return typeMismatchReason(p, v)
}
if slice.IsValid() {
slice.Set(reflect.Append(slice, v))
}
return ""
}
// loadEntity loads an EntityProto into PropertyLoadSaver or struct pointer.
func loadEntity(dst interface{}, src *pb.Entity) (err error) {
props := protoToProperties(src)
if e, ok := dst.(PropertyLoadSaver); ok {
return e.Load(props)
}
return LoadStruct(dst, props)
}
func (s structPLS) Load(props []Property) error {
var fieldName, reason string
var l propertyLoader
prev := make(map[string]struct{})
for _, p := range props {
if errStr := l.load(s.codec, s.v, p, prev); errStr != "" {
// We don't return early, as we try to load as many properties as possible.
// It is valid to load an entity into a struct that cannot fully represent it.
// That case returns an error, but the caller is free to ignore it.
fieldName, reason = p.Name, errStr
}
}
if reason != "" {
return &ErrFieldMismatch{
StructType: s.v.Type(),
FieldName: fieldName,
Reason: reason,
}
}
return nil
}
func protoToProperties(src *pb.Entity) []Property {
props := src.Property
out := make([]Property, 0, len(props))
for {
var (
x *pb.Property
noIndex bool
)
if len(props) > 0 {
x, props = props[0], props[1:]
noIndex = !x.GetValue().GetIndexed()
} else {
break
}
if x.Value.ListValue == nil {
out = append(out, Property{
Name: x.GetName(),
Value: propValue(x.Value),
NoIndex: noIndex,
Multiple: false,
})
} else {
for _, v := range x.Value.ListValue {
out = append(out, Property{
Name: x.GetName(),
Value: propValue(v),
NoIndex: noIndex,
Multiple: true,
})
}
}
}
return out
}
// propValue returns a Go value that combines the raw PropertyValue with a
// meaning. For example, an Int64Value with GD_WHEN becomes a time.Time.
func propValue(v *pb.Value) interface{} {
//TODO(PSG-Luna): Support EntityValue
//TODO(PSG-Luna): GeoPoint seems gone from the v1 proto, reimplement it once it's readded
switch {
case v.IntegerValue != nil:
return *v.IntegerValue
case v.TimestampMicrosecondsValue != nil:
return fromUnixMicro(*v.TimestampMicrosecondsValue)
case v.BooleanValue != nil:
return *v.BooleanValue
case v.StringValue != nil:
return *v.StringValue
case v.BlobValue != nil:
return []byte(v.BlobValue)
case v.BlobKeyValue != nil:
return *v.BlobKeyValue
case v.DoubleValue != nil:
return *v.DoubleValue
case v.KeyValue != nil:
return protoToKey(v.KeyValue)
}
return nil
}
================================================
FILE: vendor/google.golang.org/cloud/datastore/prop.go
================================================
// Copyright 2014 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package datastore
import (
"fmt"
"reflect"
"strings"
"sync"
"unicode"
)
// Entities with more than this many indexed properties will not be saved.
const maxIndexedProperties = 5000
// []byte fields more than 1 megabyte long will not be loaded or saved.
const maxBlobLen = 1 << 20
// Property is a name/value pair plus some metadata. A datastore entity's
// contents are loaded and saved as a sequence of Properties. An entity can
// have multiple Properties with the same name, provided that p.Multiple is
// true on all of that entity's Properties with that name.
type Property struct {
// Name is the property name.
Name string
// Value is the property value. The valid types are:
// - int64
// - bool
// - string
// - float64
// - *Key
// - time.Time
// - []byte (up to 1 megabyte in length)
// This set is smaller than the set of valid struct field types that the
// datastore can load and save. A Property Value cannot be a slice (apart
// from []byte); use multiple Properties instead. Also, a Value's type
// must be explicitly on the list above; it is not sufficient for the
// underlying type to be on that list. For example, a Value of "type
// myInt64 int64" is invalid. Smaller-width integers and floats are also
// invalid. Again, this is more restrictive than the set of valid struct
// field types.
//
// A Value will have an opaque type when loading entities from an index,
// such as via a projection query. Load entities into a struct instead
// of a PropertyLoadSaver when using a projection query.
//
// A Value may also be the nil interface value; this is equivalent to
// Python's None but not directly representable by a Go struct. Loading
// a nil-valued property into a struct will set that field to the zero
// value.
Value interface{}
// NoIndex is whether the datastore cannot index this property.
// If NoIndex is set to false, []byte values are limited to 1500 bytes and
// string values are limited to 1500 bytes.
NoIndex bool
// Multiple is whether the entity can have multiple properties with
// the same name. Even if a particular instance only has one property with
// a certain name, Multiple should be true if a struct would best represent
// it as a field of type []T instead of type T.
Multiple bool
}
// PropertyLoadSaver can be converted from and to a slice of Properties.
type PropertyLoadSaver interface {
Load([]Property) error
Save() ([]Property, error)
}
// PropertyList converts a []Property to implement PropertyLoadSaver.
type PropertyList []Property
var (
typeOfPropertyLoadSaver = reflect.TypeOf((*PropertyLoadSaver)(nil)).Elem()
typeOfPropertyList = reflect.TypeOf(PropertyList(nil))
)
// Load loads all of the provided properties into l.
// It does not first reset *l to an empty slice.
func (l *PropertyList) Load(p []Property) error {
*l = append(*l, p...)
return nil
}
// Save saves all of l's properties as a slice of Properties.
func (l *PropertyList) Save() ([]Property, error) {
return *l, nil
}
// validPropertyName returns whether name consists of one or more valid Go
// identifiers joined by ".".
func validPropertyName(name string) bool {
if name == "" {
return false
}
for _, s := range strings.Split(name, ".") {
if s == "" {
return false
}
first := true
for _, c := range s {
if first {
first = false
if c != '_' && !unicode.IsLetter(c) {
return false
}
} else {
if c != '_' && !unicode.IsLetter(c) && !unicode.IsDigit(c) {
return false
}
}
}
}
return true
}
// structTag is the parsed `datastore:"name,options"` tag of a struct field.
// If a field has no tag, or the tag has an empty name, then the structTag's
// name is just the field name. A "-" name means that the datastore ignores
// that field.
type structTag struct {
name string
noIndex bool
}
// structCodec describes how to convert a struct to and from a sequence of
// properties.
type structCodec struct {
// byIndex gives the structTag for the i'th field.
byIndex []structTag
// byName gives the field codec for the structTag with the given name.
byName map[string]fieldCodec
// hasSlice is whether a struct or any of its nested or embedded structs
// has a slice-typed field (other than []byte).
hasSlice bool
// complete is whether the structCodec is complete. An incomplete
// structCodec may be encountered when walking a recursive struct.
complete bool
}
// fieldCodec is a struct field's index and, if that struct field's type is
// itself a struct, that substruct's structCodec.
type fieldCodec struct {
index int
substructCodec *structCodec
}
// structCodecs collects the structCodecs that have already been calculated.
var (
structCodecsMutex sync.Mutex
structCodecs = make(map[reflect.Type]*structCodec)
)
// getStructCodec returns the structCodec for the given struct type.
func getStructCodec(t reflect.Type) (*structCodec, error) {
structCodecsMutex.Lock()
defer structCodecsMutex.Unlock()
return getStructCodecLocked(t)
}
// getStructCodecLocked implements getStructCodec. The structCodecsMutex must
// be held when calling this function.
func getStructCodecLocked(t reflect.Type) (ret *structCodec, retErr error) {
c, ok := structCodecs[t]
if ok {
return c, nil
}
c = &structCodec{
byIndex: make([]structTag, t.NumField()),
byName: make(map[string]fieldCodec),
}
// Add c to the structCodecs map before we are sure it is good. If t is
// a recursive type, it needs to find the incomplete entry for itself in
// the map.
structCodecs[t] = c
defer func() {
if retErr != nil {
delete(structCodecs, t)
}
}()
for i := range c.byIndex {
f := t.Field(i)
name, opts := f.Tag.Get("datastore"), ""
if i := strings.Index(name, ","); i != -1 {
name, opts = name[:i], name[i+1:]
}
if name == "" {
if !f.Anonymous {
name = f.Name
}
} else if name == "-" {
c.byIndex[i] = structTag{name: name}
continue
} else if !validPropertyName(name) {
return nil, fmt.Errorf("datastore: struct tag has invalid property name: %q", name)
}
substructType, fIsSlice := reflect.Type(nil), false
switch f.Type.Kind() {
case reflect.Struct:
substructType = f.Type
case reflect.Slice:
if f.Type.Elem().Kind() == reflect.Struct {
substructType = f.Type.Elem()
}
fIsSlice = f.Type != typeOfByteSlice
c.hasSlice = c.hasSlice || fIsSlice
}
if substructType != nil && substructType != typeOfTime {
if name != "" {
name = name + "."
}
sub, err := getStructCodecLocked(substructType)
if err != nil {
return nil, err
}
if !sub.complete {
return nil, fmt.Errorf("datastore: recursive struct: field %q", f.Name)
}
if fIsSlice && sub.hasSlice {
return nil, fmt.Errorf(
"datastore: flattening nested structs leads to a slice of slices: field %q", f.Name)
}
c.hasSlice = c.hasSlice || sub.hasSlice
for relName := range sub.byName {
absName := name + relName
if _, ok := c.byName[absName]; ok {
return nil, fmt.Errorf("datastore: struct tag has repeated property name: %q", absName)
}
c.byName[absName] = fieldCodec{index: i, substructCodec: sub}
}
} else {
if _, ok := c.byName[name]; ok {
return nil, fmt.Errorf("datastore: struct tag has repeated property name: %q", name)
}
c.byName[name] = fieldCodec{index: i}
}
c.byIndex[i] = structTag{
name: name,
noIndex: opts == "noindex",
}
}
c.complete = true
return c, nil
}
// structPLS adapts a struct to be a PropertyLoadSaver.
type structPLS struct {
v reflect.Value
codec *structCodec
}
// newStructPLS returns a PropertyLoadSaver for the struct pointer p.
func newStructPLS(p interface{}) (PropertyLoadSaver, error) {
v := reflect.ValueOf(p)
if v.Kind() != reflect.Ptr || v.IsNil() || v.Elem().Kind() != reflect.Struct {
return nil, ErrInvalidEntityType
}
v = v.Elem()
codec, err := getStructCodec(v.Type())
if err != nil {
return nil, err
}
return structPLS{v, codec}, nil
}
// LoadStruct loads the properties from p to dst.
// dst must be a struct pointer.
func LoadStruct(dst interface{}, p []Property) error {
x, err := newStructPLS(dst)
if err != nil {
return err
}
return x.Load(p)
}
// SaveStruct returns the properties from src as a slice of Properties.
// src must be a struct pointer.
func SaveStruct(src interface{}) ([]Property, error) {
x, err := newStructPLS(src)
if err != nil {
return nil, err
}
return x.Save()
}
================================================
FILE: vendor/google.golang.org/cloud/datastore/query.go
================================================
// Copyright 2014 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package datastore
import (
"encoding/base64"
"errors"
"fmt"
"math"
"reflect"
"strconv"
"strings"
"github.com/golang/protobuf/proto"
"golang.org/x/net/context"
pb "google.golang.org/cloud/internal/datastore"
)
type operator int
const (
lessThan operator = iota
lessEq
equal
greaterEq
greaterThan
keyFieldName = "__key__"
)
var operatorToProto = map[operator]*pb.PropertyFilter_Operator{
lessThan: pb.PropertyFilter_LESS_THAN.Enum(),
lessEq: pb.PropertyFilter_LESS_THAN_OR_EQUAL.Enum(),
equal: pb.PropertyFilter_EQUAL.Enum(),
greaterEq: pb.PropertyFilter_GREATER_THAN_OR_EQUAL.Enum(),
greaterThan: pb.PropertyFilter_GREATER_THAN.Enum(),
}
// filter is a conditional filter on query results.
type filter struct {
FieldName string
Op operator
Value interface{}
}
type sortDirection int
const (
ascending sortDirection = iota
descending
)
var sortDirectionToProto = map[sortDirection]*pb.PropertyOrder_Direction{
ascending: pb.PropertyOrder_ASCENDING.Enum(),
descending: pb.PropertyOrder_DESCENDING.Enum(),
}
// order is a sort order on query results.
type order struct {
FieldName string
Direction sortDirection
}
// NewQuery creates a new Query for a specific entity kind.
//
// An empty kind means to return all entities, including entities created and
// managed by other App Engine features, and is called a kindless query.
// Kindless queries cannot include filters or sort orders on property values.
func NewQuery(kind string) *Query {
return &Query{
kind: kind,
limit: -1,
}
}
// Query represents a datastore query.
type Query struct {
kind string
ancestor *Key
filter []filter
order []order
projection []string
distinct bool
keysOnly bool
eventual bool
limit int32
offset int32
start []byte
end []byte
trans *Transaction
err error
}
func (q *Query) clone() *Query {
x := *q
// Copy the contents of the slice-typed fields to a new backing store.
if len(q.filter) > 0 {
x.filter = make([]filter, len(q.filter))
copy(x.filter, q.filter)
}
if len(q.order) > 0 {
x.order = make([]order, len(q.order))
copy(x.order, q.order)
}
return &x
}
// Ancestor returns a derivative query with an ancestor filter.
// The ancestor should not be nil.
func (q *Query) Ancestor(ancestor *Key) *Query {
q = q.clone()
if ancestor == nil {
q.err = errors.New("datastore: nil query ancestor")
return q
}
q.ancestor = ancestor
return q
}
// EventualConsistency returns a derivative query that returns eventually
// consistent results.
// It only has an effect on ancestor queries.
func (q *Query) EventualConsistency() *Query {
q = q.clone()
q.eventual = true
return q
}
// Transaction returns a derivative query that is associated with the given
// transaction.
//
// All reads performed as part of the transaction will come from a single
// consistent snapshot. Furthermore, if the transaction is set to a
// serializable isolation level, another transaction cannot concurrently modify
// the data that is read or modified by this transaction.
func (q *Query) Transaction(t *Transaction) *Query {
q = q.clone()
q.trans = t
return q
}
// Filter returns a derivative query with a field-based filter.
// The filterStr argument must be a field name followed by optional space,
// followed by an operator, one of ">", "<", ">=", "<=", or "=".
// Fields are compared against the provided value using the operator.
// Multiple filters are AND'ed together.
// Field names which contain spaces, quote marks, or operator characters
// should be passed as quoted Go string literals as returned by strconv.Quote
// or the fmt package's %q verb.
func (q *Query) Filter(filterStr string, value interface{}) *Query {
q = q.clone()
filterStr = strings.TrimSpace(filterStr)
if filterStr == "" {
q.err = fmt.Errorf("datastore: invalid filter %q", filterStr)
return q
}
f := filter{
FieldName: strings.TrimRight(filterStr, " ><=!"),
Value: value,
}
switch op := strings.TrimSpace(filterStr[len(f.FieldName):]); op {
case "<=":
f.Op = lessEq
case ">=":
f.Op = greaterEq
case "<":
f.Op = lessThan
case ">":
f.Op = greaterThan
case "=":
f.Op = equal
default:
q.err = fmt.Errorf("datastore: invalid operator %q in filter %q", op, filterStr)
return q
}
var err error
f.FieldName, err = unquote(f.FieldName)
if err != nil {
q.err = fmt.Errorf("datastore: invalid syntax for quoted field name %q", f.FieldName)
return q
}
q.filter = append(q.filter, f)
return q
}
// Order returns a derivative query with a field-based sort order. Orders are
// applied in the order they are added. The default order is ascending; to sort
// in descending order prefix the fieldName with a minus sign (-).
// Field names which contain spaces, quote marks, or the minus sign
// should be passed as quoted Go string literals as returned by strconv.Quote
// or the fmt package's %q verb.
func (q *Query) Order(fieldName string) *Query {
q = q.clone()
fieldName, dir := strings.TrimSpace(fieldName), ascending
if strings.HasPrefix(fieldName, "-") {
fieldName, dir = strings.TrimSpace(fieldName[1:]), descending
} else if strings.HasPrefix(fieldName, "+") {
q.err = fmt.Errorf("datastore: invalid order: %q", fieldName)
return q
}
fieldName, err := unquote(fieldName)
if err != nil {
q.err = fmt.Errorf("datastore: invalid syntax for quoted field name %q", fieldName)
return q
}
if fieldName == "" {
q.err = errors.New("datastore: empty order")
return q
}
q.order = append(q.order, order{
Direction: dir,
FieldName: fieldName,
})
return q
}
// unquote optionally interprets s as a double-quoted or backquoted Go
// string literal if it begins with the relevant character.
func unquote(s string) (string, error) {
if s == "" || (s[0] != '`' && s[0] != '"') {
return s, nil
}
return strconv.Unquote(s)
}
// Project returns a derivative query that yields only the given fields. It
// cannot be used with KeysOnly.
func (q *Query) Project(fieldNames ...string) *Query {
q = q.clone()
q.projection = append([]string(nil), fieldNames...)
return q
}
// Distinct returns a derivative query that yields de-duplicated entities with
// respect to the set of projected fields. It is only used for projection
// queries.
func (q *Query) Distinct() *Query {
q = q.clone()
q.distinct = true
return q
}
// KeysOnly returns a derivative query that yields only keys, not keys and
// entities. It cannot be used with projection queries.
func (q *Query) KeysOnly() *Query {
q = q.clone()
q.keysOnly = true
return q
}
// Limit returns a derivative query that has a limit on the number of results
// returned. A negative value means unlimited.
func (q *Query) Limit(limit int) *Query {
q = q.clone()
if limit < math.MinInt32 || limit > math.MaxInt32 {
q.err = errors.New("datastore: query limit overflow")
return q
}
q.limit = int32(limit)
return q
}
// Offset returns a derivative query that has an offset of how many keys to
// skip over before returning results. A negative value is invalid.
func (q *Query) Offset(offset int) *Query {
q = q.clone()
if offset < 0 {
q.err = errors.New("datastore: negative query offset")
return q
}
if offset > math.MaxInt32 {
q.err = errors.New("datastore: query offset overflow")
return q
}
q.offset = int32(offset)
return q
}
// Start returns a derivative query with the given start point.
func (q *Query) Start(c Cursor) *Query {
q = q.clone()
if c.cc == nil {
q.err = errors.New("datastore: invalid cursor")
return q
}
q.start = c.cc
return q
}
// End returns a derivative query with the given end point.
func (q *Query) End(c Cursor) *Query {
q = q.clone()
if c.cc == nil {
q.err = errors.New("datastore: invalid cursor")
return q
}
q.end = c.cc
return q
}
// toProto converts the query to a protocol buffer.
func (q *Query) toProto(req *pb.RunQueryRequest) error {
dst := pb.Query{}
if len(q.projection) != 0 && q.keysOnly {
return errors.New("datastore: query cannot both project and be keys-only")
}
dst.Reset()
if q.kind != "" {
dst.Kind = []*pb.KindExpression{&pb.KindExpression{Name: proto.String(q.kind)}}
}
if q.projection != nil {
for _, propertyName := range q.projection {
dst.Projection = append(dst.Projection, &pb.PropertyExpression{Property: &pb.PropertyReference{Name: proto.String(propertyName)}})
}
if q.distinct {
for _, propertyName := range q.projection {
dst.GroupBy = append(dst.GroupBy, &pb.PropertyReference{Name: proto.String(propertyName)})
}
}
}
if q.keysOnly {
dst.Projection = []*pb.PropertyExpression{&pb.PropertyExpression{Property: &pb.PropertyReference{Name: proto.String(keyFieldName)}}}
}
var filters []*pb.Filter
for _, qf := range q.filter {
if qf.FieldName == "" {
return errors.New("datastore: empty query filter field name")
}
v, errStr := interfaceToProto(reflect.ValueOf(qf.Value).Interface())
if errStr != "" {
return errors.New("datastore: bad query filter value type: " + errStr)
}
xf := &pb.PropertyFilter{
Operator: operatorToProto[qf.Op],
Property: &pb.PropertyReference{Name: proto.String(qf.FieldName)},
Value: v,
}
if xf.Operator == nil {
return errors.New("datastore: unknown query filter operator")
}
filters = append(filters, &pb.Filter{PropertyFilter: xf})
}
if q.ancestor != nil {
filters = append(filters, &pb.Filter{
PropertyFilter: &pb.PropertyFilter{
Property: &pb.PropertyReference{Name: proto.String("__key__")},
Operator: pb.PropertyFilter_HAS_ANCESTOR.Enum(),
Value: &pb.Value{KeyValue: keyToProto(q.ancestor)},
}})
}
if len(filters) == 1 {
dst.Filter = filters[0]
} else if len(filters) > 1 {
dst.Filter = &pb.Filter{CompositeFilter: &pb.CompositeFilter{
Operator: pb.CompositeFilter_AND.Enum(),
Filter: filters,
}}
}
for _, qo := range q.order {
if qo.FieldName == "" {
return errors.New("datastore: empty query order field name")
}
xo := &pb.PropertyOrder{
Property: &pb.PropertyReference{Name: proto.String(qo.FieldName)},
Direction: sortDirectionToProto[qo.Direction],
}
if xo.Direction == nil {
return errors.New("datastore: unknown query order direction")
}
dst.Order = append(dst.Order, xo)
}
if q.limit >= 0 {
dst.Limit = proto.Int32(q.limit)
}
if q.offset != 0 {
dst.Offset = proto.Int32(q.offset)
}
dst.StartCursor = q.start
dst.EndCursor = q.end
if t := q.trans; t != nil {
if t.id == nil {
return errExpiredTransaction
}
req.ReadOptions = &pb.ReadOptions{Transaction: t.id}
}
req.Query = &dst
return nil
}
// Count returns the number of results for the query.
func (q *Query) Count(ctx context.Context) (int, error) {
// Check that the query is well-formed.
if q.err != nil {
return 0, q.err
}
// Run a copy of the query, with keysOnly true (if we're not a projection,
// since the two are incompatible).
newQ := q.clone()
newQ.keysOnly = len(newQ.projection) == 0
req := &pb.RunQueryRequest{}
if ns := ctxNamespace(ctx); ns != "" {
req.PartitionId = &pb.PartitionId{
Namespace: proto.String(ns),
}
}
if err := newQ.toProto(req); err != nil {
return 0, err
}
res := &pb.RunQueryResponse{}
if err := call(ctx, "runQuery", req, res); err != nil {
return 0, err
}
var n int
b := res.Batch
for {
n += len(b.GetEntityResult())
if b.GetMoreResults() != pb.QueryResultBatch_NOT_FINISHED {
break
}
var err error
// TODO(jbd): Support count queries that have a limit and an offset.
if err = callNext(ctx, req, res, 0, 0); err != nil {
return 0, err
}
}
return int(n), nil
}
func callNext(ctx context.Context, req *pb.RunQueryRequest, res *pb.RunQueryResponse, offset, limit int32) error {
if res.GetBatch().EndCursor == nil {
return errors.New("datastore: internal error: server did not return a cursor")
}
req.Query.StartCursor = res.GetBatch().GetEndCursor()
if limit >= 0 {
req.Query.Limit = proto.Int32(limit)
}
if offset != 0 {
req.Query.Offset = proto.Int32(offset)
}
res.Reset()
return call(ctx, "runQuery", req, res)
}
// GetAll runs the query in the given context and returns all keys that match
// that query, as well as appending the values to dst.
//
// dst must have type *[]S or *[]*S or *[]P, for some struct type S or some non-
// interface, non-pointer type P such that P or *P implements PropertyLoadSaver.
//
// As a special case, *PropertyList is an invalid type for dst, even though a
// PropertyList is a slice of structs. It is treated as invalid to avoid being
// mistakenly passed when *[]PropertyList was intended.
//
// The keys returned by GetAll will be in a 1-1 correspondence with the entities
// added to dst.
//
// If q is a ``keys-only'' query, GetAll ignores dst and only returns the keys.
func (q *Query) GetAll(ctx context.Context, dst interface{}) ([]*Key, error) {
var (
dv reflect.Value
mat multiArgType
elemType reflect.Type
errFieldMismatch error
)
if !q.keysOnly {
dv = reflect.ValueOf(dst)
if dv.Kind() != reflect.Ptr || dv.IsNil() {
return nil, ErrInvalidEntityType
}
dv = dv.Elem()
mat, elemType = checkMultiArg(dv)
if mat == multiArgTypeInvalid || mat == multiArgTypeInterface {
return nil, ErrInvalidEntityType
}
}
var keys []*Key
for t := q.Run(ctx); ; {
k, e, err := t.next()
if err == Done {
break
}
if err != nil {
return keys, err
}
if !q.keysOnly {
ev := reflect.New(elemType)
if elemType.Kind() == reflect.Map {
// This is a special case. The zero values of a map type are
// not immediately useful; they have to be make'd.
//
// Funcs and channels are similar, in that a zero value is not useful,
// but even a freshly make'd channel isn't useful: there's no fixed
// channel buffer size that is always going to be large enough, and
// there's no goroutine to drain the other end. Theoretically, these
// types could be supported, for example by sniffing for a constructor
// method or requiring prior registration, but for now it's not a
// frequent enough concern to be worth it. Programmers can work around
// it by explicitly using Iterator.Next instead of the Query.GetAll
// convenience method.
x := reflect.MakeMap(elemType)
ev.Elem().Set(x)
}
if err = loadEntity(ev.Interface(), e); err != nil {
if _, ok := err.(*ErrFieldMismatch); ok {
// We continue loading entities even in the face of field mismatch errors.
// If we encounter any other error, that other error is returned. Otherwise,
// an ErrFieldMismatch is returned.
errFieldMismatch = err
} else {
return keys, err
}
}
if mat != multiArgTypeStructPtr {
ev = ev.Elem()
}
dv.Set(reflect.Append(dv, ev))
}
keys = append(keys, k)
}
return keys, errFieldMismatch
}
// Run runs the query in the given context.
func (q *Query) Run(ctx context.Context) *Iterator {
if q.err != nil {
return &Iterator{err: q.err}
}
t := &Iterator{
ctx: ctx,
limit: q.limit,
q: q,
prevCC: q.start,
}
t.req.Reset()
if ns := ctxNamespace(ctx); ns != "" {
t.req.PartitionId = &pb.PartitionId{
Namespace: proto.String(ns),
}
}
if err := q.toProto(&t.req); err != nil {
t.err = err
return t
}
if err := call(ctx, "runQuery", &t.req, &t.res); err != nil {
t.err = err
return t
}
b := t.res.GetBatch()
offset := q.offset - b.GetSkippedResults()
for offset > 0 && b.GetMoreResults() == pb.QueryResultBatch_NOT_FINISHED {
t.prevCC = b.GetEndCursor()
var err error
if err = callNext(t.ctx, &t.req, &t.res, offset, t.limit); err != nil {
t.err = err
break
}
skip := b.GetSkippedResults()
if skip < 0 {
t.err = errors.New("datastore: internal error: negative number of skipped_results")
break
}
offset -= skip
}
if offset < 0 {
t.err = errors.New("datastore: internal error: query offset was overshot")
}
return t
}
// Iterator is the result of running a query.
type Iterator struct {
ctx context.Context
err error
// req is the request we sent previously, we need to keep track of it to resend it
req pb.RunQueryRequest
// res is the result of the most recent RunQuery or Next API call.
res pb.RunQueryResponse
// i is how many elements of res.Result we have iterated over.
i int
// limit is the limit on the number of results this iterator should return.
// A negative value means unlimited.
limit int32
// q is the original query which yielded this iterator.
q *Query
// prevCC is the compiled cursor that marks the end of the previous batch
// of results.
prevCC []byte
}
// Done is returned when a query iteration has completed.
var Done = errors.New("datastore: query has no more results")
// Next returns the key of the next result. When there are no more results,
// Done is returned as the error.
//
// If the query is not keys only and dst is non-nil, it also loads the entity
// stored for that key into the struct pointer or PropertyLoadSaver dst, with
// the same semantics and possible errors as for the Get function.
func (t *Iterator) Next(dst interface{}) (*Key, error) {
k, e, err := t.next()
if err != nil {
return nil, err
}
if dst != nil && !t.q.keysOnly {
err = loadEntity(dst, e)
}
return k, err
}
func (t *Iterator) next() (*Key, *pb.Entity, error) {
if t.err != nil {
return nil, nil, t.err
}
// Issue datastore_v3/Next RPCs as necessary.
b := t.res.GetBatch()
for t.i == len(b.EntityResult) {
if b.GetMoreResults() != pb.QueryResultBatch_NOT_FINISHED {
t.err = Done
return nil, nil, t.err
}
t.prevCC = b.GetEndCursor()
if err := callNext(t.ctx, &t.req, &t.res, 0, t.limit); err != nil {
t.err = err
return nil, nil, t.err
}
if b.GetSkippedResults() != 0 {
t.err = errors.New("datastore: internal error: iterator has skipped results")
return nil, nil, t.err
}
t.i = 0
if t.limit >= 0 {
t.limit -= int32(len(b.EntityResult))
if t.limit < 0 {
t.err = errors.New("datastore: internal error: query returned more results than the limit")
return nil, nil, t.err
}
}
}
// Extract the key from the t.i'th element of t.res.Result.
e := b.EntityResult[t.i]
t.i++
if e.Entity.Key == nil {
return nil, nil, errors.New("datastore: internal error: server did not return a key")
}
k := protoToKey(e.Entity.Key)
if k.Incomplete() {
return nil, nil, errors.New("datastore: internal error: server returned an invalid key")
}
return k, e.Entity, nil
}
// Cursor returns a cursor for the iterator's current location.
func (t *Iterator) Cursor() (Cursor, error) {
if t.err != nil && t.err != Done {
return Cursor{}, t.err
}
// If we are at either end of the current batch of results,
// return the compiled cursor at that end.
b := t.res.Batch
skipped := b.GetSkippedResults()
if t.i == 0 && skipped == 0 {
if t.prevCC == nil {
// A nil pointer (of type *pb.CompiledCursor) means no constraint:
// passing it as the end cursor of a new query means unlimited results
// (glossing over the integer limit parameter for now).
// A non-nil pointer to an empty pb.CompiledCursor means the start:
// passing it as the end cursor of a new query means 0 results.
// If prevCC was nil, then the original query had no start cursor, but
// Iterator.Cursor should return "the start" instead of unlimited.
return Cursor{}, nil
}
return Cursor{t.prevCC}, nil
}
if t.i == len(b.EntityResult) {
return Cursor{b.EndCursor}, nil
}
// Otherwise, re-run the query offset to this iterator's position, starting from
// the most recent compiled cursor. This is done on a best-effort basis, as it
// is racy; if a concurrent process has added or removed entities, then the
// cursor returned may be inconsistent.
q := t.q.clone()
q.start = t.prevCC
q.offset = skipped + int32(t.i)
q.limit = 0
q.keysOnly = len(q.projection) == 0
t1 := q.Run(t.ctx)
_, _, err := t1.next()
if err != Done {
if err == nil {
err = fmt.Errorf("datastore: internal error: zero-limit query did not have zero results")
}
return Cursor{}, err
}
return Cursor{t1.res.Batch.EndCursor}, nil
}
// Cursor is an iterator's position. It can be converted to and from an opaque
// string. A cursor can be used from different HTTP requests, but only with a
// query with the same kind, ancestor, filter and order constraints.
type Cursor struct {
cc []byte
}
// String returns a base-64 string representation of a cursor.
func (c Cursor) String() string {
if c.cc == nil {
return ""
}
return strings.TrimRight(base64.URLEncoding.EncodeToString(c.cc), "=")
}
// Decode decodes a cursor from its base-64 string representation.
func DecodeCursor(s string) (Cursor, error) {
if s == "" {
return Cursor{}, nil
}
if n := len(s) % 4; n != 0 {
s += strings.Repeat("=", 4-n)
}
b, err := base64.URLEncoding.DecodeString(s)
if err != nil {
return Cursor{}, err
}
return Cursor{b}, nil
}
================================================
FILE: vendor/google.golang.org/cloud/datastore/save.go
================================================
// Copyright 2014 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package datastore
import (
"errors"
"fmt"
"reflect"
"time"
"github.com/golang/protobuf/proto"
pb "google.golang.org/cloud/internal/datastore"
)
// saveEntity saves an EntityProto into a PropertyLoadSaver or struct pointer.
func saveEntity(key *Key, src interface{}) (*pb.Entity, error) {
var err error
var props []Property
if e, ok := src.(PropertyLoadSaver); ok {
props, err = e.Save()
} else {
props, err = SaveStruct(src)
}
if err != nil {
return nil, err
}
return propertiesToProto(key, props)
}
func saveStructProperty(props *[]Property, name string, noIndex, multiple bool, v reflect.Value) error {
p := Property{
Name: name,
NoIndex: noIndex,
Multiple: multiple,
}
switch x := v.Interface().(type) {
case *Key, time.Time:
p.Value = x
default:
switch v.Kind() {
case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
p.Value = v.Int()
case reflect.Bool:
p.Value = v.Bool()
case reflect.String:
p.Value = v.String()
case reflect.Float32, reflect.Float64:
p.Value = v.Float()
case reflect.Slice:
if v.Type().Elem().Kind() == reflect.Uint8 {
p.Value = v.Bytes()
}
case reflect.Struct:
if !v.CanAddr() {
return fmt.Errorf("datastore: unsupported struct field: value is unaddressable")
}
sub, err := newStructPLS(v.Addr().Interface())
if err != nil {
return fmt.Errorf("datastore: unsupported struct field: %v", err)
}
return sub.(structPLS).save(props, name, noIndex, multiple)
}
}
if p.Value == nil {
return fmt.Errorf("datastore: unsupported struct field type: %v", v.Type())
}
*props = append(*props, p)
return nil
}
func (s structPLS) Save() ([]Property, error) {
var props []Property
if err := s.save(&props, "", false, false); err != nil {
return nil, err
}
return props, nil
}
func (s structPLS) save(props *[]Property, prefix string, noIndex, multiple bool) error {
for i, t := range s.codec.byIndex {
if t.name == "-" {
continue
}
name := t.name
if prefix != "" {
name = prefix + name
}
v := s.v.Field(i)
if !v.IsValid() || !v.CanSet() {
continue
}
noIndex1 := noIndex || t.noIndex
// For slice fields that aren't []byte, save each element.
if v.Kind() == reflect.Slice && v.Type().Elem().Kind() != reflect.Uint8 {
for j := 0; j < v.Len(); j++ {
if err := saveStructProperty(props, name, noIndex1, true, v.Index(j)); err != nil {
return err
}
}
continue
}
// Otherwise, save the field itself.
if err := saveStructProperty(props, name, noIndex1, multiple, v); err != nil {
return err
}
}
return nil
}
func propertiesToProto(key *Key, props []Property) (*pb.Entity, error) {
e := &pb.Entity{
Key: keyToProto(key),
}
indexedProps := 0
prevMultiple := make(map[string]*pb.Property)
for _, p := range props {
val, err := interfaceToProto(p.Value)
if err != "" {
return nil, fmt.Errorf("datastore: %s for a Property with Name %q", err, p.Name)
}
if !p.NoIndex {
rVal := reflect.ValueOf(p.Value)
if rVal.Kind() == reflect.Slice && rVal.Type().Elem().Kind() != reflect.Uint8 {
indexedProps += rVal.Len()
} else {
indexedProps++
}
}
if indexedProps > maxIndexedProperties {
return nil, errors.New("datastore: too many indexed properties")
}
switch v := p.Value.(type) {
case string:
case []byte:
if len(v) > 1500 && !p.NoIndex {
return nil, fmt.Errorf("datastore: cannot index a Property with Name %q", p.Name)
}
}
val.Indexed = proto.Bool(!p.NoIndex)
if p.Multiple {
x, ok := prevMultiple[p.Name]
if !ok {
x = &pb.Property{
Name: proto.String(p.Name),
Value: &pb.Value{},
}
prevMultiple[p.Name] = x
e.Property = append(e.Property, x)
}
x.Value.ListValue = append(x.Value.ListValue, val)
} else {
e.Property = append(e.Property, &pb.Property{
Name: proto.String(p.Name),
Value: val,
})
}
}
return e, nil
}
func interfaceToProto(iv interface{}) (p *pb.Value, errStr string) {
val := new(pb.Value)
switch v := iv.(type) {
case int:
val.IntegerValue = proto.Int64(int64(v))
case int32:
val.IntegerValue = proto.Int64(int64(v))
case int64:
val.IntegerValue = proto.Int64(v)
case bool:
val.BooleanValue = proto.Bool(v)
case string:
val.StringValue = proto.String(v)
case float32:
val.DoubleValue = proto.Float64(float64(v))
case float64:
val.DoubleValue = proto.Float64(v)
case *Key:
if v != nil {
val.KeyValue = keyToProto(v)
}
case time.Time:
if v.Before(minTime) || v.After(maxTime) {
return nil, fmt.Sprintf("time value out of range")
}
val.TimestampMicrosecondsValue = proto.Int64(toUnixMicro(v))
case []byte:
val.BlobValue = v
default:
if iv != nil {
return nil, fmt.Sprintf("invalid Value type %t", iv)
}
}
// TODO(jbd): Support ListValue and EntityValue.
// TODO(jbd): Support types whose underlying type is one of the types above.
return val, ""
}
================================================
FILE: vendor/google.golang.org/cloud/datastore/time.go
================================================
// Copyright 2014 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package datastore
import (
"math"
"time"
)
var (
minTime = time.Unix(int64(math.MinInt64)/1e6, (int64(math.MinInt64)%1e6)*1e3)
maxTime = time.Unix(int64(math.MaxInt64)/1e6, (int64(math.MaxInt64)%1e6)*1e3)
)
func toUnixMicro(t time.Time) int64 {
// We cannot use t.UnixNano() / 1e3 because we want to handle times more than
// 2^63 nanoseconds (which is about 292 years) away from 1970, and those cannot
// be represented in the numerator of a single int64 divide.
return t.Unix()*1e6 + int64(t.Nanosecond()/1e3)
}
func fromUnixMicro(t int64) time.Time {
return time.Unix(t/1e6, (t%1e6)*1e3)
}
================================================
FILE: vendor/google.golang.org/cloud/datastore/transaction.go
================================================
// Copyright 2014 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package datastore
import (
"errors"
"net/http"
"github.com/golang/protobuf/proto"
"golang.org/x/net/context"
pb "google.golang.org/cloud/internal/datastore"
)
// ErrConcurrentTransaction is returned when a transaction is rolled back due
// to a conflict with a concurrent transaction.
var ErrConcurrentTransaction = errors.New("datastore: concurrent transaction")
var errExpiredTransaction = errors.New("datastore: transaction expired")
// A TransactionOption configures the Transaction returned by NewTransaction.
type TransactionOption interface {
apply(*pb.BeginTransactionRequest)
}
type isolation struct {
level pb.BeginTransactionRequest_IsolationLevel
}
func (i isolation) apply(req *pb.BeginTransactionRequest) {
req.IsolationLevel = i.level.Enum()
}
var (
// Snapshot causes the transaction to enforce a snapshot isolation level.
Snapshot TransactionOption = isolation{pb.BeginTransactionRequest_SNAPSHOT}
// Serializable causes the transaction to enforce a serializable isolation level.
Serializable TransactionOption = isolation{pb.BeginTransactionRequest_SERIALIZABLE}
)
// Transaction represents a set of datastore operations to be committed atomically.
//
// Operations are enqueued by calling the Put and Delete methods on Transaction
// (or their Multi-equivalents). These operations are only committed when the
// Commit method is invoked. To ensure consistency, reads must be performed by
// using Transaction's Get method or by using the Transaction method when
// building a query.
//
// A Transaction must be committed or rolled back exactly once.
type Transaction struct {
id []byte
ctx context.Context
mutation *pb.Mutation // The mutations to apply.
pending []*PendingKey // Incomplete keys pending transaction completion.
}
// NewTransaction starts a new transaction.
func NewTransaction(ctx context.Context, opts ...TransactionOption) (*Transaction, error) {
req, resp := &pb.BeginTransactionRequest{}, &pb.BeginTransactionResponse{}
for _, o := range opts {
o.apply(req)
}
if err := call(ctx, "beginTransaction", req, resp); err != nil {
return nil, err
}
return &Transaction{
id: resp.Transaction,
ctx: ctx,
mutation: &pb.Mutation{},
}, nil
}
// Commit applies the enqueued operations atomically.
func (t *Transaction) Commit() (*Commit, error) {
if t.id == nil {
return nil, errExpiredTransaction
}
req := &pb.CommitRequest{
Transaction: t.id,
Mutation: t.mutation,
Mode: pb.CommitRequest_TRANSACTIONAL.Enum(),
}
t.id = nil
resp := &pb.CommitResponse{}
if err := call(t.ctx, "commit", req, resp); err != nil {
if e, ok := err.(*errHTTP); ok && e.StatusCode == http.StatusConflict {
// TODO(jbd): Make sure that we explicitly handle the case where response
// has an HTTP 409 and the error message indicates that it's an concurrent
// transaction error.
return nil, ErrConcurrentTransaction
}
return nil, err
}
// Copy any newly minted keys into the returned keys.
if len(t.pending) != len(resp.MutationResult.InsertAutoIdKey) {
return nil, errors.New("datastore: internal error: server returned the wrong number of keys")
}
commit := &Commit{}
for i, p := range t.pending {
p.key = protoToKey(resp.MutationResult.InsertAutoIdKey[i])
p.commit = commit
}
return commit, nil
}
// Rollback abandons a pending transaction.
func (t *Transaction) Rollback() error {
if t.id == nil {
return errExpiredTransaction
}
id := t.id
t.id = nil
return call(t.ctx, "rollback", &pb.RollbackRequest{Transaction: id}, &pb.RollbackResponse{})
}
// Get is the transaction-specific version of the package function Get.
// All reads performed during the transaction will come from a single consistent
// snapshot. Furthermore, if the transaction is set to a serializable isolation
// level, another transaction cannot concurrently modify the data that is read
// or modified by this transaction.
func (t *Transaction) Get(key *Key, dst interface{}) error {
err := get(t.ctx, []*Key{key}, []interface{}{dst}, &pb.ReadOptions{Transaction: t.id})
if me, ok := err.(MultiError); ok {
return me[0]
}
return err
}
// GetMulti is a batch version of Get.
func (t *Transaction) GetMulti(keys []*Key, dst interface{}) error {
if t.id == nil {
return errExpiredTransaction
}
return get(t.ctx, keys, dst, &pb.ReadOptions{Transaction: t.id})
}
// Put is the transaction-specific version of the package function Put.
//
// Put returns a PendingKey which can be resolved into a Key using the
// return value from a successful Commit. If key is an incomplete key, the
// returned pending key will resolve to a unique key generated by the
// datastore.
func (t *Transaction) Put(key *Key, src interface{}) (*PendingKey, error) {
h, err := t.PutMulti([]*Key{key}, []interface{}{src})
if err != nil {
if me, ok := err.(MultiError); ok {
return nil, me[0]
}
return nil, err
}
return h[0], nil
}
// PutMulti is a batch version of Put. One PendingKey is returned for each
// element of src in the same order.
func (t *Transaction) PutMulti(keys []*Key, src interface{}) ([]*PendingKey, error) {
if t.id == nil {
return nil, errExpiredTransaction
}
mutation, err := putMutation(keys, src)
if err != nil {
return nil, err
}
proto.Merge(t.mutation, mutation)
// Prepare the returned handles, pre-populating where possible.
ret := make([]*PendingKey, len(keys))
for _, key := range keys {
h := &PendingKey{}
if key.Incomplete() {
// This key will be in the final commit result.
t.pending = append(t.pending, h)
} else {
h.key = key
}
ret = append(ret, h)
}
return ret, nil
}
// Delete is the transaction-specific version of the package function Delete.
// Delete enqueues the deletion of the entity for the given key, to be
// committed atomically upon calling Commit.
func (t *Transaction) Delete(key *Key) error {
err := t.DeleteMulti([]*Key{key})
if me, ok := err.(MultiError); ok {
return me[0]
}
return err
}
// DeleteMulti is a batch version of Delete.
func (t *Transaction) DeleteMulti(keys []*Key) error {
if t.id == nil {
return errExpiredTransaction
}
mutation, err := deleteMutation(keys)
if err != nil {
return err
}
proto.Merge(t.mutation, mutation)
return nil
}
// Commit represents the result of a committed transaction.
type Commit struct{}
// Key resolves a pending key handle into a final key.
func (c *Commit) Key(p *PendingKey) *Key {
if c != p.commit {
panic("PendingKey was not created by corresponding transaction")
}
return p.key
}
// PendingKey represents the key for newly-inserted entity. It can be
// resolved into a Key by calling the Key method of Commit.
type PendingKey struct {
key *Key
commit *Commit
}
================================================
FILE: vendor/google.golang.org/cloud/examples/bigquery/concat_table/main.go
================================================
// Copyright 2015 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// concat_table is an example client of the bigquery client library.
// It concatenates two BigQuery tables and writes the result to another table.
package main
import (
"flag"
"fmt"
"log"
"os"
"time"
"golang.org/x/net/context"
"golang.org/x/oauth2/google"
"google.golang.org/cloud/bigquery"
)
var (
project = flag.String("project", "", "The ID of a Google Cloud Platform project")
dataset = flag.String("dataset", "", "The ID of a BigQuery dataset")
src1 = flag.String("src1", "", "The ID of the first BigQuery table to concatenate")
src2 = flag.String("src2", "", "The ID of the second BigQuery table to concatenate")
dest = flag.String("dest", "", "The ID of the BigQuery table to write the result to")
pollint = flag.Duration("pollint", 10*time.Second, "Polling interval for checking job status")
)
func main() {
flag.Parse()
flagsOk := true
for _, f := range []string{"project", "dataset", "src1", "src2", "dest"} {
if flag.Lookup(f).Value.String() == "" {
fmt.Fprintf(os.Stderr, "Flag --%s is required\n", f)
flagsOk = false
}
}
if !flagsOk {
os.Exit(1)
}
if *src1 == *src2 || *src1 == *dest || *src2 == *dest {
log.Fatalf("Different values must be supplied for each of --src1, --src2 and --dest")
}
httpClient, err := google.DefaultClient(context.Background(), bigquery.Scope)
if err != nil {
log.Fatalf("Creating http client: %v", err)
}
client, err := bigquery.NewClient(httpClient, *project)
if err != nil {
log.Fatalf("Creating bigquery client: %v", err)
}
s1 := &bigquery.Table{
ProjectID: *project,
DatasetID: *dataset,
TableID: *src1,
}
s2 := &bigquery.Table{
ProjectID: *project,
DatasetID: *dataset,
TableID: *src2,
}
d := &bigquery.Table{
ProjectID: *project,
DatasetID: *dataset,
TableID: *dest,
WriteDisposition: bigquery.WriteTruncate,
}
// Concatenate data.
job, err := client.Copy(context.Background(), d, bigquery.Tables{s1, s2})
if err != nil {
log.Fatalf("Concatenating: %v", err)
}
fmt.Printf("Job for concatenation operation: %+v\n", job)
fmt.Printf("Waiting for job to complete.\n")
for range time.Tick(*pollint) {
status, err := job.Status(context.Background())
if err != nil {
fmt.Printf("Failure determining status: %v", err)
break
}
if !status.Done() {
continue
}
if err := status.Err(); err == nil {
fmt.Printf("Success\n")
} else {
fmt.Printf("Failure: %+v\n", err)
}
break
}
}
================================================
FILE: vendor/google.golang.org/cloud/examples/bigquery/load/main.go
================================================
// Copyright 2015 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// load is an example client of the bigquery client library.
// It loads a file from Google Cloud Storage into a BigQuery table.
package main
import (
"flag"
"fmt"
"log"
"os"
"time"
"golang.org/x/net/context"
"golang.org/x/oauth2/google"
"google.golang.org/cloud/bigquery"
)
var (
project = flag.String("project", "", "The ID of a Google Cloud Platform project")
dataset = flag.String("dataset", "", "The ID of a BigQuery dataset")
table = flag.String("table", "", "The ID of a BigQuery table to load data into")
bucket = flag.String("bucket", "", "The name of a Google Cloud Storage bucket to load data from")
object = flag.String("object", "", "The name of a Google Cloud Storage object to load data from. Must exist within the bucket specified by --bucket")
skiprows = flag.Int64("skiprows", 0, "The number of rows of the source data to skip when loading")
pollint = flag.Duration("pollint", 10*time.Second, "Polling interval for checking job status")
)
func main() {
flag.Parse()
flagsOk := true
for _, f := range []string{"project", "dataset", "table", "bucket", "object"} {
if flag.Lookup(f).Value.String() == "" {
fmt.Fprintf(os.Stderr, "Flag --%s is required\n", f)
flagsOk = false
}
}
if !flagsOk {
os.Exit(1)
}
httpClient, err := google.DefaultClient(context.Background(), bigquery.Scope)
if err != nil {
log.Fatalf("Creating http client: %v", err)
}
client, err := bigquery.NewClient(httpClient, *project)
if err != nil {
log.Fatalf("Creating bigquery client: %v", err)
}
table := &bigquery.Table{
ProjectID: *project,
DatasetID: *dataset,
TableID: *table,
WriteDisposition: bigquery.WriteTruncate,
}
gcs := client.NewGCSReference(fmt.Sprintf("gs://%s/%s", *bucket, *object))
gcs.SkipLeadingRows = *skiprows
// Load data from Google Cloud Storage into a BigQuery table.
job, err := client.Copy(
context.Background(), table, gcs,
bigquery.MaxBadRecords(1),
bigquery.AllowQuotedNewlines())
if err != nil {
log.Fatalf("Loading data: %v", err)
}
fmt.Printf("Job for data load operation: %+v\n", job)
fmt.Printf("Waiting for job to complete.\n")
for range time.Tick(*pollint) {
status, err := job.Status(context.Background())
if err != nil {
fmt.Printf("Failure determining status: %v", err)
break
}
if !status.Done() {
continue
}
if err := status.Err(); err == nil {
fmt.Printf("Success\n")
} else {
fmt.Printf("Failure: %+v\n", err)
}
break
}
}
================================================
FILE: vendor/google.golang.org/cloud/examples/bigquery/query/main.go
================================================
// Copyright 2015 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// query is an example client of the bigquery client library.
// It submits a query and writes the result to a table.
package main
import (
"flag"
"fmt"
"log"
"os"
"time"
"golang.org/x/net/context"
"golang.org/x/oauth2/google"
"google.golang.org/cloud/bigquery"
)
var (
project = flag.String("project", "", "The ID of a Google Cloud Platform project")
dataset = flag.String("dataset", "", "The ID of a BigQuery dataset")
q = flag.String("q", "", "The query string")
dest = flag.String("dest", "", "The ID of the BigQuery table to write the result to. If unset, an ephemeral table ID will be generated.")
pollint = flag.Duration("pollint", 10*time.Second, "Polling interval for checking job status")
)
func main() {
flag.Parse()
flagsOk := true
for _, f := range []string{"project", "dataset", "q"} {
if flag.Lookup(f).Value.String() == "" {
fmt.Fprintf(os.Stderr, "Flag --%s is required\n", f)
flagsOk = false
}
}
if !flagsOk {
os.Exit(1)
}
httpClient, err := google.DefaultClient(context.Background(), bigquery.Scope)
if err != nil {
log.Fatalf("Creating http client: %v", err)
}
client, err := bigquery.NewClient(httpClient, *project)
if err != nil {
log.Fatalf("Creating bigquery client: %v", err)
}
d := &bigquery.Table{
WriteDisposition: bigquery.WriteTruncate,
}
if *dest != "" {
d.ProjectID = *project
d.DatasetID = *dataset
d.TableID = *dest
}
query := &bigquery.Query{
Q: *q,
DefaultProjectID: *project,
DefaultDatasetID: *dataset,
}
// Query data.
job, err := client.Copy(context.Background(), d, query)
if err != nil {
log.Fatalf("Querying: %v", err)
}
fmt.Printf("Job for query operation: %+v\n", job)
fmt.Printf("Waiting for job to complete.\n")
for range time.Tick(*pollint) {
status, err := job.Status(context.Background())
if err != nil {
fmt.Printf("Failure determining status: %v", err)
break
}
if !status.Done() {
continue
}
if err := status.Err(); err == nil {
fmt.Printf("Success\n")
} else {
fmt.Printf("Failure: %+v\n", err)
}
break
}
}
================================================
FILE: vendor/google.golang.org/cloud/examples/bigquery/read/main.go
================================================
// Copyright 2015 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// read is an example client of the bigquery client library.
// It reads from a table, returning the data via an Iterator.
package main
import (
"flag"
"fmt"
"log"
"os"
"text/tabwriter"
"golang.org/x/net/context"
"golang.org/x/oauth2/google"
"google.golang.org/cloud/bigquery"
)
var (
project = flag.String("project", "", "The ID of a Google Cloud Platform project")
dataset = flag.String("dataset", "", "The ID of a BigQuery dataset")
table = flag.String("table", "", "The ID of a BigQuery table.")
)
func main() {
flag.Parse()
flagsOk := true
for _, f := range []string{"project", "dataset", "table"} {
if flag.Lookup(f).Value.String() == "" {
fmt.Fprintf(os.Stderr, "Flag --%s is required\n", f)
flagsOk = false
}
}
if !flagsOk {
os.Exit(1)
}
httpClient, err := google.DefaultClient(context.Background(), bigquery.Scope)
if err != nil {
log.Fatalf("Creating http client: %v", err)
}
client, err := bigquery.NewClient(httpClient, *project)
if err != nil {
log.Fatalf("Creating bigquery client: %v", err)
}
it, err := client.Read(&bigquery.Table{
ProjectID: *project,
DatasetID: *dataset,
TableID: *table,
})
if err != nil {
log.Fatalf("Reading: %v", err)
}
// one-space padding.
tw := tabwriter.NewWriter(os.Stdout, 0, 0, 1, ' ', 0)
for it.Next(context.Background()) {
var vals bigquery.ValueList
if err := it.Get(&vals); err != nil {
fmt.Printf("err calling get: %v\n", err)
} else {
sep := ""
for _, v := range vals {
fmt.Fprintf(tw, "%s%v", sep, v)
sep = "\t"
}
fmt.Fprintf(tw, "\n")
}
}
tw.Flush()
if err := it.Err(); err != nil {
fmt.Printf("err reading: %v\n")
}
}
================================================
FILE: vendor/google.golang.org/cloud/examples/pubsub/cmdline/main.go
================================================
// Copyright 2014 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Package main contains a simple command line tool for Cloud Pub/Sub
// Cloud Pub/Sub docs: https://cloud.google.com/pubsub/docs
package main
import (
"errors"
"flag"
"fmt"
"io/ioutil"
"log"
"net/http"
"os"
"strconv"
"time"
"golang.org/x/net/context"
"golang.org/x/oauth2"
"golang.org/x/oauth2/google"
"google.golang.org/cloud"
"google.golang.org/cloud/compute/metadata"
"google.golang.org/cloud/pubsub"
)
var (
jsonFile = flag.String("j", "", "A path to your JSON key file for your service account downloaded from Google Developer Console, not needed if you run it on Compute Engine instances.")
projID = flag.String("p", "", "The ID of your Google Cloud project.")
reportMPS = flag.Bool("report", false, "Reports the incoming/outgoing message rate in msg/sec if set.")
size = flag.Int("size", 10, "Batch size for pull_messages and publish_messages subcommands.")
)
const (
usage = `Available arguments are:
create_topic
delete_topic
create_subscription
delete_subscription
publish
pull_messages
publish_messages
`
tick = 1 * time.Second
)
func usageAndExit(msg string) {
fmt.Fprintln(os.Stderr, msg)
fmt.Println("Flags:")
flag.PrintDefaults()
fmt.Fprint(os.Stderr, usage)
os.Exit(2)
}
// Check the length of the arguments.
func checkArgs(argv []string, min int) {
if len(argv) < min {
usageAndExit("Missing arguments")
}
}
// newClient creates http.Client with a jwt service account when
// jsonFile flag is specified, otherwise by obtaining the GCE service
// account's access token.
func newClient(jsonFile string) (*http.Client, error) {
if jsonFile != "" {
jsonKey, err := ioutil.ReadFile(jsonFile)
if err != nil {
return nil, err
}
conf, err := google.JWTConfigFromJSON(jsonKey, pubsub.ScopePubSub)
if err != nil {
return nil, err
}
return conf.Client(oauth2.NoContext), nil
}
if metadata.OnGCE() {
c := &http.Client{
Transport: &oauth2.Transport{
Source: google.ComputeTokenSource(""),
},
}
if *projID == "" {
projectID, err := metadata.ProjectID()
if err != nil {
return nil, fmt.Errorf("ProjectID failed, %v", err)
}
*projID = projectID
}
return c, nil
}
return nil, errors.New("Could not create an authenticated client.")
}
func listTopics(ctx context.Context, argv []string) {
panic("listTopics not implemented yet")
}
func createTopic(ctx context.Context, argv []string) {
checkArgs(argv, 2)
topic := argv[1]
err := pubsub.CreateTopic(ctx, topic)
if err != nil {
log.Fatalf("CreateTopic failed, %v", err)
}
fmt.Printf("Topic %s was created.\n", topic)
}
func deleteTopic(ctx context.Context, argv []string) {
checkArgs(argv, 2)
topic := argv[1]
err := pubsub.DeleteTopic(ctx, topic)
if err != nil {
log.Fatalf("DeleteTopic failed, %v", err)
}
fmt.Printf("Topic %s was deleted.\n", topic)
}
func listSubscriptions(ctx context.Context, argv []string) {
panic("listSubscriptions not implemented yet")
}
func createSubscription(ctx context.Context, argv []string) {
checkArgs(argv, 3)
sub := argv[1]
topic := argv[2]
err := pubsub.CreateSub(ctx, sub, topic, 60*time.Second, "")
if err != nil {
log.Fatalf("CreateSub failed, %v", err)
}
fmt.Printf("Subscription %s was created.\n", sub)
}
func deleteSubscription(ctx context.Context, argv []string) {
checkArgs(argv, 2)
sub := argv[1]
err := pubsub.DeleteSub(ctx, sub)
if err != nil {
log.Fatalf("DeleteSub failed, %v", err)
}
fmt.Printf("Subscription %s was deleted.\n", sub)
}
func publish(ctx context.Context, argv []string) {
checkArgs(argv, 3)
topic := argv[1]
message := argv[2]
msgIDs, err := pubsub.Publish(ctx, topic, &pubsub.Message{
Data: []byte(message),
})
if err != nil {
log.Fatalf("Publish failed, %v", err)
}
fmt.Printf("Message '%s' published to a topic %s and the message id is %s\n", message, topic, msgIDs[0])
}
type reporter struct {
reportTitle string
lastC uint64
c uint64
result <-chan int
}
func (r *reporter) report() {
ticker := time.NewTicker(tick)
defer func() {
ticker.Stop()
}()
for {
select {
case <-ticker.C:
n := r.c - r.lastC
r.lastC = r.c
mps := n / uint64(tick/time.Second)
log.Printf("%s ~%d msgs/s, total: %d", r.reportTitle, mps, r.c)
case n := <-r.result:
r.c += uint64(n)
}
}
}
func ack(ctx context.Context, sub string, ackID ...string) {
err := pubsub.Ack(ctx, sub, ackID...)
if err != nil {
log.Printf("Ack failed, %v\n", err)
}
}
func pullLoop(ctx context.Context, sub string, result chan<- int) {
for {
msgs, err := pubsub.PullWait(ctx, sub, *size)
if err != nil {
log.Printf("PullWait failed, %v\n", err)
time.Sleep(5 * time.Second)
continue
}
if len(msgs) == 0 {
log.Println("Received no messages")
continue
}
if *reportMPS {
result <- len(msgs)
}
ackIDs := make([]string, len(msgs))
for i, msg := range msgs {
if !*reportMPS {
fmt.Printf("Got a message: %s\n", msg.Data)
}
ackIDs[i] = msg.AckID
}
go ack(ctx, sub, ackIDs...)
}
}
func pullMessages(ctx context.Context, argv []string) {
checkArgs(argv, 3)
sub := argv[1]
workers, err := strconv.Atoi(argv[2])
if err != nil {
log.Fatalf("Atoi failed, %v", err)
}
result := make(chan int, 1024)
for i := 0; i < int(workers); i++ {
go pullLoop(ctx, sub, result)
}
if *reportMPS {
r := reporter{reportTitle: "Received", result: result}
r.report()
} else {
select {}
}
}
func publishLoop(ctx context.Context, topic string, workerid int, result chan<- int) {
var r uint64
for {
msgs := make([]*pubsub.Message, *size)
for i := 0; i < *size; i++ {
msgs[i] = &pubsub.Message{
Data: []byte(fmt.Sprintf("Worker: %d, Round: %d, Message: %d", workerid, r, i)),
}
}
_, err := pubsub.Publish(ctx, topic, msgs...)
if err != nil {
log.Printf("Publish failed, %v\n", err)
return
}
r++
if *reportMPS {
result <- *size
}
}
}
func publishMessages(ctx context.Context, argv []string) {
checkArgs(argv, 3)
topic := argv[1]
workers, err := strconv.Atoi(argv[2])
if err != nil {
log.Fatalf("Atoi failed, %v", err)
}
result := make(chan int, 1024)
for i := 0; i < int(workers); i++ {
go publishLoop(ctx, topic, i, result)
}
if *reportMPS {
r := reporter{reportTitle: "Sent", result: result}
r.report()
} else {
select {}
}
}
// This example demonstrates calling the Cloud Pub/Sub API. As of 22
// Oct 2014, the Cloud Pub/Sub API is only available if you're
// whitelisted. If you're interested in using it, please apply for the
// Limited Preview program at the following form:
// http://goo.gl/Wql9HL
//
// Also, before running this example, be sure to enable Cloud Pub/Sub
// service on your project in Developer Console at:
// https://console.developers.google.com/
//
// Unless you run this sample on Compute Engine instance, please
// create a new service account and download a JSON key file for it at
// the developer console: https://console.developers.google.com/
//
// It has the following subcommands:
//
// create_topic
// delete_topic
// create_subscription
// delete_subscription
// publish
// pull_messages
// publish_messages
//
// You can choose any names for topic and subscription as long as they
// follow the naming rule described at:
// https://cloud.google.com/pubsub/overview#names
//
// You can create/delete topics/subscriptions by self-explanatory
// subcommands.
//
// The "publish" subcommand is for publishing a single message to a
// specified Cloud Pub/Sub topic.
//
// The "pull_messages" subcommand is for continuously pulling messages
// from a specified Cloud Pub/Sub subscription with specified number
// of workers.
//
// The "publish_messages" subcommand is for continuously publishing
// messages to a specified Cloud Pub/Sub topic with specified number
// of workers.
func main() {
flag.Parse()
argv := flag.Args()
checkArgs(argv, 1)
client, err := newClient(*jsonFile)
if err != nil {
log.Fatalf("clientAndId failed, %v", err)
}
if *projID == "" {
usageAndExit("Please specify Project ID.")
}
ctx := cloud.NewContext(*projID, client)
m := map[string]func(ctx context.Context, argv []string){
"create_topic": createTopic,
"delete_topic": deleteTopic,
"create_subscription": createSubscription,
"delete_subscription": deleteSubscription,
"publish": publish,
"pull_messages": pullMessages,
"publish_messages": publishMessages,
}
subcommand := argv[0]
f, ok := m[subcommand]
if !ok {
usageAndExit(fmt.Sprintf("Function not found for %s", subcommand))
}
f(ctx, argv)
}
================================================
FILE: vendor/google.golang.org/cloud/examples/storage/appengine/app.go
================================================
// Copyright 2014 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Package gcsdemo is an example App Engine or Mananged VM app using the Google Cloud Storage API.
package gcsdemo
import (
"bytes"
"fmt"
"io"
"io/ioutil"
"net/http"
"strings"
"golang.org/x/net/context"
"golang.org/x/oauth2"
"golang.org/x/oauth2/google"
"google.golang.org/appengine"
"google.golang.org/appengine/file"
"google.golang.org/appengine/log"
"google.golang.org/appengine/urlfetch"
"google.golang.org/cloud"
"google.golang.org/cloud/storage"
)
// bucket is a local cache of the app's default bucket name.
var bucket string // or: var bucket = ".appspot.com"
func init() {
http.HandleFunc("/", handler)
}
// demo struct holds information needed to run the various demo functions.
type demo struct {
c context.Context
w http.ResponseWriter
ctx context.Context
// cleanUp is a list of filenames that need cleaning up at the end of the demo.
cleanUp []string
// failed indicates that one or more of the demo steps failed.
failed bool
}
func (d *demo) errorf(format string, args ...interface{}) {
d.failed = true
log.Errorf(d.c, format, args...)
}
// handler is the main demo entry point that calls the GCS operations.
func handler(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/" {
http.NotFound(w, r)
return
}
c := appengine.NewContext(r)
if bucket == "" {
var err error
if bucket, err = file.DefaultBucketName(c); err != nil {
log.Errorf(c, "failed to get default GCS bucket name: %v", err)
return
}
}
hc := &http.Client{
Transport: &oauth2.Transport{
Source: google.AppEngineTokenSource(c, storage.ScopeFullControl),
Base: &urlfetch.Transport{Context: c},
},
}
ctx := cloud.NewContext(appengine.AppID(c), hc)
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
fmt.Fprintf(w, "Demo GCS Application running from Version: %v\n", appengine.VersionID(c))
fmt.Fprintf(w, "Using bucket name: %v\n\n", bucket)
d := &demo{
c: c,
w: w,
ctx: ctx,
}
n := "demo-testfile-go"
d.createFile(n)
d.readFile(n)
d.copyFile(n)
d.statFile(n)
d.createListFiles()
d.listBucket()
d.listBucketDirMode()
d.defaultACL()
d.putDefaultACLRule()
d.deleteDefaultACLRule()
d.bucketACL()
d.putBucketACLRule()
d.deleteBucketACLRule()
d.acl(n)
d.putACLRule(n)
d.deleteACLRule(n)
d.deleteFiles()
if d.failed {
io.WriteString(w, "\nDemo failed.\n")
} else {
io.WriteString(w, "\nDemo succeeded.\n")
}
}
// createFile creates a file in Google Cloud Storage.
func (d *demo) createFile(fileName string) {
fmt.Fprintf(d.w, "Creating file /%v/%v\n", bucket, fileName)
wc := storage.NewWriter(d.ctx, bucket, fileName)
wc.ContentType = "text/plain"
wc.Metadata = map[string]string{
"x-goog-meta-foo": "foo",
"x-goog-meta-bar": "bar",
}
d.cleanUp = append(d.cleanUp, fileName)
if _, err := wc.Write([]byte("abcde\n")); err != nil {
d.errorf("createFile: unable to write data to bucket %q, file %q: %v", bucket, fileName, err)
return
}
if _, err := wc.Write([]byte(strings.Repeat("f", 1024*4) + "\n")); err != nil {
d.errorf("createFile: unable to write data to bucket %q, file %q: %v", bucket, fileName, err)
return
}
if err := wc.Close(); err != nil {
d.errorf("createFile: unable to close bucket %q, file %q: %v", bucket, fileName, err)
return
}
}
// readFile reads the named file in Google Cloud Storage.
func (d *demo) readFile(fileName string) {
io.WriteString(d.w, "\nAbbreviated file content (first line and last 1K):\n")
rc, err := storage.NewReader(d.ctx, bucket, fileName)
if err != nil {
d.errorf("readFile: unable to open file from bucket %q, file %q: %v", bucket, fileName, err)
return
}
defer rc.Close()
slurp, err := ioutil.ReadAll(rc)
if err != nil {
d.errorf("readFile: unable to read data from bucket %q, file %q: %v", bucket, fileName, err)
return
}
fmt.Fprintf(d.w, "%s\n", bytes.SplitN(slurp, []byte("\n"), 2)[0])
if len(slurp) > 1024 {
fmt.Fprintf(d.w, "...%s\n", slurp[len(slurp)-1024:])
} else {
fmt.Fprintf(d.w, "%s\n", slurp)
}
}
// copyFile copies a file in Google Cloud Storage.
func (d *demo) copyFile(fileName string) {
copyName := fileName + "-copy"
fmt.Fprintf(d.w, "Copying file /%v/%v to /%v/%v:\n", bucket, fileName, bucket, copyName)
obj, err := storage.CopyObject(d.ctx, bucket, fileName, bucket, copyName, nil)
if err != nil {
d.errorf("copyFile: unable to copy /%v/%v to bucket %q, file %q: %v", bucket, fileName, bucket, copyName, err)
return
}
d.cleanUp = append(d.cleanUp, copyName)
d.dumpStats(obj)
}
func (d *demo) dumpStats(obj *storage.Object) {
fmt.Fprintf(d.w, "(filename: /%v/%v, ", obj.Bucket, obj.Name)
fmt.Fprintf(d.w, "ContentType: %q, ", obj.ContentType)
fmt.Fprintf(d.w, "ACL: %#v, ", obj.ACL)
fmt.Fprintf(d.w, "Owner: %v, ", obj.Owner)
fmt.Fprintf(d.w, "ContentEncoding: %q, ", obj.ContentEncoding)
fmt.Fprintf(d.w, "Size: %v, ", obj.Size)
fmt.Fprintf(d.w, "MD5: %q, ", obj.MD5)
fmt.Fprintf(d.w, "CRC32C: %q, ", obj.CRC32C)
fmt.Fprintf(d.w, "Metadata: %#v, ", obj.Metadata)
fmt.Fprintf(d.w, "MediaLink: %q, ", obj.MediaLink)
fmt.Fprintf(d.w, "StorageClass: %q, ", obj.StorageClass)
if !obj.Deleted.IsZero() {
fmt.Fprintf(d.w, "Deleted: %v, ", obj.Deleted)
}
fmt.Fprintf(d.w, "Updated: %v)\n", obj.Updated)
}
// statFile reads the stats of the named file in Google Cloud Storage.
func (d *demo) statFile(fileName string) {
io.WriteString(d.w, "\nFile stat:\n")
obj, err := storage.StatObject(d.ctx, bucket, fileName)
if err != nil {
d.errorf("statFile: unable to stat file from bucket %q, file %q: %v", bucket, fileName, err)
return
}
d.dumpStats(obj)
}
// createListFiles creates files that will be used by listBucket.
func (d *demo) createListFiles() {
io.WriteString(d.w, "\nCreating more files for listbucket...\n")
for _, n := range []string{"foo1", "foo2", "bar", "bar/1", "bar/2", "boo/"} {
d.createFile(n)
}
}
// listBucket lists the contents of a bucket in Google Cloud Storage.
func (d *demo) listBucket() {
io.WriteString(d.w, "\nListbucket result:\n")
query := &storage.Query{Prefix: "foo"}
for query != nil {
objs, err := storage.ListObjects(d.ctx, bucket, query)
if err != nil {
d.errorf("listBucket: unable to list bucket %q: %v", bucket, err)
return
}
query = objs.Next
for _, obj := range objs.Results {
d.dumpStats(obj)
}
}
}
func (d *demo) listDir(name, indent string) {
query := &storage.Query{Prefix: name, Delimiter: "/"}
for query != nil {
objs, err := storage.ListObjects(d.ctx, bucket, query)
if err != nil {
d.errorf("listBucketDirMode: unable to list bucket %q: %v", bucket, err)
return
}
query = objs.Next
for _, obj := range objs.Results {
fmt.Fprint(d.w, indent)
d.dumpStats(obj)
}
for _, dir := range objs.Prefixes {
fmt.Fprintf(d.w, "%v(directory: /%v/%v)\n", indent, bucket, dir)
d.listDir(dir, indent+" ")
}
}
}
// listBucketDirMode lists the contents of a bucket in dir mode in Google Cloud Storage.
func (d *demo) listBucketDirMode() {
io.WriteString(d.w, "\nListbucket directory mode result:\n")
d.listDir("b", "")
}
// dumpDefaultACL prints out the default object ACL for this bucket.
func (d *demo) dumpDefaultACL() {
acl, err := storage.DefaultACL(d.ctx, bucket)
if err != nil {
d.errorf("defaultACL: unable to list default object ACL for bucket %q: %v", bucket, err)
return
}
for _, v := range acl {
fmt.Fprintf(d.w, "Entity: %q, Role: %q\n", v.Entity, v.Role)
}
}
// defaultACL displays the default object ACL for this bucket.
func (d *demo) defaultACL() {
io.WriteString(d.w, "\nDefault object ACL:\n")
d.dumpDefaultACL()
}
// putDefaultACLRule adds the "allUsers" default object ACL rule for this bucket.
func (d *demo) putDefaultACLRule() {
io.WriteString(d.w, "\nPut Default object ACL Rule:\n")
err := storage.PutDefaultACLRule(d.ctx, bucket, "allUsers", storage.RoleReader)
if err != nil {
d.errorf("putDefaultACLRule: unable to save default object ACL rule for bucket %q: %v", bucket, err)
return
}
d.dumpDefaultACL()
}
// deleteDefaultACLRule deleted the "allUsers" default object ACL rule for this bucket.
func (d *demo) deleteDefaultACLRule() {
io.WriteString(d.w, "\nDelete Default object ACL Rule:\n")
err := storage.DeleteDefaultACLRule(d.ctx, bucket, "allUsers")
if err != nil {
d.errorf("deleteDefaultACLRule: unable to delete default object ACL rule for bucket %q: %v", bucket, err)
return
}
d.dumpDefaultACL()
}
// dumpBucketACL prints out the bucket ACL.
func (d *demo) dumpBucketACL() {
acl, err := storage.BucketACL(d.ctx, bucket)
if err != nil {
d.errorf("dumpBucketACL: unable to list bucket ACL for bucket %q: %v", bucket, err)
return
}
for _, v := range acl {
fmt.Fprintf(d.w, "Entity: %q, Role: %q\n", v.Entity, v.Role)
}
}
// bucketACL displays the bucket ACL for this bucket.
func (d *demo) bucketACL() {
io.WriteString(d.w, "\nBucket ACL:\n")
d.dumpBucketACL()
}
// putBucketACLRule adds the "allUsers" bucket ACL rule for this bucket.
func (d *demo) putBucketACLRule() {
io.WriteString(d.w, "\nPut Bucket ACL Rule:\n")
err := storage.PutBucketACLRule(d.ctx, bucket, "allUsers", storage.RoleReader)
if err != nil {
d.errorf("putBucketACLRule: unable to save bucket ACL rule for bucket %q: %v", bucket, err)
return
}
d.dumpBucketACL()
}
// deleteBucketACLRule deleted the "allUsers" bucket ACL rule for this bucket.
func (d *demo) deleteBucketACLRule() {
io.WriteString(d.w, "\nDelete Bucket ACL Rule:\n")
err := storage.DeleteBucketACLRule(d.ctx, bucket, "allUsers")
if err != nil {
d.errorf("deleteBucketACLRule: unable to delete bucket ACL rule for bucket %q: %v", bucket, err)
return
}
d.dumpBucketACL()
}
// dumpACL prints out the ACL of the named file.
func (d *demo) dumpACL(fileName string) {
acl, err := storage.ACL(d.ctx, bucket, fileName)
if err != nil {
d.errorf("dumpACL: unable to list file ACL for bucket %q, file %q: %v", bucket, fileName, err)
return
}
for _, v := range acl {
fmt.Fprintf(d.w, "Entity: %q, Role: %q\n", v.Entity, v.Role)
}
}
// acl displays the ACL for the named file.
func (d *demo) acl(fileName string) {
fmt.Fprintf(d.w, "\nACL for file %v:\n", fileName)
d.dumpACL(fileName)
}
// putACLRule adds the "allUsers" ACL rule for the named file.
func (d *demo) putACLRule(fileName string) {
fmt.Fprintf(d.w, "\nPut ACL rule for file %v:\n", fileName)
err := storage.PutACLRule(d.ctx, bucket, fileName, "allUsers", storage.RoleReader)
if err != nil {
d.errorf("putACLRule: unable to save ACL rule for bucket %q, file %q: %v", bucket, fileName, err)
return
}
d.dumpACL(fileName)
}
// deleteACLRule deleted the "allUsers" ACL rule for the named file.
func (d *demo) deleteACLRule(fileName string) {
fmt.Fprintf(d.w, "\nDelete ACL rule for file %v:\n", fileName)
err := storage.DeleteACLRule(d.ctx, bucket, fileName, "allUsers")
if err != nil {
d.errorf("deleteACLRule: unable to delete ACL rule for bucket %q, file %q: %v", bucket, fileName, err)
return
}
d.dumpACL(fileName)
}
// deleteFiles deletes all the temporary files from a bucket created by this demo.
func (d *demo) deleteFiles() {
io.WriteString(d.w, "\nDeleting files...\n")
for _, v := range d.cleanUp {
fmt.Fprintf(d.w, "Deleting file %v\n", v)
if err := storage.DeleteObject(d.ctx, bucket, v); err != nil {
d.errorf("deleteFiles: unable to delete bucket %q, file %q: %v", bucket, v, err)
return
}
}
}
================================================
FILE: vendor/google.golang.org/cloud/examples/storage/appengine/app.yaml
================================================
application:
version: v1
runtime: go
api_version: go1
handlers:
- url: /.*
script: _go_app
================================================
FILE: vendor/google.golang.org/cloud/examples/storage/appenginevm/app.go
================================================
// Copyright 2014 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Package gcsdemo is an example App Engine or Mananged VM app using the Google Cloud Storage API.
package gcsdemo
import (
"bytes"
"fmt"
"io"
"io/ioutil"
"net/http"
"strings"
"golang.org/x/net/context"
"golang.org/x/oauth2"
"golang.org/x/oauth2/google"
"google.golang.org/appengine"
"google.golang.org/appengine/file"
"google.golang.org/appengine/log"
"google.golang.org/appengine/urlfetch"
"google.golang.org/cloud"
"google.golang.org/cloud/storage"
)
// bucket is a local cache of the app's default bucket name.
var bucket string // or: var bucket = ".appspot.com"
func init() {
http.HandleFunc("/", handler)
}
// demo struct holds information needed to run the various demo functions.
type demo struct {
c context.Context
w http.ResponseWriter
ctx context.Context
// cleanUp is a list of filenames that need cleaning up at the end of the demo.
cleanUp []string
// failed indicates that one or more of the demo steps failed.
failed bool
}
func (d *demo) errorf(format string, args ...interface{}) {
d.failed = true
log.Errorf(d.c, format, args...)
}
// handler is the main demo entry point that calls the GCS operations.
func handler(w http.ResponseWriter, r *http.Request) {
if r.URL.Path != "/" {
http.NotFound(w, r)
return
}
c := appengine.NewContext(r)
if bucket == "" {
var err error
if bucket, err = file.DefaultBucketName(c); err != nil {
log.Errorf(c, "failed to get default GCS bucket name: %v", err)
return
}
}
hc := &http.Client{
Transport: &oauth2.Transport{
Source: google.AppEngineTokenSource(c, storage.ScopeFullControl),
Base: &urlfetch.Transport{Context: c},
},
}
ctx := cloud.NewContext(appengine.AppID(c), hc)
w.Header().Set("Content-Type", "text/plain; charset=utf-8")
fmt.Fprintf(w, "Demo GCS Application running from Version: %v\n", appengine.VersionID(c))
fmt.Fprintf(w, "Using bucket name: %v\n\n", bucket)
d := &demo{
c: c,
w: w,
ctx: ctx,
}
n := "demo-testfile-go"
d.createFile(n)
d.readFile(n)
d.copyFile(n)
d.statFile(n)
d.createListFiles()
d.listBucket()
d.listBucketDirMode()
d.defaultACL()
d.putDefaultACLRule()
d.deleteDefaultACLRule()
d.bucketACL()
d.putBucketACLRule()
d.deleteBucketACLRule()
d.acl(n)
d.putACLRule(n)
d.deleteACLRule(n)
d.deleteFiles()
if d.failed {
io.WriteString(w, "\nDemo failed.\n")
} else {
io.WriteString(w, "\nDemo succeeded.\n")
}
}
// createFile creates a file in Google Cloud Storage.
func (d *demo) createFile(fileName string) {
fmt.Fprintf(d.w, "Creating file /%v/%v\n", bucket, fileName)
wc := storage.NewWriter(d.ctx, bucket, fileName)
wc.ContentType = "text/plain"
wc.Metadata = map[string]string{
"x-goog-meta-foo": "foo",
"x-goog-meta-bar": "bar",
}
d.cleanUp = append(d.cleanUp, fileName)
if _, err := wc.Write([]byte("abcde\n")); err != nil {
d.errorf("createFile: unable to write data to bucket %q, file %q: %v", bucket, fileName, err)
return
}
if _, err := wc.Write([]byte(strings.Repeat("f", 1024*4) + "\n")); err != nil {
d.errorf("createFile: unable to write data to bucket %q, file %q: %v", bucket, fileName, err)
return
}
if err := wc.Close(); err != nil {
d.errorf("createFile: unable to close bucket %q, file %q: %v", bucket, fileName, err)
return
}
}
// readFile reads the named file in Google Cloud Storage.
func (d *demo) readFile(fileName string) {
io.WriteString(d.w, "\nAbbreviated file content (first line and last 1K):\n")
rc, err := storage.NewReader(d.ctx, bucket, fileName)
if err != nil {
d.errorf("readFile: unable to open file from bucket %q, file %q: %v", bucket, fileName, err)
return
}
defer rc.Close()
slurp, err := ioutil.ReadAll(rc)
if err != nil {
d.errorf("readFile: unable to read data from bucket %q, file %q: %v", bucket, fileName, err)
return
}
fmt.Fprintf(d.w, "%s\n", bytes.SplitN(slurp, []byte("\n"), 2)[0])
if len(slurp) > 1024 {
fmt.Fprintf(d.w, "...%s\n", slurp[len(slurp)-1024:])
} else {
fmt.Fprintf(d.w, "%s\n", slurp)
}
}
// copyFile copies a file in Google Cloud Storage.
func (d *demo) copyFile(fileName string) {
copyName := fileName + "-copy"
fmt.Fprintf(d.w, "Copying file /%v/%v to /%v/%v:\n", bucket, fileName, bucket, copyName)
obj, err := storage.CopyObject(d.ctx, bucket, fileName, bucket, copyName, nil)
if err != nil {
d.errorf("copyFile: unable to copy /%v/%v to bucket %q, file %q: %v", bucket, fileName, bucket, copyName, err)
return
}
d.cleanUp = append(d.cleanUp, copyName)
d.dumpStats(obj)
}
func (d *demo) dumpStats(obj *storage.Object) {
fmt.Fprintf(d.w, "(filename: /%v/%v, ", obj.Bucket, obj.Name)
fmt.Fprintf(d.w, "ContentType: %q, ", obj.ContentType)
fmt.Fprintf(d.w, "ACL: %#v, ", obj.ACL)
fmt.Fprintf(d.w, "Owner: %v, ", obj.Owner)
fmt.Fprintf(d.w, "ContentEncoding: %q, ", obj.ContentEncoding)
fmt.Fprintf(d.w, "Size: %v, ", obj.Size)
fmt.Fprintf(d.w, "MD5: %q, ", obj.MD5)
fmt.Fprintf(d.w, "CRC32C: %q, ", obj.CRC32C)
fmt.Fprintf(d.w, "Metadata: %#v, ", obj.Metadata)
fmt.Fprintf(d.w, "MediaLink: %q, ", obj.MediaLink)
fmt.Fprintf(d.w, "StorageClass: %q, ", obj.StorageClass)
if !obj.Deleted.IsZero() {
fmt.Fprintf(d.w, "Deleted: %v, ", obj.Deleted)
}
fmt.Fprintf(d.w, "Updated: %v)\n", obj.Updated)
}
// statFile reads the stats of the named file in Google Cloud Storage.
func (d *demo) statFile(fileName string) {
io.WriteString(d.w, "\nFile stat:\n")
obj, err := storage.StatObject(d.ctx, bucket, fileName)
if err != nil {
d.errorf("statFile: unable to stat file from bucket %q, file %q: %v", bucket, fileName, err)
return
}
d.dumpStats(obj)
}
// createListFiles creates files that will be used by listBucket.
func (d *demo) createListFiles() {
io.WriteString(d.w, "\nCreating more files for listbucket...\n")
for _, n := range []string{"foo1", "foo2", "bar", "bar/1", "bar/2", "boo/"} {
d.createFile(n)
}
}
// listBucket lists the contents of a bucket in Google Cloud Storage.
func (d *demo) listBucket() {
io.WriteString(d.w, "\nListbucket result:\n")
query := &storage.Query{Prefix: "foo"}
for query != nil {
objs, err := storage.ListObjects(d.ctx, bucket, query)
if err != nil {
d.errorf("listBucket: unable to list bucket %q: %v", bucket, err)
return
}
query = objs.Next
for _, obj := range objs.Results {
d.dumpStats(obj)
}
}
}
func (d *demo) listDir(name, indent string) {
query := &storage.Query{Prefix: name, Delimiter: "/"}
for query != nil {
objs, err := storage.ListObjects(d.ctx, bucket, query)
if err != nil {
d.errorf("listBucketDirMode: unable to list bucket %q: %v", bucket, err)
return
}
query = objs.Next
for _, obj := range objs.Results {
fmt.Fprint(d.w, indent)
d.dumpStats(obj)
}
for _, dir := range objs.Prefixes {
fmt.Fprintf(d.w, "%v(directory: /%v/%v)\n", indent, bucket, dir)
d.listDir(dir, indent+" ")
}
}
}
// listBucketDirMode lists the contents of a bucket in dir mode in Google Cloud Storage.
func (d *demo) listBucketDirMode() {
io.WriteString(d.w, "\nListbucket directory mode result:\n")
d.listDir("b", "")
}
// dumpDefaultACL prints out the default object ACL for this bucket.
func (d *demo) dumpDefaultACL() {
acl, err := storage.DefaultACL(d.ctx, bucket)
if err != nil {
d.errorf("defaultACL: unable to list default object ACL for bucket %q: %v", bucket, err)
return
}
for _, v := range acl {
fmt.Fprintf(d.w, "Entity: %q, Role: %q\n", v.Entity, v.Role)
}
}
// defaultACL displays the default object ACL for this bucket.
func (d *demo) defaultACL() {
io.WriteString(d.w, "\nDefault object ACL:\n")
d.dumpDefaultACL()
}
// putDefaultACLRule adds the "allUsers" default object ACL rule for this bucket.
func (d *demo) putDefaultACLRule() {
io.WriteString(d.w, "\nPut Default object ACL Rule:\n")
err := storage.PutDefaultACLRule(d.ctx, bucket, "allUsers", storage.RoleReader)
if err != nil {
d.errorf("putDefaultACLRule: unable to save default object ACL rule for bucket %q: %v", bucket, err)
return
}
d.dumpDefaultACL()
}
// deleteDefaultACLRule deleted the "allUsers" default object ACL rule for this bucket.
func (d *demo) deleteDefaultACLRule() {
io.WriteString(d.w, "\nDelete Default object ACL Rule:\n")
err := storage.DeleteDefaultACLRule(d.ctx, bucket, "allUsers")
if err != nil {
d.errorf("deleteDefaultACLRule: unable to delete default object ACL rule for bucket %q: %v", bucket, err)
return
}
d.dumpDefaultACL()
}
// dumpBucketACL prints out the bucket ACL.
func (d *demo) dumpBucketACL() {
acl, err := storage.BucketACL(d.ctx, bucket)
if err != nil {
d.errorf("dumpBucketACL: unable to list bucket ACL for bucket %q: %v", bucket, err)
return
}
for _, v := range acl {
fmt.Fprintf(d.w, "Entity: %q, Role: %q\n", v.Entity, v.Role)
}
}
// bucketACL displays the bucket ACL for this bucket.
func (d *demo) bucketACL() {
io.WriteString(d.w, "\nBucket ACL:\n")
d.dumpBucketACL()
}
// putBucketACLRule adds the "allUsers" bucket ACL rule for this bucket.
func (d *demo) putBucketACLRule() {
io.WriteString(d.w, "\nPut Bucket ACL Rule:\n")
err := storage.PutBucketACLRule(d.ctx, bucket, "allUsers", storage.RoleReader)
if err != nil {
d.errorf("putBucketACLRule: unable to save bucket ACL rule for bucket %q: %v", bucket, err)
return
}
d.dumpBucketACL()
}
// deleteBucketACLRule deleted the "allUsers" bucket ACL rule for this bucket.
func (d *demo) deleteBucketACLRule() {
io.WriteString(d.w, "\nDelete Bucket ACL Rule:\n")
err := storage.DeleteBucketACLRule(d.ctx, bucket, "allUsers")
if err != nil {
d.errorf("deleteBucketACLRule: unable to delete bucket ACL rule for bucket %q: %v", bucket, err)
return
}
d.dumpBucketACL()
}
// dumpACL prints out the ACL of the named file.
func (d *demo) dumpACL(fileName string) {
acl, err := storage.ACL(d.ctx, bucket, fileName)
if err != nil {
d.errorf("dumpACL: unable to list file ACL for bucket %q, file %q: %v", bucket, fileName, err)
return
}
for _, v := range acl {
fmt.Fprintf(d.w, "Entity: %q, Role: %q\n", v.Entity, v.Role)
}
}
// acl displays the ACL for the named file.
func (d *demo) acl(fileName string) {
fmt.Fprintf(d.w, "\nACL for file %v:\n", fileName)
d.dumpACL(fileName)
}
// putACLRule adds the "allUsers" ACL rule for the named file.
func (d *demo) putACLRule(fileName string) {
fmt.Fprintf(d.w, "\nPut ACL rule for file %v:\n", fileName)
err := storage.PutACLRule(d.ctx, bucket, fileName, "allUsers", storage.RoleReader)
if err != nil {
d.errorf("putACLRule: unable to save ACL rule for bucket %q, file %q: %v", bucket, fileName, err)
return
}
d.dumpACL(fileName)
}
// deleteACLRule deleted the "allUsers" ACL rule for the named file.
func (d *demo) deleteACLRule(fileName string) {
fmt.Fprintf(d.w, "\nDelete ACL rule for file %v:\n", fileName)
err := storage.DeleteACLRule(d.ctx, bucket, fileName, "allUsers")
if err != nil {
d.errorf("deleteACLRule: unable to delete ACL rule for bucket %q, file %q: %v", bucket, fileName, err)
return
}
d.dumpACL(fileName)
}
// deleteFiles deletes all the temporary files from a bucket created by this demo.
func (d *demo) deleteFiles() {
io.WriteString(d.w, "\nDeleting files...\n")
for _, v := range d.cleanUp {
fmt.Fprintf(d.w, "Deleting file %v\n", v)
if err := storage.DeleteObject(d.ctx, bucket, v); err != nil {
d.errorf("deleteFiles: unable to delete bucket %q, file %q: %v", bucket, v, err)
return
}
}
}
================================================
FILE: vendor/google.golang.org/cloud/examples/storage/appenginevm/app.yaml
================================================
application:
version: v1
runtime: go
api_version: go1
vm: true
manual_scaling:
instances: 1
handlers:
- url: /.*
script: _go_app
================================================
FILE: vendor/google.golang.org/cloud/internal/cloud.go
================================================
// Copyright 2014 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Package internal provides support for the cloud packages.
//
// Users should not import this package directly.
package internal
import (
"fmt"
"net/http"
"sync"
"golang.org/x/net/context"
)
type contextKey struct{}
func WithContext(parent context.Context, projID string, c *http.Client) context.Context {
if c == nil {
panic("nil *http.Client passed to WithContext")
}
if projID == "" {
panic("empty project ID passed to WithContext")
}
return context.WithValue(parent, contextKey{}, &cloudContext{
ProjectID: projID,
HTTPClient: c,
})
}
const userAgent = "gcloud-golang/0.1"
type cloudContext struct {
ProjectID string
HTTPClient *http.Client
mu sync.Mutex // guards svc
svc map[string]interface{} // e.g. "storage" => *rawStorage.Service
}
// Service returns the result of the fill function if it's never been
// called before for the given name (which is assumed to be an API
// service name, like "datastore"). If it has already been cached, the fill
// func is not run.
// It's safe for concurrent use by multiple goroutines.
func Service(ctx context.Context, name string, fill func(*http.Client) interface{}) interface{} {
return cc(ctx).service(name, fill)
}
func (c *cloudContext) service(name string, fill func(*http.Client) interface{}) interface{} {
c.mu.Lock()
defer c.mu.Unlock()
if c.svc == nil {
c.svc = make(map[string]interface{})
} else if v, ok := c.svc[name]; ok {
return v
}
v := fill(c.HTTPClient)
c.svc[name] = v
return v
}
// Transport is an http.RoundTripper that appends
// Google Cloud client's user-agent to the original
// request's user-agent header.
type Transport struct {
// Base represents the actual http.RoundTripper
// the requests will be delegated to.
Base http.RoundTripper
}
// RoundTrip appends a user-agent to the existing user-agent
// header and delegates the request to the base http.RoundTripper.
func (t *Transport) RoundTrip(req *http.Request) (*http.Response, error) {
req = cloneRequest(req)
ua := req.Header.Get("User-Agent")
if ua == "" {
ua = userAgent
} else {
ua = fmt.Sprintf("%s %s", ua, userAgent)
}
req.Header.Set("User-Agent", ua)
return t.Base.RoundTrip(req)
}
// cloneRequest returns a clone of the provided *http.Request.
// The clone is a shallow copy of the struct and its Header map.
func cloneRequest(r *http.Request) *http.Request {
// shallow copy of the struct
r2 := new(http.Request)
*r2 = *r
// deep copy of the Header
r2.Header = make(http.Header)
for k, s := range r.Header {
r2.Header[k] = s
}
return r2
}
func ProjID(ctx context.Context) string {
return cc(ctx).ProjectID
}
func HTTPClient(ctx context.Context) *http.Client {
return cc(ctx).HTTPClient
}
// cc returns the internal *cloudContext (cc) state for a context.Context.
// It panics if the user did it wrong.
func cc(ctx context.Context) *cloudContext {
if c, ok := ctx.Value(contextKey{}).(*cloudContext); ok {
return c
}
panic("invalid context.Context type; it should be created with cloud.NewContext")
}
================================================
FILE: vendor/google.golang.org/cloud/internal/datastore/datastore_v1.pb.go
================================================
// Code generated by protoc-gen-go.
// source: datastore_v1.proto
// DO NOT EDIT!
/*
Package datastore is a generated protocol buffer package.
It is generated from these files:
datastore_v1.proto
It has these top-level messages:
PartitionId
Key
Value
Property
Entity
EntityResult
Query
KindExpression
PropertyReference
PropertyExpression
PropertyOrder
Filter
CompositeFilter
PropertyFilter
GqlQuery
GqlQueryArg
QueryResultBatch
Mutation
MutationResult
ReadOptions
LookupRequest
LookupResponse
RunQueryRequest
RunQueryResponse
BeginTransactionRequest
BeginTransactionResponse
RollbackRequest
RollbackResponse
CommitRequest
CommitResponse
AllocateIdsRequest
AllocateIdsResponse
*/
package datastore
import proto "github.com/golang/protobuf/proto"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = math.Inf
// Specifies what data the 'entity' field contains.
// A ResultType is either implied (for example, in LookupResponse.found it
// is always FULL) or specified by context (for example, in message
// QueryResultBatch, field 'entity_result_type' specifies a ResultType
// for all the values in field 'entity_result').
type EntityResult_ResultType int32
const (
EntityResult_FULL EntityResult_ResultType = 1
EntityResult_PROJECTION EntityResult_ResultType = 2
// The entity may have no key.
// A property value may have meaning 18.
EntityResult_KEY_ONLY EntityResult_ResultType = 3
)
var EntityResult_ResultType_name = map[int32]string{
1: "FULL",
2: "PROJECTION",
3: "KEY_ONLY",
}
var EntityResult_ResultType_value = map[string]int32{
"FULL": 1,
"PROJECTION": 2,
"KEY_ONLY": 3,
}
func (x EntityResult_ResultType) Enum() *EntityResult_ResultType {
p := new(EntityResult_ResultType)
*p = x
return p
}
func (x EntityResult_ResultType) String() string {
return proto.EnumName(EntityResult_ResultType_name, int32(x))
}
func (x *EntityResult_ResultType) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(EntityResult_ResultType_value, data, "EntityResult_ResultType")
if err != nil {
return err
}
*x = EntityResult_ResultType(value)
return nil
}
type PropertyExpression_AggregationFunction int32
const (
PropertyExpression_FIRST PropertyExpression_AggregationFunction = 1
)
var PropertyExpression_AggregationFunction_name = map[int32]string{
1: "FIRST",
}
var PropertyExpression_AggregationFunction_value = map[string]int32{
"FIRST": 1,
}
func (x PropertyExpression_AggregationFunction) Enum() *PropertyExpression_AggregationFunction {
p := new(PropertyExpression_AggregationFunction)
*p = x
return p
}
func (x PropertyExpression_AggregationFunction) String() string {
return proto.EnumName(PropertyExpression_AggregationFunction_name, int32(x))
}
func (x *PropertyExpression_AggregationFunction) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(PropertyExpression_AggregationFunction_value, data, "PropertyExpression_AggregationFunction")
if err != nil {
return err
}
*x = PropertyExpression_AggregationFunction(value)
return nil
}
type PropertyOrder_Direction int32
const (
PropertyOrder_ASCENDING PropertyOrder_Direction = 1
PropertyOrder_DESCENDING PropertyOrder_Direction = 2
)
var PropertyOrder_Direction_name = map[int32]string{
1: "ASCENDING",
2: "DESCENDING",
}
var PropertyOrder_Direction_value = map[string]int32{
"ASCENDING": 1,
"DESCENDING": 2,
}
func (x PropertyOrder_Direction) Enum() *PropertyOrder_Direction {
p := new(PropertyOrder_Direction)
*p = x
return p
}
func (x PropertyOrder_Direction) String() string {
return proto.EnumName(PropertyOrder_Direction_name, int32(x))
}
func (x *PropertyOrder_Direction) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(PropertyOrder_Direction_value, data, "PropertyOrder_Direction")
if err != nil {
return err
}
*x = PropertyOrder_Direction(value)
return nil
}
type CompositeFilter_Operator int32
const (
CompositeFilter_AND CompositeFilter_Operator = 1
)
var CompositeFilter_Operator_name = map[int32]string{
1: "AND",
}
var CompositeFilter_Operator_value = map[string]int32{
"AND": 1,
}
func (x CompositeFilter_Operator) Enum() *CompositeFilter_Operator {
p := new(CompositeFilter_Operator)
*p = x
return p
}
func (x CompositeFilter_Operator) String() string {
return proto.EnumName(CompositeFilter_Operator_name, int32(x))
}
func (x *CompositeFilter_Operator) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(CompositeFilter_Operator_value, data, "CompositeFilter_Operator")
if err != nil {
return err
}
*x = CompositeFilter_Operator(value)
return nil
}
type PropertyFilter_Operator int32
const (
PropertyFilter_LESS_THAN PropertyFilter_Operator = 1
PropertyFilter_LESS_THAN_OR_EQUAL PropertyFilter_Operator = 2
PropertyFilter_GREATER_THAN PropertyFilter_Operator = 3
PropertyFilter_GREATER_THAN_OR_EQUAL PropertyFilter_Operator = 4
PropertyFilter_EQUAL PropertyFilter_Operator = 5
PropertyFilter_HAS_ANCESTOR PropertyFilter_Operator = 11
)
var PropertyFilter_Operator_name = map[int32]string{
1: "LESS_THAN",
2: "LESS_THAN_OR_EQUAL",
3: "GREATER_THAN",
4: "GREATER_THAN_OR_EQUAL",
5: "EQUAL",
11: "HAS_ANCESTOR",
}
var PropertyFilter_Operator_value = map[string]int32{
"LESS_THAN": 1,
"LESS_THAN_OR_EQUAL": 2,
"GREATER_THAN": 3,
"GREATER_THAN_OR_EQUAL": 4,
"EQUAL": 5,
"HAS_ANCESTOR": 11,
}
func (x PropertyFilter_Operator) Enum() *PropertyFilter_Operator {
p := new(PropertyFilter_Operator)
*p = x
return p
}
func (x PropertyFilter_Operator) String() string {
return proto.EnumName(PropertyFilter_Operator_name, int32(x))
}
func (x *PropertyFilter_Operator) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(PropertyFilter_Operator_value, data, "PropertyFilter_Operator")
if err != nil {
return err
}
*x = PropertyFilter_Operator(value)
return nil
}
// The possible values for the 'more_results' field.
type QueryResultBatch_MoreResultsType int32
const (
QueryResultBatch_NOT_FINISHED QueryResultBatch_MoreResultsType = 1
QueryResultBatch_MORE_RESULTS_AFTER_LIMIT QueryResultBatch_MoreResultsType = 2
// results after the limit.
QueryResultBatch_NO_MORE_RESULTS QueryResultBatch_MoreResultsType = 3
)
var QueryResultBatch_MoreResultsType_name = map[int32]string{
1: "NOT_FINISHED",
2: "MORE_RESULTS_AFTER_LIMIT",
3: "NO_MORE_RESULTS",
}
var QueryResultBatch_MoreResultsType_value = map[string]int32{
"NOT_FINISHED": 1,
"MORE_RESULTS_AFTER_LIMIT": 2,
"NO_MORE_RESULTS": 3,
}
func (x QueryResultBatch_MoreResultsType) Enum() *QueryResultBatch_MoreResultsType {
p := new(QueryResultBatch_MoreResultsType)
*p = x
return p
}
func (x QueryResultBatch_MoreResultsType) String() string {
return proto.EnumName(QueryResultBatch_MoreResultsType_name, int32(x))
}
func (x *QueryResultBatch_MoreResultsType) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(QueryResultBatch_MoreResultsType_value, data, "QueryResultBatch_MoreResultsType")
if err != nil {
return err
}
*x = QueryResultBatch_MoreResultsType(value)
return nil
}
type ReadOptions_ReadConsistency int32
const (
ReadOptions_DEFAULT ReadOptions_ReadConsistency = 0
ReadOptions_STRONG ReadOptions_ReadConsistency = 1
ReadOptions_EVENTUAL ReadOptions_ReadConsistency = 2
)
var ReadOptions_ReadConsistency_name = map[int32]string{
0: "DEFAULT",
1: "STRONG",
2: "EVENTUAL",
}
var ReadOptions_ReadConsistency_value = map[string]int32{
"DEFAULT": 0,
"STRONG": 1,
"EVENTUAL": 2,
}
func (x ReadOptions_ReadConsistency) Enum() *ReadOptions_ReadConsistency {
p := new(ReadOptions_ReadConsistency)
*p = x
return p
}
func (x ReadOptions_ReadConsistency) String() string {
return proto.EnumName(ReadOptions_ReadConsistency_name, int32(x))
}
func (x *ReadOptions_ReadConsistency) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(ReadOptions_ReadConsistency_value, data, "ReadOptions_ReadConsistency")
if err != nil {
return err
}
*x = ReadOptions_ReadConsistency(value)
return nil
}
type BeginTransactionRequest_IsolationLevel int32
const (
BeginTransactionRequest_SNAPSHOT BeginTransactionRequest_IsolationLevel = 0
// conflict if their mutations conflict. For example:
// Read(A),Write(B) may not conflict with Read(B),Write(A),
// but Read(B),Write(B) does conflict with Read(B),Write(B).
BeginTransactionRequest_SERIALIZABLE BeginTransactionRequest_IsolationLevel = 1
)
var BeginTransactionRequest_IsolationLevel_name = map[int32]string{
0: "SNAPSHOT",
1: "SERIALIZABLE",
}
var BeginTransactionRequest_IsolationLevel_value = map[string]int32{
"SNAPSHOT": 0,
"SERIALIZABLE": 1,
}
func (x BeginTransactionRequest_IsolationLevel) Enum() *BeginTransactionRequest_IsolationLevel {
p := new(BeginTransactionRequest_IsolationLevel)
*p = x
return p
}
func (x BeginTransactionRequest_IsolationLevel) String() string {
return proto.EnumName(BeginTransactionRequest_IsolationLevel_name, int32(x))
}
func (x *BeginTransactionRequest_IsolationLevel) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(BeginTransactionRequest_IsolationLevel_value, data, "BeginTransactionRequest_IsolationLevel")
if err != nil {
return err
}
*x = BeginTransactionRequest_IsolationLevel(value)
return nil
}
type CommitRequest_Mode int32
const (
CommitRequest_TRANSACTIONAL CommitRequest_Mode = 1
CommitRequest_NON_TRANSACTIONAL CommitRequest_Mode = 2
)
var CommitRequest_Mode_name = map[int32]string{
1: "TRANSACTIONAL",
2: "NON_TRANSACTIONAL",
}
var CommitRequest_Mode_value = map[string]int32{
"TRANSACTIONAL": 1,
"NON_TRANSACTIONAL": 2,
}
func (x CommitRequest_Mode) Enum() *CommitRequest_Mode {
p := new(CommitRequest_Mode)
*p = x
return p
}
func (x CommitRequest_Mode) String() string {
return proto.EnumName(CommitRequest_Mode_name, int32(x))
}
func (x *CommitRequest_Mode) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(CommitRequest_Mode_value, data, "CommitRequest_Mode")
if err != nil {
return err
}
*x = CommitRequest_Mode(value)
return nil
}
// An identifier for a particular subset of entities.
//
// Entities are partitioned into various subsets, each used by different
// datasets and different namespaces within a dataset and so forth.
//
// All input partition IDs are normalized before use.
// A partition ID is normalized as follows:
// If the partition ID is unset or is set to an empty partition ID, replace it
// with the context partition ID.
// Otherwise, if the partition ID has no dataset ID, assign it the context
// partition ID's dataset ID.
// Unless otherwise documented, the context partition ID has the dataset ID set
// to the context dataset ID and no other partition dimension set.
//
// A partition ID is empty if all of its fields are unset.
//
// Partition dimension:
// A dimension may be unset.
// A dimension's value must never be "".
// A dimension's value must match [A-Za-z\d\.\-_]{1,100}
// If the value of any dimension matches regex "__.*__",
// the partition is reserved/read-only.
// A reserved/read-only partition ID is forbidden in certain documented contexts.
//
// Dataset ID:
// A dataset id's value must never be "".
// A dataset id's value must match
// ([a-z\d\-]{1,100}~)?([a-z\d][a-z\d\-\.]{0,99}:)?([a-z\d][a-z\d\-]{0,99}
type PartitionId struct {
// The dataset ID.
DatasetId *string `protobuf:"bytes,3,opt,name=dataset_id" json:"dataset_id,omitempty"`
// The namespace.
Namespace *string `protobuf:"bytes,4,opt,name=namespace" json:"namespace,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *PartitionId) Reset() { *m = PartitionId{} }
func (m *PartitionId) String() string { return proto.CompactTextString(m) }
func (*PartitionId) ProtoMessage() {}
func (m *PartitionId) GetDatasetId() string {
if m != nil && m.DatasetId != nil {
return *m.DatasetId
}
return ""
}
func (m *PartitionId) GetNamespace() string {
if m != nil && m.Namespace != nil {
return *m.Namespace
}
return ""
}
// A unique identifier for an entity.
// If a key's partition id or any of its path kinds or names are
// reserved/read-only, the key is reserved/read-only.
// A reserved/read-only key is forbidden in certain documented contexts.
type Key struct {
// Entities are partitioned into subsets, currently identified by a dataset
// (usually implicitly specified by the project) and namespace ID.
// Queries are scoped to a single partition.
PartitionId *PartitionId `protobuf:"bytes,1,opt,name=partition_id" json:"partition_id,omitempty"`
// The entity path.
// An entity path consists of one or more elements composed of a kind and a
// string or numerical identifier, which identify entities. The first
// element identifies a root entity, the second element identifies
// a child of the root entity, the third element a child of the
// second entity, and so forth. The entities identified by all prefixes of
// the path are called the element's ancestors.
// An entity path is always fully complete: ALL of the entity's ancestors
// are required to be in the path along with the entity identifier itself.
// The only exception is that in some documented cases, the identifier in the
// last path element (for the entity) itself may be omitted. A path can never
// be empty.
PathElement []*Key_PathElement `protobuf:"bytes,2,rep,name=path_element" json:"path_element,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Key) Reset() { *m = Key{} }
func (m *Key) String() string { return proto.CompactTextString(m) }
func (*Key) ProtoMessage() {}
func (m *Key) GetPartitionId() *PartitionId {
if m != nil {
return m.PartitionId
}
return nil
}
func (m *Key) GetPathElement() []*Key_PathElement {
if m != nil {
return m.PathElement
}
return nil
}
// A (kind, ID/name) pair used to construct a key path.
//
// At most one of name or ID may be set.
// If either is set, the element is complete.
// If neither is set, the element is incomplete.
type Key_PathElement struct {
// The kind of the entity.
// A kind matching regex "__.*__" is reserved/read-only.
// A kind must not contain more than 500 characters.
// Cannot be "".
Kind *string `protobuf:"bytes,1,req,name=kind" json:"kind,omitempty"`
// The ID of the entity.
// Never equal to zero. Values less than zero are discouraged and will not
// be supported in the future.
Id *int64 `protobuf:"varint,2,opt,name=id" json:"id,omitempty"`
// The name of the entity.
// A name matching regex "__.*__" is reserved/read-only.
// A name must not be more than 500 characters.
// Cannot be "".
Name *string `protobuf:"bytes,3,opt,name=name" json:"name,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Key_PathElement) Reset() { *m = Key_PathElement{} }
func (m *Key_PathElement) String() string { return proto.CompactTextString(m) }
func (*Key_PathElement) ProtoMessage() {}
func (m *Key_PathElement) GetKind() string {
if m != nil && m.Kind != nil {
return *m.Kind
}
return ""
}
func (m *Key_PathElement) GetId() int64 {
if m != nil && m.Id != nil {
return *m.Id
}
return 0
}
func (m *Key_PathElement) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
// A message that can hold any of the supported value types and associated
// metadata.
//
// At most one of the Value fields may be set.
// If none are set the value is "null".
//
type Value struct {
// A boolean value.
BooleanValue *bool `protobuf:"varint,1,opt,name=boolean_value" json:"boolean_value,omitempty"`
// An integer value.
IntegerValue *int64 `protobuf:"varint,2,opt,name=integer_value" json:"integer_value,omitempty"`
// A double value.
DoubleValue *float64 `protobuf:"fixed64,3,opt,name=double_value" json:"double_value,omitempty"`
// A timestamp value.
TimestampMicrosecondsValue *int64 `protobuf:"varint,4,opt,name=timestamp_microseconds_value" json:"timestamp_microseconds_value,omitempty"`
// A key value.
KeyValue *Key `protobuf:"bytes,5,opt,name=key_value" json:"key_value,omitempty"`
// A blob key value.
BlobKeyValue *string `protobuf:"bytes,16,opt,name=blob_key_value" json:"blob_key_value,omitempty"`
// A UTF-8 encoded string value.
StringValue *string `protobuf:"bytes,17,opt,name=string_value" json:"string_value,omitempty"`
// A blob value.
BlobValue []byte `protobuf:"bytes,18,opt,name=blob_value" json:"blob_value,omitempty"`
// An entity value.
// May have no key.
// May have a key with an incomplete key path.
// May have a reserved/read-only key.
EntityValue *Entity `protobuf:"bytes,6,opt,name=entity_value" json:"entity_value,omitempty"`
// A list value.
// Cannot contain another list value.
// Cannot also have a meaning and indexing set.
ListValue []*Value `protobuf:"bytes,7,rep,name=list_value" json:"list_value,omitempty"`
// The meaning field is reserved and should not be used.
Meaning *int32 `protobuf:"varint,14,opt,name=meaning" json:"meaning,omitempty"`
// If the value should be indexed.
//
// The indexed property may be set for a
// null value.
// When indexed is true, stringValue
// is limited to 500 characters and the blob value is limited to 500 bytes.
// Exception: If meaning is set to 2, string_value is limited to 2038
// characters regardless of indexed.
// When indexed is true, meaning 15 and 22 are not allowed, and meaning 16
// will be ignored on input (and will never be set on output).
// Input values by default have indexed set to
// true; however, you can explicitly set indexed to
// true if you want. (An output value never has
// indexed explicitly set to true.) If a value is
// itself an entity, it cannot have indexed set to
// true.
// Exception: An entity value with meaning 9, 20 or 21 may be indexed.
Indexed *bool `protobuf:"varint,15,opt,name=indexed,def=1" json:"indexed,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Value) Reset() { *m = Value{} }
func (m *Value) String() string { return proto.CompactTextString(m) }
func (*Value) ProtoMessage() {}
const Default_Value_Indexed bool = true
func (m *Value) GetBooleanValue() bool {
if m != nil && m.BooleanValue != nil {
return *m.BooleanValue
}
return false
}
func (m *Value) GetIntegerValue() int64 {
if m != nil && m.IntegerValue != nil {
return *m.IntegerValue
}
return 0
}
func (m *Value) GetDoubleValue() float64 {
if m != nil && m.DoubleValue != nil {
return *m.DoubleValue
}
return 0
}
func (m *Value) GetTimestampMicrosecondsValue() int64 {
if m != nil && m.TimestampMicrosecondsValue != nil {
return *m.TimestampMicrosecondsValue
}
return 0
}
func (m *Value) GetKeyValue() *Key {
if m != nil {
return m.KeyValue
}
return nil
}
func (m *Value) GetBlobKeyValue() string {
if m != nil && m.BlobKeyValue != nil {
return *m.BlobKeyValue
}
return ""
}
func (m *Value) GetStringValue() string {
if m != nil && m.StringValue != nil {
return *m.StringValue
}
return ""
}
func (m *Value) GetBlobValue() []byte {
if m != nil {
return m.BlobValue
}
return nil
}
func (m *Value) GetEntityValue() *Entity {
if m != nil {
return m.EntityValue
}
return nil
}
func (m *Value) GetListValue() []*Value {
if m != nil {
return m.ListValue
}
return nil
}
func (m *Value) GetMeaning() int32 {
if m != nil && m.Meaning != nil {
return *m.Meaning
}
return 0
}
func (m *Value) GetIndexed() bool {
if m != nil && m.Indexed != nil {
return *m.Indexed
}
return Default_Value_Indexed
}
// An entity property.
type Property struct {
// The name of the property.
// A property name matching regex "__.*__" is reserved.
// A reserved property name is forbidden in certain documented contexts.
// The name must not contain more than 500 characters.
// Cannot be "".
Name *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
// The value(s) of the property.
// Each value can have only one value property populated. For example,
// you cannot have a values list of { value: { integerValue: 22,
// stringValue: "a" } }, but you can have { value: { listValue:
// [ { integerValue: 22 }, { stringValue: "a" } ] }.
Value *Value `protobuf:"bytes,4,req,name=value" json:"value,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Property) Reset() { *m = Property{} }
func (m *Property) String() string { return proto.CompactTextString(m) }
func (*Property) ProtoMessage() {}
func (m *Property) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *Property) GetValue() *Value {
if m != nil {
return m.Value
}
return nil
}
// An entity.
//
// An entity is limited to 1 megabyte when stored. That roughly
// corresponds to a limit of 1 megabyte for the serialized form of this
// message.
type Entity struct {
// The entity's key.
//
// An entity must have a key, unless otherwise documented (for example,
// an entity in Value.entityValue may have no key).
// An entity's kind is its key's path's last element's kind,
// or null if it has no key.
Key *Key `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"`
// The entity's properties.
// Each property's name must be unique for its entity.
Property []*Property `protobuf:"bytes,2,rep,name=property" json:"property,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Entity) Reset() { *m = Entity{} }
func (m *Entity) String() string { return proto.CompactTextString(m) }
func (*Entity) ProtoMessage() {}
func (m *Entity) GetKey() *Key {
if m != nil {
return m.Key
}
return nil
}
func (m *Entity) GetProperty() []*Property {
if m != nil {
return m.Property
}
return nil
}
// The result of fetching an entity from the datastore.
type EntityResult struct {
// The resulting entity.
Entity *Entity `protobuf:"bytes,1,req,name=entity" json:"entity,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *EntityResult) Reset() { *m = EntityResult{} }
func (m *EntityResult) String() string { return proto.CompactTextString(m) }
func (*EntityResult) ProtoMessage() {}
func (m *EntityResult) GetEntity() *Entity {
if m != nil {
return m.Entity
}
return nil
}
// A query.
type Query struct {
// The projection to return. If not set the entire entity is returned.
Projection []*PropertyExpression `protobuf:"bytes,2,rep,name=projection" json:"projection,omitempty"`
// The kinds to query (if empty, returns entities from all kinds).
Kind []*KindExpression `protobuf:"bytes,3,rep,name=kind" json:"kind,omitempty"`
// The filter to apply (optional).
Filter *Filter `protobuf:"bytes,4,opt,name=filter" json:"filter,omitempty"`
// The order to apply to the query results (if empty, order is unspecified).
Order []*PropertyOrder `protobuf:"bytes,5,rep,name=order" json:"order,omitempty"`
// The properties to group by (if empty, no grouping is applied to the
// result set).
GroupBy []*PropertyReference `protobuf:"bytes,6,rep,name=group_by" json:"group_by,omitempty"`
// A starting point for the query results. Optional. Query cursors are
// returned in query result batches.
StartCursor []byte `protobuf:"bytes,7,opt,name=start_cursor" json:"start_cursor,omitempty"`
// An ending point for the query results. Optional. Query cursors are
// returned in query result batches.
EndCursor []byte `protobuf:"bytes,8,opt,name=end_cursor" json:"end_cursor,omitempty"`
// The number of results to skip. Applies before limit, but after all other
// constraints (optional, defaults to 0).
Offset *int32 `protobuf:"varint,10,opt,name=offset,def=0" json:"offset,omitempty"`
// The maximum number of results to return. Applies after all other
// constraints. Optional.
Limit *int32 `protobuf:"varint,11,opt,name=limit" json:"limit,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Query) Reset() { *m = Query{} }
func (m *Query) String() string { return proto.CompactTextString(m) }
func (*Query) ProtoMessage() {}
const Default_Query_Offset int32 = 0
func (m *Query) GetProjection() []*PropertyExpression {
if m != nil {
return m.Projection
}
return nil
}
func (m *Query) GetKind() []*KindExpression {
if m != nil {
return m.Kind
}
return nil
}
func (m *Query) GetFilter() *Filter {
if m != nil {
return m.Filter
}
return nil
}
func (m *Query) GetOrder() []*PropertyOrder {
if m != nil {
return m.Order
}
return nil
}
func (m *Query) GetGroupBy() []*PropertyReference {
if m != nil {
return m.GroupBy
}
return nil
}
func (m *Query) GetStartCursor() []byte {
if m != nil {
return m.StartCursor
}
return nil
}
func (m *Query) GetEndCursor() []byte {
if m != nil {
return m.EndCursor
}
return nil
}
func (m *Query) GetOffset() int32 {
if m != nil && m.Offset != nil {
return *m.Offset
}
return Default_Query_Offset
}
func (m *Query) GetLimit() int32 {
if m != nil && m.Limit != nil {
return *m.Limit
}
return 0
}
// A representation of a kind.
type KindExpression struct {
// The name of the kind.
Name *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *KindExpression) Reset() { *m = KindExpression{} }
func (m *KindExpression) String() string { return proto.CompactTextString(m) }
func (*KindExpression) ProtoMessage() {}
func (m *KindExpression) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
// A reference to a property relative to the kind expressions.
// exactly.
type PropertyReference struct {
// The name of the property.
Name *string `protobuf:"bytes,2,req,name=name" json:"name,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *PropertyReference) Reset() { *m = PropertyReference{} }
func (m *PropertyReference) String() string { return proto.CompactTextString(m) }
func (*PropertyReference) ProtoMessage() {}
func (m *PropertyReference) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
// A representation of a property in a projection.
type PropertyExpression struct {
// The property to project.
Property *PropertyReference `protobuf:"bytes,1,req,name=property" json:"property,omitempty"`
// The aggregation function to apply to the property. Optional.
// Can only be used when grouping by at least one property. Must
// then be set on all properties in the projection that are not
// being grouped by.
AggregationFunction *PropertyExpression_AggregationFunction `protobuf:"varint,2,opt,name=aggregation_function,enum=datastore.PropertyExpression_AggregationFunction" json:"aggregation_function,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *PropertyExpression) Reset() { *m = PropertyExpression{} }
func (m *PropertyExpression) String() string { return proto.CompactTextString(m) }
func (*PropertyExpression) ProtoMessage() {}
func (m *PropertyExpression) GetProperty() *PropertyReference {
if m != nil {
return m.Property
}
return nil
}
func (m *PropertyExpression) GetAggregationFunction() PropertyExpression_AggregationFunction {
if m != nil && m.AggregationFunction != nil {
return *m.AggregationFunction
}
return PropertyExpression_FIRST
}
// The desired order for a specific property.
type PropertyOrder struct {
// The property to order by.
Property *PropertyReference `protobuf:"bytes,1,req,name=property" json:"property,omitempty"`
// The direction to order by.
Direction *PropertyOrder_Direction `protobuf:"varint,2,opt,name=direction,enum=datastore.PropertyOrder_Direction,def=1" json:"direction,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *PropertyOrder) Reset() { *m = PropertyOrder{} }
func (m *PropertyOrder) String() string { return proto.CompactTextString(m) }
func (*PropertyOrder) ProtoMessage() {}
const Default_PropertyOrder_Direction PropertyOrder_Direction = PropertyOrder_ASCENDING
func (m *PropertyOrder) GetProperty() *PropertyReference {
if m != nil {
return m.Property
}
return nil
}
func (m *PropertyOrder) GetDirection() PropertyOrder_Direction {
if m != nil && m.Direction != nil {
return *m.Direction
}
return Default_PropertyOrder_Direction
}
// A holder for any type of filter. Exactly one field should be specified.
type Filter struct {
// A composite filter.
CompositeFilter *CompositeFilter `protobuf:"bytes,1,opt,name=composite_filter" json:"composite_filter,omitempty"`
// A filter on a property.
PropertyFilter *PropertyFilter `protobuf:"bytes,2,opt,name=property_filter" json:"property_filter,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Filter) Reset() { *m = Filter{} }
func (m *Filter) String() string { return proto.CompactTextString(m) }
func (*Filter) ProtoMessage() {}
func (m *Filter) GetCompositeFilter() *CompositeFilter {
if m != nil {
return m.CompositeFilter
}
return nil
}
func (m *Filter) GetPropertyFilter() *PropertyFilter {
if m != nil {
return m.PropertyFilter
}
return nil
}
// A filter that merges the multiple other filters using the given operation.
type CompositeFilter struct {
// The operator for combining multiple filters.
Operator *CompositeFilter_Operator `protobuf:"varint,1,req,name=operator,enum=datastore.CompositeFilter_Operator" json:"operator,omitempty"`
// The list of filters to combine.
// Must contain at least one filter.
Filter []*Filter `protobuf:"bytes,2,rep,name=filter" json:"filter,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CompositeFilter) Reset() { *m = CompositeFilter{} }
func (m *CompositeFilter) String() string { return proto.CompactTextString(m) }
func (*CompositeFilter) ProtoMessage() {}
func (m *CompositeFilter) GetOperator() CompositeFilter_Operator {
if m != nil && m.Operator != nil {
return *m.Operator
}
return CompositeFilter_AND
}
func (m *CompositeFilter) GetFilter() []*Filter {
if m != nil {
return m.Filter
}
return nil
}
// A filter on a specific property.
type PropertyFilter struct {
// The property to filter by.
Property *PropertyReference `protobuf:"bytes,1,req,name=property" json:"property,omitempty"`
// The operator to filter by.
Operator *PropertyFilter_Operator `protobuf:"varint,2,req,name=operator,enum=datastore.PropertyFilter_Operator" json:"operator,omitempty"`
// The value to compare the property to.
Value *Value `protobuf:"bytes,3,req,name=value" json:"value,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *PropertyFilter) Reset() { *m = PropertyFilter{} }
func (m *PropertyFilter) String() string { return proto.CompactTextString(m) }
func (*PropertyFilter) ProtoMessage() {}
func (m *PropertyFilter) GetProperty() *PropertyReference {
if m != nil {
return m.Property
}
return nil
}
func (m *PropertyFilter) GetOperator() PropertyFilter_Operator {
if m != nil && m.Operator != nil {
return *m.Operator
}
return PropertyFilter_LESS_THAN
}
func (m *PropertyFilter) GetValue() *Value {
if m != nil {
return m.Value
}
return nil
}
// A GQL query.
type GqlQuery struct {
QueryString *string `protobuf:"bytes,1,req,name=query_string" json:"query_string,omitempty"`
// When false, the query string must not contain a literal.
AllowLiteral *bool `protobuf:"varint,2,opt,name=allow_literal,def=0" json:"allow_literal,omitempty"`
// A named argument must set field GqlQueryArg.name.
// No two named arguments may have the same name.
// For each non-reserved named binding site in the query string,
// there must be a named argument with that name,
// but not necessarily the inverse.
NameArg []*GqlQueryArg `protobuf:"bytes,3,rep,name=name_arg" json:"name_arg,omitempty"`
// Numbered binding site @1 references the first numbered argument,
// effectively using 1-based indexing, rather than the usual 0.
// A numbered argument must NOT set field GqlQueryArg.name.
// For each binding site numbered i in query_string,
// there must be an ith numbered argument.
// The inverse must also be true.
NumberArg []*GqlQueryArg `protobuf:"bytes,4,rep,name=number_arg" json:"number_arg,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GqlQuery) Reset() { *m = GqlQuery{} }
func (m *GqlQuery) String() string { return proto.CompactTextString(m) }
func (*GqlQuery) ProtoMessage() {}
const Default_GqlQuery_AllowLiteral bool = false
func (m *GqlQuery) GetQueryString() string {
if m != nil && m.QueryString != nil {
return *m.QueryString
}
return ""
}
func (m *GqlQuery) GetAllowLiteral() bool {
if m != nil && m.AllowLiteral != nil {
return *m.AllowLiteral
}
return Default_GqlQuery_AllowLiteral
}
func (m *GqlQuery) GetNameArg() []*GqlQueryArg {
if m != nil {
return m.NameArg
}
return nil
}
func (m *GqlQuery) GetNumberArg() []*GqlQueryArg {
if m != nil {
return m.NumberArg
}
return nil
}
// A binding argument for a GQL query.
// Exactly one of fields value and cursor must be set.
type GqlQueryArg struct {
// Must match regex "[A-Za-z_$][A-Za-z_$0-9]*".
// Must not match regex "__.*__".
// Must not be "".
Name *string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
Value *Value `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"`
Cursor []byte `protobuf:"bytes,3,opt,name=cursor" json:"cursor,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *GqlQueryArg) Reset() { *m = GqlQueryArg{} }
func (m *GqlQueryArg) String() string { return proto.CompactTextString(m) }
func (*GqlQueryArg) ProtoMessage() {}
func (m *GqlQueryArg) GetName() string {
if m != nil && m.Name != nil {
return *m.Name
}
return ""
}
func (m *GqlQueryArg) GetValue() *Value {
if m != nil {
return m.Value
}
return nil
}
func (m *GqlQueryArg) GetCursor() []byte {
if m != nil {
return m.Cursor
}
return nil
}
// A batch of results produced by a query.
type QueryResultBatch struct {
// The result type for every entity in entityResults.
EntityResultType *EntityResult_ResultType `protobuf:"varint,1,req,name=entity_result_type,enum=datastore.EntityResult_ResultType" json:"entity_result_type,omitempty"`
// The results for this batch.
EntityResult []*EntityResult `protobuf:"bytes,2,rep,name=entity_result" json:"entity_result,omitempty"`
// A cursor that points to the position after the last result in the batch.
// May be absent.
EndCursor []byte `protobuf:"bytes,4,opt,name=end_cursor" json:"end_cursor,omitempty"`
// The state of the query after the current batch.
MoreResults *QueryResultBatch_MoreResultsType `protobuf:"varint,5,req,name=more_results,enum=datastore.QueryResultBatch_MoreResultsType" json:"more_results,omitempty"`
// The number of results skipped because of Query.offset.
SkippedResults *int32 `protobuf:"varint,6,opt,name=skipped_results" json:"skipped_results,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *QueryResultBatch) Reset() { *m = QueryResultBatch{} }
func (m *QueryResultBatch) String() string { return proto.CompactTextString(m) }
func (*QueryResultBatch) ProtoMessage() {}
func (m *QueryResultBatch) GetEntityResultType() EntityResult_ResultType {
if m != nil && m.EntityResultType != nil {
return *m.EntityResultType
}
return EntityResult_FULL
}
func (m *QueryResultBatch) GetEntityResult() []*EntityResult {
if m != nil {
return m.EntityResult
}
return nil
}
func (m *QueryResultBatch) GetEndCursor() []byte {
if m != nil {
return m.EndCursor
}
return nil
}
func (m *QueryResultBatch) GetMoreResults() QueryResultBatch_MoreResultsType {
if m != nil && m.MoreResults != nil {
return *m.MoreResults
}
return QueryResultBatch_NOT_FINISHED
}
func (m *QueryResultBatch) GetSkippedResults() int32 {
if m != nil && m.SkippedResults != nil {
return *m.SkippedResults
}
return 0
}
// A set of changes to apply.
//
// No entity in this message may have a reserved property name,
// not even a property in an entity in a value.
// No value in this message may have meaning 18,
// not even a value in an entity in another value.
//
// If entities with duplicate keys are present, an arbitrary choice will
// be made as to which is written.
type Mutation struct {
// Entities to upsert.
// Each upserted entity's key must have a complete path and
// must not be reserved/read-only.
Upsert []*Entity `protobuf:"bytes,1,rep,name=upsert" json:"upsert,omitempty"`
// Entities to update.
// Each updated entity's key must have a complete path and
// must not be reserved/read-only.
Update []*Entity `protobuf:"bytes,2,rep,name=update" json:"update,omitempty"`
// Entities to insert.
// Each inserted entity's key must have a complete path and
// must not be reserved/read-only.
Insert []*Entity `protobuf:"bytes,3,rep,name=insert" json:"insert,omitempty"`
// Insert entities with a newly allocated ID.
// Each inserted entity's key must omit the final identifier in its path and
// must not be reserved/read-only.
InsertAutoId []*Entity `protobuf:"bytes,4,rep,name=insert_auto_id" json:"insert_auto_id,omitempty"`
// Keys of entities to delete.
// Each key must have a complete key path and must not be reserved/read-only.
Delete []*Key `protobuf:"bytes,5,rep,name=delete" json:"delete,omitempty"`
// Ignore a user specified read-only period. Optional.
Force *bool `protobuf:"varint,6,opt,name=force" json:"force,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Mutation) Reset() { *m = Mutation{} }
func (m *Mutation) String() string { return proto.CompactTextString(m) }
func (*Mutation) ProtoMessage() {}
func (m *Mutation) GetUpsert() []*Entity {
if m != nil {
return m.Upsert
}
return nil
}
func (m *Mutation) GetUpdate() []*Entity {
if m != nil {
return m.Update
}
return nil
}
func (m *Mutation) GetInsert() []*Entity {
if m != nil {
return m.Insert
}
return nil
}
func (m *Mutation) GetInsertAutoId() []*Entity {
if m != nil {
return m.InsertAutoId
}
return nil
}
func (m *Mutation) GetDelete() []*Key {
if m != nil {
return m.Delete
}
return nil
}
func (m *Mutation) GetForce() bool {
if m != nil && m.Force != nil {
return *m.Force
}
return false
}
// The result of applying a mutation.
type MutationResult struct {
// Number of index writes.
IndexUpdates *int32 `protobuf:"varint,1,req,name=index_updates" json:"index_updates,omitempty"`
// Keys for insertAutoId entities. One per entity from the
// request, in the same order.
InsertAutoIdKey []*Key `protobuf:"bytes,2,rep,name=insert_auto_id_key" json:"insert_auto_id_key,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *MutationResult) Reset() { *m = MutationResult{} }
func (m *MutationResult) String() string { return proto.CompactTextString(m) }
func (*MutationResult) ProtoMessage() {}
func (m *MutationResult) GetIndexUpdates() int32 {
if m != nil && m.IndexUpdates != nil {
return *m.IndexUpdates
}
return 0
}
func (m *MutationResult) GetInsertAutoIdKey() []*Key {
if m != nil {
return m.InsertAutoIdKey
}
return nil
}
// Options shared by read requests.
type ReadOptions struct {
// The read consistency to use.
// Cannot be set when transaction is set.
// Lookup and ancestor queries default to STRONG, global queries default to
// EVENTUAL and cannot be set to STRONG.
ReadConsistency *ReadOptions_ReadConsistency `protobuf:"varint,1,opt,name=read_consistency,enum=datastore.ReadOptions_ReadConsistency,def=0" json:"read_consistency,omitempty"`
// The transaction to use. Optional.
Transaction []byte `protobuf:"bytes,2,opt,name=transaction" json:"transaction,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ReadOptions) Reset() { *m = ReadOptions{} }
func (m *ReadOptions) String() string { return proto.CompactTextString(m) }
func (*ReadOptions) ProtoMessage() {}
const Default_ReadOptions_ReadConsistency ReadOptions_ReadConsistency = ReadOptions_DEFAULT
func (m *ReadOptions) GetReadConsistency() ReadOptions_ReadConsistency {
if m != nil && m.ReadConsistency != nil {
return *m.ReadConsistency
}
return Default_ReadOptions_ReadConsistency
}
func (m *ReadOptions) GetTransaction() []byte {
if m != nil {
return m.Transaction
}
return nil
}
// The request for Lookup.
type LookupRequest struct {
// Options for this lookup request. Optional.
ReadOptions *ReadOptions `protobuf:"bytes,1,opt,name=read_options" json:"read_options,omitempty"`
// Keys of entities to look up from the datastore.
Key []*Key `protobuf:"bytes,3,rep,name=key" json:"key,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *LookupRequest) Reset() { *m = LookupRequest{} }
func (m *LookupRequest) String() string { return proto.CompactTextString(m) }
func (*LookupRequest) ProtoMessage() {}
func (m *LookupRequest) GetReadOptions() *ReadOptions {
if m != nil {
return m.ReadOptions
}
return nil
}
func (m *LookupRequest) GetKey() []*Key {
if m != nil {
return m.Key
}
return nil
}
// The response for Lookup.
type LookupResponse struct {
// Entities found as ResultType.FULL entities.
Found []*EntityResult `protobuf:"bytes,1,rep,name=found" json:"found,omitempty"`
// Entities not found as ResultType.KEY_ONLY entities.
Missing []*EntityResult `protobuf:"bytes,2,rep,name=missing" json:"missing,omitempty"`
// A list of keys that were not looked up due to resource constraints.
Deferred []*Key `protobuf:"bytes,3,rep,name=deferred" json:"deferred,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *LookupResponse) Reset() { *m = LookupResponse{} }
func (m *LookupResponse) String() string { return proto.CompactTextString(m) }
func (*LookupResponse) ProtoMessage() {}
func (m *LookupResponse) GetFound() []*EntityResult {
if m != nil {
return m.Found
}
return nil
}
func (m *LookupResponse) GetMissing() []*EntityResult {
if m != nil {
return m.Missing
}
return nil
}
func (m *LookupResponse) GetDeferred() []*Key {
if m != nil {
return m.Deferred
}
return nil
}
// The request for RunQuery.
type RunQueryRequest struct {
// The options for this query.
ReadOptions *ReadOptions `protobuf:"bytes,1,opt,name=read_options" json:"read_options,omitempty"`
// Entities are partitioned into subsets, identified by a dataset (usually
// implicitly specified by the project) and namespace ID. Queries are scoped
// to a single partition.
// This partition ID is normalized with the standard default context
// partition ID, but all other partition IDs in RunQueryRequest are
// normalized with this partition ID as the context partition ID.
PartitionId *PartitionId `protobuf:"bytes,2,opt,name=partition_id" json:"partition_id,omitempty"`
// The query to run.
// Either this field or field gql_query must be set, but not both.
Query *Query `protobuf:"bytes,3,opt,name=query" json:"query,omitempty"`
// The GQL query to run.
// Either this field or field query must be set, but not both.
GqlQuery *GqlQuery `protobuf:"bytes,7,opt,name=gql_query" json:"gql_query,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *RunQueryRequest) Reset() { *m = RunQueryRequest{} }
func (m *RunQueryRequest) String() string { return proto.CompactTextString(m) }
func (*RunQueryRequest) ProtoMessage() {}
func (m *RunQueryRequest) GetReadOptions() *ReadOptions {
if m != nil {
return m.ReadOptions
}
return nil
}
func (m *RunQueryRequest) GetPartitionId() *PartitionId {
if m != nil {
return m.PartitionId
}
return nil
}
func (m *RunQueryRequest) GetQuery() *Query {
if m != nil {
return m.Query
}
return nil
}
func (m *RunQueryRequest) GetGqlQuery() *GqlQuery {
if m != nil {
return m.GqlQuery
}
return nil
}
// The response for RunQuery.
type RunQueryResponse struct {
// A batch of query results (always present).
Batch *QueryResultBatch `protobuf:"bytes,1,opt,name=batch" json:"batch,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *RunQueryResponse) Reset() { *m = RunQueryResponse{} }
func (m *RunQueryResponse) String() string { return proto.CompactTextString(m) }
func (*RunQueryResponse) ProtoMessage() {}
func (m *RunQueryResponse) GetBatch() *QueryResultBatch {
if m != nil {
return m.Batch
}
return nil
}
// The request for BeginTransaction.
type BeginTransactionRequest struct {
// The transaction isolation level.
IsolationLevel *BeginTransactionRequest_IsolationLevel `protobuf:"varint,1,opt,name=isolation_level,enum=datastore.BeginTransactionRequest_IsolationLevel,def=0" json:"isolation_level,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *BeginTransactionRequest) Reset() { *m = BeginTransactionRequest{} }
func (m *BeginTransactionRequest) String() string { return proto.CompactTextString(m) }
func (*BeginTransactionRequest) ProtoMessage() {}
const Default_BeginTransactionRequest_IsolationLevel BeginTransactionRequest_IsolationLevel = BeginTransactionRequest_SNAPSHOT
func (m *BeginTransactionRequest) GetIsolationLevel() BeginTransactionRequest_IsolationLevel {
if m != nil && m.IsolationLevel != nil {
return *m.IsolationLevel
}
return Default_BeginTransactionRequest_IsolationLevel
}
// The response for BeginTransaction.
type BeginTransactionResponse struct {
// The transaction identifier (always present).
Transaction []byte `protobuf:"bytes,1,opt,name=transaction" json:"transaction,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *BeginTransactionResponse) Reset() { *m = BeginTransactionResponse{} }
func (m *BeginTransactionResponse) String() string { return proto.CompactTextString(m) }
func (*BeginTransactionResponse) ProtoMessage() {}
func (m *BeginTransactionResponse) GetTransaction() []byte {
if m != nil {
return m.Transaction
}
return nil
}
// The request for Rollback.
type RollbackRequest struct {
// The transaction identifier, returned by a call to
// beginTransaction.
Transaction []byte `protobuf:"bytes,1,req,name=transaction" json:"transaction,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *RollbackRequest) Reset() { *m = RollbackRequest{} }
func (m *RollbackRequest) String() string { return proto.CompactTextString(m) }
func (*RollbackRequest) ProtoMessage() {}
func (m *RollbackRequest) GetTransaction() []byte {
if m != nil {
return m.Transaction
}
return nil
}
// The response for Rollback.
type RollbackResponse struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *RollbackResponse) Reset() { *m = RollbackResponse{} }
func (m *RollbackResponse) String() string { return proto.CompactTextString(m) }
func (*RollbackResponse) ProtoMessage() {}
// The request for Commit.
type CommitRequest struct {
// The transaction identifier, returned by a call to
// beginTransaction. Must be set when mode is TRANSACTIONAL.
Transaction []byte `protobuf:"bytes,1,opt,name=transaction" json:"transaction,omitempty"`
// The mutation to perform. Optional.
Mutation *Mutation `protobuf:"bytes,2,opt,name=mutation" json:"mutation,omitempty"`
// The type of commit to perform. Either TRANSACTIONAL or NON_TRANSACTIONAL.
Mode *CommitRequest_Mode `protobuf:"varint,5,opt,name=mode,enum=datastore.CommitRequest_Mode,def=1" json:"mode,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CommitRequest) Reset() { *m = CommitRequest{} }
func (m *CommitRequest) String() string { return proto.CompactTextString(m) }
func (*CommitRequest) ProtoMessage() {}
const Default_CommitRequest_Mode CommitRequest_Mode = CommitRequest_TRANSACTIONAL
func (m *CommitRequest) GetTransaction() []byte {
if m != nil {
return m.Transaction
}
return nil
}
func (m *CommitRequest) GetMutation() *Mutation {
if m != nil {
return m.Mutation
}
return nil
}
func (m *CommitRequest) GetMode() CommitRequest_Mode {
if m != nil && m.Mode != nil {
return *m.Mode
}
return Default_CommitRequest_Mode
}
// The response for Commit.
type CommitResponse struct {
// The result of performing the mutation (if any).
MutationResult *MutationResult `protobuf:"bytes,1,opt,name=mutation_result" json:"mutation_result,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *CommitResponse) Reset() { *m = CommitResponse{} }
func (m *CommitResponse) String() string { return proto.CompactTextString(m) }
func (*CommitResponse) ProtoMessage() {}
func (m *CommitResponse) GetMutationResult() *MutationResult {
if m != nil {
return m.MutationResult
}
return nil
}
// The request for AllocateIds.
type AllocateIdsRequest struct {
// A list of keys with incomplete key paths to allocate IDs for.
// No key may be reserved/read-only.
Key []*Key `protobuf:"bytes,1,rep,name=key" json:"key,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *AllocateIdsRequest) Reset() { *m = AllocateIdsRequest{} }
func (m *AllocateIdsRequest) String() string { return proto.CompactTextString(m) }
func (*AllocateIdsRequest) ProtoMessage() {}
func (m *AllocateIdsRequest) GetKey() []*Key {
if m != nil {
return m.Key
}
return nil
}
// The response for AllocateIds.
type AllocateIdsResponse struct {
// The keys specified in the request (in the same order), each with
// its key path completed with a newly allocated ID.
Key []*Key `protobuf:"bytes,1,rep,name=key" json:"key,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *AllocateIdsResponse) Reset() { *m = AllocateIdsResponse{} }
func (m *AllocateIdsResponse) String() string { return proto.CompactTextString(m) }
func (*AllocateIdsResponse) ProtoMessage() {}
func (m *AllocateIdsResponse) GetKey() []*Key {
if m != nil {
return m.Key
}
return nil
}
func init() {
proto.RegisterEnum("datastore.EntityResult_ResultType", EntityResult_ResultType_name, EntityResult_ResultType_value)
proto.RegisterEnum("datastore.PropertyExpression_AggregationFunction", PropertyExpression_AggregationFunction_name, PropertyExpression_AggregationFunction_value)
proto.RegisterEnum("datastore.PropertyOrder_Direction", PropertyOrder_Direction_name, PropertyOrder_Direction_value)
proto.RegisterEnum("datastore.CompositeFilter_Operator", CompositeFilter_Operator_name, CompositeFilter_Operator_value)
proto.RegisterEnum("datastore.PropertyFilter_Operator", PropertyFilter_Operator_name, PropertyFilter_Operator_value)
proto.RegisterEnum("datastore.QueryResultBatch_MoreResultsType", QueryResultBatch_MoreResultsType_name, QueryResultBatch_MoreResultsType_value)
proto.RegisterEnum("datastore.ReadOptions_ReadConsistency", ReadOptions_ReadConsistency_name, ReadOptions_ReadConsistency_value)
proto.RegisterEnum("datastore.BeginTransactionRequest_IsolationLevel", BeginTransactionRequest_IsolationLevel_name, BeginTransactionRequest_IsolationLevel_value)
proto.RegisterEnum("datastore.CommitRequest_Mode", CommitRequest_Mode_name, CommitRequest_Mode_value)
}
================================================
FILE: vendor/google.golang.org/cloud/internal/datastore/datastore_v1.proto
================================================
// Copyright 2013 Google Inc. All Rights Reserved.
//
// The datastore v1 service proto definitions
syntax = "proto2";
package datastore;
option java_package = "com.google.api.services.datastore";
// An identifier for a particular subset of entities.
//
// Entities are partitioned into various subsets, each used by different
// datasets and different namespaces within a dataset and so forth.
//
// All input partition IDs are normalized before use.
// A partition ID is normalized as follows:
// If the partition ID is unset or is set to an empty partition ID, replace it
// with the context partition ID.
// Otherwise, if the partition ID has no dataset ID, assign it the context
// partition ID's dataset ID.
// Unless otherwise documented, the context partition ID has the dataset ID set
// to the context dataset ID and no other partition dimension set.
//
// A partition ID is empty if all of its fields are unset.
//
// Partition dimension:
// A dimension may be unset.
// A dimension's value must never be "".
// A dimension's value must match [A-Za-z\d\.\-_]{1,100}
// If the value of any dimension matches regex "__.*__",
// the partition is reserved/read-only.
// A reserved/read-only partition ID is forbidden in certain documented contexts.
//
// Dataset ID:
// A dataset id's value must never be "".
// A dataset id's value must match
// ([a-z\d\-]{1,100}~)?([a-z\d][a-z\d\-\.]{0,99}:)?([a-z\d][a-z\d\-]{0,99}
message PartitionId {
// The dataset ID.
optional string dataset_id = 3;
// The namespace.
optional string namespace = 4;
}
// A unique identifier for an entity.
// If a key's partition id or any of its path kinds or names are
// reserved/read-only, the key is reserved/read-only.
// A reserved/read-only key is forbidden in certain documented contexts.
message Key {
// Entities are partitioned into subsets, currently identified by a dataset
// (usually implicitly specified by the project) and namespace ID.
// Queries are scoped to a single partition.
optional PartitionId partition_id = 1;
// A (kind, ID/name) pair used to construct a key path.
//
// At most one of name or ID may be set.
// If either is set, the element is complete.
// If neither is set, the element is incomplete.
message PathElement {
// The kind of the entity.
// A kind matching regex "__.*__" is reserved/read-only.
// A kind must not contain more than 500 characters.
// Cannot be "".
required string kind = 1;
// The ID of the entity.
// Never equal to zero. Values less than zero are discouraged and will not
// be supported in the future.
optional int64 id = 2;
// The name of the entity.
// A name matching regex "__.*__" is reserved/read-only.
// A name must not be more than 500 characters.
// Cannot be "".
optional string name = 3;
}
// The entity path.
// An entity path consists of one or more elements composed of a kind and a
// string or numerical identifier, which identify entities. The first
// element identifies a root entity, the second element identifies
// a child of the root entity, the third element a child of the
// second entity, and so forth. The entities identified by all prefixes of
// the path are called the element's ancestors.
// An entity path is always fully complete: ALL of the entity's ancestors
// are required to be in the path along with the entity identifier itself.
// The only exception is that in some documented cases, the identifier in the
// last path element (for the entity) itself may be omitted. A path can never
// be empty.
repeated PathElement path_element = 2;
}
// A message that can hold any of the supported value types and associated
// metadata.
//
// At most one of the Value fields may be set.
// If none are set the value is "null".
//
message Value {
// A boolean value.
optional bool boolean_value = 1;
// An integer value.
optional int64 integer_value = 2;
// A double value.
optional double double_value = 3;
// A timestamp value.
optional int64 timestamp_microseconds_value = 4;
// A key value.
optional Key key_value = 5;
// A blob key value.
optional string blob_key_value = 16;
// A UTF-8 encoded string value.
optional string string_value = 17;
// A blob value.
optional bytes blob_value = 18;
// An entity value.
// May have no key.
// May have a key with an incomplete key path.
// May have a reserved/read-only key.
optional Entity entity_value = 6;
// A list value.
// Cannot contain another list value.
// Cannot also have a meaning and indexing set.
repeated Value list_value = 7;
// The meaning field is reserved and should not be used.
optional int32 meaning = 14;
// If the value should be indexed.
//
// The indexed property may be set for a
// null value.
// When indexed is true, stringValue
// is limited to 500 characters and the blob value is limited to 500 bytes.
// Exception: If meaning is set to 2, string_value is limited to 2038
// characters regardless of indexed.
// When indexed is true, meaning 15 and 22 are not allowed, and meaning 16
// will be ignored on input (and will never be set on output).
// Input values by default have indexed set to
// true; however, you can explicitly set indexed to
// true if you want. (An output value never has
// indexed explicitly set to true.) If a value is
// itself an entity, it cannot have indexed set to
// true.
// Exception: An entity value with meaning 9, 20 or 21 may be indexed.
optional bool indexed = 15 [default = true];
}
// An entity property.
message Property {
// The name of the property.
// A property name matching regex "__.*__" is reserved.
// A reserved property name is forbidden in certain documented contexts.
// The name must not contain more than 500 characters.
// Cannot be "".
required string name = 1;
// The value(s) of the property.
// Each value can have only one value property populated. For example,
// you cannot have a values list of { value: { integerValue: 22,
// stringValue: "a" } }, but you can have { value: { listValue:
// [ { integerValue: 22 }, { stringValue: "a" } ] }.
required Value value = 4;
}
// An entity.
//
// An entity is limited to 1 megabyte when stored. That roughly
// corresponds to a limit of 1 megabyte for the serialized form of this
// message.
message Entity {
// The entity's key.
//
// An entity must have a key, unless otherwise documented (for example,
// an entity in Value.entityValue may have no key).
// An entity's kind is its key's path's last element's kind,
// or null if it has no key.
optional Key key = 1;
// The entity's properties.
// Each property's name must be unique for its entity.
repeated Property property = 2;
}
// The result of fetching an entity from the datastore.
message EntityResult {
// Specifies what data the 'entity' field contains.
// A ResultType is either implied (for example, in LookupResponse.found it
// is always FULL) or specified by context (for example, in message
// QueryResultBatch, field 'entity_result_type' specifies a ResultType
// for all the values in field 'entity_result').
enum ResultType {
FULL = 1; // The entire entity.
PROJECTION = 2; // A projected subset of properties.
// The entity may have no key.
// A property value may have meaning 18.
KEY_ONLY = 3; // Only the key.
}
// The resulting entity.
required Entity entity = 1;
}
// A query.
message Query {
// The projection to return. If not set the entire entity is returned.
repeated PropertyExpression projection = 2;
// The kinds to query (if empty, returns entities from all kinds).
repeated KindExpression kind = 3;
// The filter to apply (optional).
optional Filter filter = 4;
// The order to apply to the query results (if empty, order is unspecified).
repeated PropertyOrder order = 5;
// The properties to group by (if empty, no grouping is applied to the
// result set).
repeated PropertyReference group_by = 6;
// A starting point for the query results. Optional. Query cursors are
// returned in query result batches.
optional bytes /* serialized QueryCursor */ start_cursor = 7;
// An ending point for the query results. Optional. Query cursors are
// returned in query result batches.
optional bytes /* serialized QueryCursor */ end_cursor = 8;
// The number of results to skip. Applies before limit, but after all other
// constraints (optional, defaults to 0).
optional int32 offset = 10 [default=0];
// The maximum number of results to return. Applies after all other
// constraints. Optional.
optional int32 limit = 11;
}
// A representation of a kind.
message KindExpression {
// The name of the kind.
required string name = 1;
}
// A reference to a property relative to the kind expressions.
// exactly.
message PropertyReference {
// The name of the property.
required string name = 2;
}
// A representation of a property in a projection.
message PropertyExpression {
enum AggregationFunction {
FIRST = 1;
}
// The property to project.
required PropertyReference property = 1;
// The aggregation function to apply to the property. Optional.
// Can only be used when grouping by at least one property. Must
// then be set on all properties in the projection that are not
// being grouped by.
optional AggregationFunction aggregation_function = 2;
}
// The desired order for a specific property.
message PropertyOrder {
enum Direction {
ASCENDING = 1;
DESCENDING = 2;
}
// The property to order by.
required PropertyReference property = 1;
// The direction to order by.
optional Direction direction = 2 [default=ASCENDING];
}
// A holder for any type of filter. Exactly one field should be specified.
message Filter {
// A composite filter.
optional CompositeFilter composite_filter = 1;
// A filter on a property.
optional PropertyFilter property_filter = 2;
}
// A filter that merges the multiple other filters using the given operation.
message CompositeFilter {
enum Operator {
AND = 1;
}
// The operator for combining multiple filters.
required Operator operator = 1;
// The list of filters to combine.
// Must contain at least one filter.
repeated Filter filter = 2;
}
// A filter on a specific property.
message PropertyFilter {
enum Operator {
LESS_THAN = 1;
LESS_THAN_OR_EQUAL = 2;
GREATER_THAN = 3;
GREATER_THAN_OR_EQUAL = 4;
EQUAL = 5;
HAS_ANCESTOR = 11;
}
// The property to filter by.
required PropertyReference property = 1;
// The operator to filter by.
required Operator operator = 2;
// The value to compare the property to.
required Value value = 3;
}
// A GQL query.
message GqlQuery {
required string query_string = 1;
// When false, the query string must not contain a literal.
optional bool allow_literal = 2 [default = false];
// A named argument must set field GqlQueryArg.name.
// No two named arguments may have the same name.
// For each non-reserved named binding site in the query string,
// there must be a named argument with that name,
// but not necessarily the inverse.
repeated GqlQueryArg name_arg = 3;
// Numbered binding site @1 references the first numbered argument,
// effectively using 1-based indexing, rather than the usual 0.
// A numbered argument must NOT set field GqlQueryArg.name.
// For each binding site numbered i in query_string,
// there must be an ith numbered argument.
// The inverse must also be true.
repeated GqlQueryArg number_arg = 4;
}
// A binding argument for a GQL query.
// Exactly one of fields value and cursor must be set.
message GqlQueryArg {
// Must match regex "[A-Za-z_$][A-Za-z_$0-9]*".
// Must not match regex "__.*__".
// Must not be "".
optional string name = 1;
optional Value value = 2;
optional bytes cursor = 3;
}
// A batch of results produced by a query.
message QueryResultBatch {
// The possible values for the 'more_results' field.
enum MoreResultsType {
NOT_FINISHED = 1; // There are additional batches to fetch from this query.
MORE_RESULTS_AFTER_LIMIT = 2; // The query is finished, but there are more
// results after the limit.
NO_MORE_RESULTS = 3; // The query has been exhausted.
}
// The result type for every entity in entityResults.
required EntityResult.ResultType entity_result_type = 1;
// The results for this batch.
repeated EntityResult entity_result = 2;
// A cursor that points to the position after the last result in the batch.
// May be absent.
optional bytes /* serialized QueryCursor */ end_cursor = 4;
// The state of the query after the current batch.
required MoreResultsType more_results = 5;
// The number of results skipped because of Query.offset.
optional int32 skipped_results = 6;
}
// A set of changes to apply.
//
// No entity in this message may have a reserved property name,
// not even a property in an entity in a value.
// No value in this message may have meaning 18,
// not even a value in an entity in another value.
//
// If entities with duplicate keys are present, an arbitrary choice will
// be made as to which is written.
message Mutation {
// Entities to upsert.
// Each upserted entity's key must have a complete path and
// must not be reserved/read-only.
repeated Entity upsert = 1;
// Entities to update.
// Each updated entity's key must have a complete path and
// must not be reserved/read-only.
repeated Entity update = 2;
// Entities to insert.
// Each inserted entity's key must have a complete path and
// must not be reserved/read-only.
repeated Entity insert = 3;
// Insert entities with a newly allocated ID.
// Each inserted entity's key must omit the final identifier in its path and
// must not be reserved/read-only.
repeated Entity insert_auto_id = 4;
// Keys of entities to delete.
// Each key must have a complete key path and must not be reserved/read-only.
repeated Key delete = 5;
// Ignore a user specified read-only period. Optional.
optional bool force = 6;
}
// The result of applying a mutation.
message MutationResult {
// Number of index writes.
required int32 index_updates = 1;
// Keys for insertAutoId entities. One per entity from the
// request, in the same order.
repeated Key insert_auto_id_key = 2;
}
// Options shared by read requests.
message ReadOptions {
enum ReadConsistency {
DEFAULT = 0;
STRONG = 1;
EVENTUAL = 2;
}
// The read consistency to use.
// Cannot be set when transaction is set.
// Lookup and ancestor queries default to STRONG, global queries default to
// EVENTUAL and cannot be set to STRONG.
optional ReadConsistency read_consistency = 1 [default=DEFAULT];
// The transaction to use. Optional.
optional bytes /* serialized Transaction */ transaction = 2;
}
// The request for Lookup.
message LookupRequest {
// Options for this lookup request. Optional.
optional ReadOptions read_options = 1;
// Keys of entities to look up from the datastore.
repeated Key key = 3;
}
// The response for Lookup.
message LookupResponse {
// The order of results in these fields is undefined and has no relation to
// the order of the keys in the input.
// Entities found as ResultType.FULL entities.
repeated EntityResult found = 1;
// Entities not found as ResultType.KEY_ONLY entities.
repeated EntityResult missing = 2;
// A list of keys that were not looked up due to resource constraints.
repeated Key deferred = 3;
}
// The request for RunQuery.
message RunQueryRequest {
// The options for this query.
optional ReadOptions read_options = 1;
// Entities are partitioned into subsets, identified by a dataset (usually
// implicitly specified by the project) and namespace ID. Queries are scoped
// to a single partition.
// This partition ID is normalized with the standard default context
// partition ID, but all other partition IDs in RunQueryRequest are
// normalized with this partition ID as the context partition ID.
optional PartitionId partition_id = 2;
// The query to run.
// Either this field or field gql_query must be set, but not both.
optional Query query = 3;
// The GQL query to run.
// Either this field or field query must be set, but not both.
optional GqlQuery gql_query = 7;
}
// The response for RunQuery.
message RunQueryResponse {
// A batch of query results (always present).
optional QueryResultBatch batch = 1;
}
// The request for BeginTransaction.
message BeginTransactionRequest {
enum IsolationLevel {
SNAPSHOT = 0; // Read from a consistent snapshot. Concurrent transactions
// conflict if their mutations conflict. For example:
// Read(A),Write(B) may not conflict with Read(B),Write(A),
// but Read(B),Write(B) does conflict with Read(B),Write(B).
SERIALIZABLE = 1; // Read from a consistent snapshot. Concurrent
// transactions conflict if they cannot be serialized.
// For example Read(A),Write(B) does conflict with
// Read(B),Write(A) but Read(A) may not conflict with
// Write(A).
}
// The transaction isolation level.
optional IsolationLevel isolation_level = 1 [default=SNAPSHOT];
}
// The response for BeginTransaction.
message BeginTransactionResponse {
// The transaction identifier (always present).
optional bytes /* serialized Transaction */ transaction = 1;
}
// The request for Rollback.
message RollbackRequest {
// The transaction identifier, returned by a call to
// beginTransaction.
required bytes /* serialized Transaction */ transaction = 1;
}
// The response for Rollback.
message RollbackResponse {
// Empty
}
// The request for Commit.
message CommitRequest {
enum Mode {
TRANSACTIONAL = 1;
NON_TRANSACTIONAL = 2;
}
// The transaction identifier, returned by a call to
// beginTransaction. Must be set when mode is TRANSACTIONAL.
optional bytes /* serialized Transaction */ transaction = 1;
// The mutation to perform. Optional.
optional Mutation mutation = 2;
// The type of commit to perform. Either TRANSACTIONAL or NON_TRANSACTIONAL.
optional Mode mode = 5 [default=TRANSACTIONAL];
}
// The response for Commit.
message CommitResponse {
// The result of performing the mutation (if any).
optional MutationResult mutation_result = 1;
}
// The request for AllocateIds.
message AllocateIdsRequest {
// A list of keys with incomplete key paths to allocate IDs for.
// No key may be reserved/read-only.
repeated Key key = 1;
}
// The response for AllocateIds.
message AllocateIdsResponse {
// The keys specified in the request (in the same order), each with
// its key path completed with a newly allocated ID.
repeated Key key = 1;
}
// Each rpc normalizes the partition IDs of the keys in its input entities,
// and always returns entities with keys with normalized partition IDs.
// (Note that applies to all entities, including entities in values.)
service DatastoreService {
// Look up some entities by key.
rpc Lookup(LookupRequest) returns (LookupResponse) {
};
// Query for entities.
rpc RunQuery(RunQueryRequest) returns (RunQueryResponse) {
};
// Begin a new transaction.
rpc BeginTransaction(BeginTransactionRequest) returns (BeginTransactionResponse) {
};
// Commit a transaction, optionally creating, deleting or modifying some
// entities.
rpc Commit(CommitRequest) returns (CommitResponse) {
};
// Roll back a transaction.
rpc Rollback(RollbackRequest) returns (RollbackResponse) {
};
// Allocate IDs for incomplete keys (useful for referencing an entity before
// it is inserted).
rpc AllocateIds(AllocateIdsRequest) returns (AllocateIdsResponse) {
};
}
================================================
FILE: vendor/google.golang.org/cloud/internal/testutil/context.go
================================================
// Copyright 2014 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Package testutil contains helper functions for writing tests.
package testutil
import (
"io/ioutil"
"log"
"net/http"
"os"
"golang.org/x/net/context"
"golang.org/x/oauth2"
"golang.org/x/oauth2/google"
"google.golang.org/cloud"
)
const (
envProjID = "GCLOUD_TESTS_GOLANG_PROJECT_ID"
envPrivateKey = "GCLOUD_TESTS_GOLANG_KEY"
)
func Context(scopes ...string) context.Context {
key, projID := os.Getenv(envPrivateKey), os.Getenv(envProjID)
if key == "" || projID == "" {
log.Fatal("GCLOUD_TESTS_GOLANG_KEY and GCLOUD_TESTS_GOLANG_PROJECT_ID must be set. See CONTRIBUTING.md for details.")
}
jsonKey, err := ioutil.ReadFile(key)
if err != nil {
log.Fatalf("Cannot read the JSON key file, err: %v", err)
}
conf, err := google.JWTConfigFromJSON(jsonKey, scopes...)
if err != nil {
log.Fatal(err)
}
return cloud.NewContext(projID, conf.Client(oauth2.NoContext))
}
func NoAuthContext() context.Context {
projID := os.Getenv(envProjID)
if projID == "" {
log.Fatal("GCLOUD_TESTS_GOLANG_PROJECT_ID must be set. See CONTRIBUTING.md for details.")
}
return cloud.NewContext(projID, &http.Client{Transport: http.DefaultTransport})
}
================================================
FILE: vendor/google.golang.org/cloud/option.go
================================================
/*
Copyright 2015 Google Inc. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package cloud
import (
"errors"
"fmt"
"net/http"
"golang.org/x/net/context"
"golang.org/x/oauth2"
"golang.org/x/oauth2/google"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials"
)
type dialOpt struct {
endpoint string
scopes []string
tokenSource oauth2.TokenSource
httpClient *http.Client
grpcClient *grpc.ClientConn
}
// ClientOption is used when construct clients for each cloud service.
type ClientOption interface {
resolve(*dialOpt)
}
// WithTokenSource returns a ClientOption that specifies an OAuth2 token
// source to be used as the basis for authentication.
func WithTokenSource(s oauth2.TokenSource) ClientOption {
return withTokenSource{s}
}
type withTokenSource struct{ ts oauth2.TokenSource }
func (w withTokenSource) resolve(o *dialOpt) {
o.tokenSource = w.ts
}
// WithEndpoint returns a ClientOption that overrides the default endpoint
// to be used for a service.
func WithEndpoint(url string) ClientOption {
return withEndpoint(url)
}
type withEndpoint string
func (w withEndpoint) resolve(o *dialOpt) {
o.endpoint = string(w)
}
// WithScopes returns a ClientOption that overrides the default OAuth2 scopes
// to be used for a service.
func WithScopes(scope ...string) ClientOption {
return withScopes(scope)
}
type withScopes []string
func (w withScopes) resolve(o *dialOpt) {
o.scopes = []string(w)
}
// WithBaseHTTP returns a ClientOption that specifies the HTTP client to
// use as the basis of communications. This option may only be used with
// services that support HTTP as their communication transport.
func WithBaseHTTP(client *http.Client) ClientOption {
return withBaseHTTP{client}
}
type withBaseHTTP struct{ client *http.Client }
func (w withBaseHTTP) resolve(o *dialOpt) {
o.httpClient = w.client
}
// WithBaseGRPC returns a ClientOption that specifies the GRPC client
// connection to use as the basis of communications. This option many only be
// used with services that support HRPC as their communication transport.
func WithBaseGRPC(client *grpc.ClientConn) ClientOption {
return withBaseGRPC{client}
}
type withBaseGRPC struct{ client *grpc.ClientConn }
func (w withBaseGRPC) resolve(o *dialOpt) {
o.grpcClient = w.client
}
// DialHTTP returns an HTTP client for use communicating with a Google cloud
// service, configured with the given ClientOptions. Most developers should
// call the relevant NewClient method for the target service rather than
// invoking DialHTTP directly.
func DialHTTP(ctx context.Context, opt ...ClientOption) (*http.Client, error) {
var o dialOpt
for _, opt := range opt {
opt.resolve(&o)
}
if o.grpcClient != nil {
return nil, errors.New("unsupported GRPC base transport specified")
}
// TODO(djd): Wrap all http.Client's with appropriate internal version to add
// UserAgent header and prepend correct endpoint.
if o.httpClient != nil {
return o.httpClient, nil
}
if o.tokenSource == nil {
var err error
o.tokenSource, err = google.DefaultTokenSource(ctx, o.scopes...)
if err != nil {
return nil, fmt.Errorf("google.DefaultTokenSource: %v", err)
}
}
return oauth2.NewClient(ctx, o.tokenSource), nil
}
// DialGRPC returns a GRPC connection for use communicating with a Google cloud
// service, configured with the given ClientOptions. Most developers should
// call the relevant NewClient method for the target service rather than
// invoking DialGRPC directly.
func DialGRPC(ctx context.Context, opt ...ClientOption) (*grpc.ClientConn, error) {
var o dialOpt
for _, opt := range opt {
opt.resolve(&o)
}
if o.httpClient != nil {
return nil, errors.New("unsupported HTTP base transport specified")
}
if o.grpcClient != nil {
return o.grpcClient, nil
}
if o.tokenSource == nil {
var err error
o.tokenSource, err = google.DefaultTokenSource(ctx, o.scopes...)
if err != nil {
return nil, fmt.Errorf("google.DefaultTokenSource: %v", err)
}
}
grpcOpts := []grpc.DialOption{
grpc.WithPerRPCCredentials(credentials.TokenSource{o.tokenSource}),
grpc.WithTransportCredentials(credentials.NewClientTLSFromCert(nil, "")),
}
return grpc.Dial(o.endpoint, grpcOpts...)
}
================================================
FILE: vendor/google.golang.org/cloud/pubsub/pubsub.go
================================================
// Copyright 2014 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Package pubsub contains a Google Cloud Pub/Sub client.
//
// This package is experimental and may make backwards-incompatible changes.
//
// More information about Google Cloud Pub/Sub is available at
// https://cloud.google.com/pubsub/docs
package pubsub
import (
"encoding/base64"
"errors"
"fmt"
"net/http"
"time"
"google.golang.org/cloud/internal"
"golang.org/x/net/context"
"google.golang.org/api/googleapi"
raw "google.golang.org/api/pubsub/v1beta2"
)
const (
// ScopePubSub grants permissions to view and manage Pub/Sub
// topics and subscriptions.
ScopePubSub = "https://www.googleapis.com/auth/pubsub"
// ScopeCloudPlatform grants permissions to view and manage your data
// across Google Cloud Platform services.
ScopeCloudPlatform = "https://www.googleapis.com/auth/cloud-platform"
)
// batchLimit is maximun size of a single batch.
const batchLimit = 1000
// Message represents a Pub/Sub message.
type Message struct {
// ID identifies this message.
ID string
// AckID is the identifier to acknowledge this message.
AckID string
// Data is the actual data in the message.
Data []byte
// Attributes represents the key-value pairs the current message
// is labelled with.
Attributes map[string]string
}
// TODO(jbd): Add subscription and topic listing.
// CreateSub creates a Pub/Sub subscription on the backend.
// A subscription should subscribe to an existing topic.
//
// The messages that haven't acknowledged will be pushed back to the
// subscription again when the default acknowledgement deadline is
// reached. You can override the default deadline by providing a
// non-zero deadline. Deadline must not be specified to
// precision greater than one second.
//
// As new messages are being queued on the subscription, you
// may recieve push notifications regarding to the new arrivals.
// To receive notifications of new messages in the queue,
// specify an endpoint callback URL.
// If endpoint is an empty string the backend will not notify the
// client of new messages.
//
// If the subscription already exists an error will be returned.
func CreateSub(ctx context.Context, name string, topic string, deadline time.Duration, endpoint string) error {
sub := &raw.Subscription{
Topic: fullTopicName(internal.ProjID(ctx), topic),
}
if int64(deadline) > 0 {
if !isSec(deadline) {
return errors.New("pubsub: deadline must not be specified to precision greater than one second")
}
sub.AckDeadlineSeconds = int64(deadline / time.Second)
}
if endpoint != "" {
sub.PushConfig = &raw.PushConfig{PushEndpoint: endpoint}
}
_, err := rawService(ctx).Projects.Subscriptions.Create(fullSubName(internal.ProjID(ctx), name), sub).Do()
return err
}
// DeleteSub deletes the subscription.
func DeleteSub(ctx context.Context, name string) error {
_, err := rawService(ctx).Projects.Subscriptions.Delete(fullSubName(internal.ProjID(ctx), name)).Do()
return err
}
// ModifyAckDeadline modifies the acknowledgement deadline
// for the messages retrieved from the specified subscription.
// Deadline must not be specified to precision greater than one second.
func ModifyAckDeadline(ctx context.Context, sub string, id string, deadline time.Duration) error {
if !isSec(deadline) {
return errors.New("pubsub: deadline must not be specified to precision greater than one second")
}
_, err := rawService(ctx).Projects.Subscriptions.ModifyAckDeadline(fullSubName(internal.ProjID(ctx), sub), &raw.ModifyAckDeadlineRequest{
AckDeadlineSeconds: int64(deadline / time.Second),
AckId: id,
}).Do()
return err
}
// ModifyPushEndpoint modifies the URL endpoint to modify the resource
// to handle push notifications coming from the Pub/Sub backend
// for the specified subscription.
func ModifyPushEndpoint(ctx context.Context, sub, endpoint string) error {
_, err := rawService(ctx).Projects.Subscriptions.ModifyPushConfig(fullSubName(internal.ProjID(ctx), sub), &raw.ModifyPushConfigRequest{
PushConfig: &raw.PushConfig{
PushEndpoint: endpoint,
},
}).Do()
return err
}
// SubExists returns true if subscription exists.
func SubExists(ctx context.Context, name string) (bool, error) {
_, err := rawService(ctx).Projects.Subscriptions.Get(fullSubName(internal.ProjID(ctx), name)).Do()
if e, ok := err.(*googleapi.Error); ok && e.Code == http.StatusNotFound {
return false, nil
}
if err != nil {
return false, err
}
return true, nil
}
// Ack acknowledges one or more Pub/Sub messages on the
// specified subscription.
func Ack(ctx context.Context, sub string, id ...string) error {
for idx, ackID := range id {
if ackID == "" {
return fmt.Errorf("pubsub: empty ackID detected at index %d", idx)
}
}
_, err := rawService(ctx).Projects.Subscriptions.Acknowledge(fullSubName(internal.ProjID(ctx), sub), &raw.AcknowledgeRequest{
AckIds: id,
}).Do()
return err
}
func toMessage(resp *raw.ReceivedMessage) (*Message, error) {
if resp.Message == nil {
return &Message{AckID: resp.AckId}, nil
}
data, err := base64.StdEncoding.DecodeString(resp.Message.Data)
if err != nil {
return nil, err
}
return &Message{
AckID: resp.AckId,
Data: data,
Attributes: resp.Message.Attributes,
ID: resp.Message.MessageId,
}, nil
}
// Pull pulls messages from the subscription. It returns up to n
// number of messages, and n could not be larger than 100.
func Pull(ctx context.Context, sub string, n int) ([]*Message, error) {
return pull(ctx, sub, n, true)
}
// PullWait pulls messages from the subscription. If there are not
// enough messages left in the subscription queue, it will block until
// at least n number of messages arrive or timeout occurs, and n could
// not be larger than 100.
func PullWait(ctx context.Context, sub string, n int) ([]*Message, error) {
return pull(ctx, sub, n, false)
}
func pull(ctx context.Context, sub string, n int, retImmediately bool) ([]*Message, error) {
if n < 1 || n > batchLimit {
return nil, fmt.Errorf("pubsub: cannot pull less than one, more than %d messages, but %d was given", batchLimit, n)
}
resp, err := rawService(ctx).Projects.Subscriptions.Pull(fullSubName(internal.ProjID(ctx), sub), &raw.PullRequest{
ReturnImmediately: retImmediately,
MaxMessages: int64(n),
}).Do()
if err != nil {
return nil, err
}
msgs := make([]*Message, len(resp.ReceivedMessages))
for i := 0; i < len(resp.ReceivedMessages); i++ {
msg, err := toMessage(resp.ReceivedMessages[i])
if err != nil {
return nil, fmt.Errorf("pubsub: cannot decode the retrieved message at index: %d, PullResponse: %+v", i, resp.ReceivedMessages[i])
}
msgs[i] = msg
}
return msgs, nil
}
// CreateTopic creates a new topic with the specified name on the backend.
// It will return an error if topic already exists.
func CreateTopic(ctx context.Context, name string) error {
_, err := rawService(ctx).Projects.Topics.Create(fullTopicName(internal.ProjID(ctx), name), &raw.Topic{}).Do()
return err
}
// DeleteTopic deletes the specified topic.
func DeleteTopic(ctx context.Context, name string) error {
_, err := rawService(ctx).Projects.Topics.Delete(fullTopicName(internal.ProjID(ctx), name)).Do()
return err
}
// TopicExists returns true if a topic exists with the specified name.
func TopicExists(ctx context.Context, name string) (bool, error) {
_, err := rawService(ctx).Projects.Topics.Get(fullTopicName(internal.ProjID(ctx), name)).Do()
if e, ok := err.(*googleapi.Error); ok && e.Code == http.StatusNotFound {
return false, nil
}
if err != nil {
return false, err
}
return true, nil
}
// Publish publish messages to the topic's subscribers. It returns
// message IDs upon success.
func Publish(ctx context.Context, topic string, msgs ...*Message) ([]string, error) {
var rawMsgs []*raw.PubsubMessage
if len(msgs) == 0 {
return nil, errors.New("pubsub: no messages to publish")
}
if len(msgs) > batchLimit {
return nil, fmt.Errorf("pubsub: %d messages given, but maximum batch size is %d", len(msgs), batchLimit)
}
rawMsgs = make([]*raw.PubsubMessage, len(msgs))
for i, msg := range msgs {
rawMsgs[i] = &raw.PubsubMessage{
Data: base64.StdEncoding.EncodeToString(msg.Data),
Attributes: msg.Attributes,
}
}
resp, err := rawService(ctx).Projects.Topics.Publish(fullTopicName(internal.ProjID(ctx), topic), &raw.PublishRequest{
Messages: rawMsgs,
}).Do()
if err != nil {
return nil, err
}
return resp.MessageIds, nil
}
// fullSubName returns the fully qualified name for a subscription.
// E.g. /subscriptions/project-id/subscription-name.
func fullSubName(proj, name string) string {
return fmt.Sprintf("projects/%s/subscriptions/%s", proj, name)
}
// fullTopicName returns the fully qualified name for a topic.
// E.g. /topics/project-id/topic-name.
func fullTopicName(proj, name string) string {
return fmt.Sprintf("projects/%s/topics/%s", proj, name)
}
func isSec(dur time.Duration) bool {
return dur%time.Second == 0
}
func rawService(ctx context.Context) *raw.Service {
return internal.Service(ctx, "pubsub", func(hc *http.Client) interface{} {
svc, _ := raw.New(hc)
return svc
}).(*raw.Service)
}
================================================
FILE: vendor/google.golang.org/cloud/storage/acl.go
================================================
// Copyright 2014 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package storage
import (
"fmt"
"golang.org/x/net/context"
raw "google.golang.org/api/storage/v1"
)
// ACLRole is the the access permission for the entity.
type ACLRole string
const (
RoleOwner ACLRole = "OWNER"
RoleReader ACLRole = "READER"
)
// ACLEntity is an entity holding an ACL permission.
//
// It could be in the form of:
// "user-", "user-","group-", "group-",
// "domain-" and "project-team-".
//
// Or one of the predefined constants: AllUsers, AllAuthenticatedUsers.
type ACLEntity string
const (
AllUsers ACLEntity = "allUsers"
AllAuthenticatedUsers ACLEntity = "allAuthenticatedUsers"
)
// ACLRule represents an access control list rule entry for a Google Cloud Storage object or bucket.
// A bucket is a Google Cloud Storage container whose name is globally unique and contains zero or
// more objects. An object is a blob of data that is stored in a bucket.
type ACLRule struct {
// Entity identifies the entity holding the current rule's permissions.
Entity ACLEntity
// Role is the the access permission for the entity.
Role ACLRole
}
// DefaultACL returns the default object ACL entries for the named bucket.
func DefaultACL(ctx context.Context, bucket string) ([]ACLRule, error) {
acls, err := rawService(ctx).DefaultObjectAccessControls.List(bucket).Do()
if err != nil {
return nil, fmt.Errorf("storage: error listing default object ACL for bucket %q: %v", bucket, err)
}
r := make([]ACLRule, 0, len(acls.Items))
for _, v := range acls.Items {
if m, ok := v.(map[string]interface{}); ok {
entity, ok1 := m["entity"].(string)
role, ok2 := m["role"].(string)
if ok1 && ok2 {
r = append(r, ACLRule{Entity: ACLEntity(entity), Role: ACLRole(role)})
}
}
}
return r, nil
}
// PutDefaultACLRule saves the named default object ACL entity with the provided role for the named bucket.
func PutDefaultACLRule(ctx context.Context, bucket string, entity ACLEntity, role ACLRole) error {
acl := &raw.ObjectAccessControl{
Bucket: bucket,
Entity: string(entity),
Role: string(role),
}
_, err := rawService(ctx).DefaultObjectAccessControls.Update(bucket, string(entity), acl).Do()
if err != nil {
return fmt.Errorf("storage: error updating default ACL rule for bucket %q, entity %q: %v", bucket, entity, err)
}
return nil
}
// DeleteDefaultACLRule deletes the named default ACL entity for the named bucket.
func DeleteDefaultACLRule(ctx context.Context, bucket string, entity ACLEntity) error {
err := rawService(ctx).DefaultObjectAccessControls.Delete(bucket, string(entity)).Do()
if err != nil {
return fmt.Errorf("storage: error deleting default ACL rule for bucket %q, entity %q: %v", bucket, entity, err)
}
return nil
}
// BucketACL returns the ACL entries for the named bucket.
func BucketACL(ctx context.Context, bucket string) ([]ACLRule, error) {
acls, err := rawService(ctx).BucketAccessControls.List(bucket).Do()
if err != nil {
return nil, fmt.Errorf("storage: error listing bucket ACL for bucket %q: %v", bucket, err)
}
r := make([]ACLRule, len(acls.Items))
for i, v := range acls.Items {
r[i].Entity = ACLEntity(v.Entity)
r[i].Role = ACLRole(v.Role)
}
return r, nil
}
// PutBucketACLRule saves the named ACL entity with the provided role for the named bucket.
func PutBucketACLRule(ctx context.Context, bucket string, entity ACLEntity, role ACLRole) error {
acl := &raw.BucketAccessControl{
Bucket: bucket,
Entity: string(entity),
Role: string(role),
}
_, err := rawService(ctx).BucketAccessControls.Update(bucket, string(entity), acl).Do()
if err != nil {
return fmt.Errorf("storage: error updating bucket ACL rule for bucket %q, entity %q: %v", bucket, entity, err)
}
return nil
}
// DeleteBucketACLRule deletes the named ACL entity for the named bucket.
func DeleteBucketACLRule(ctx context.Context, bucket string, entity ACLEntity) error {
err := rawService(ctx).BucketAccessControls.Delete(bucket, string(entity)).Do()
if err != nil {
return fmt.Errorf("storage: error deleting bucket ACL rule for bucket %q, entity %q: %v", bucket, entity, err)
}
return nil
}
// ACL returns the ACL entries for the named object.
func ACL(ctx context.Context, bucket, object string) ([]ACLRule, error) {
acls, err := rawService(ctx).ObjectAccessControls.List(bucket, object).Do()
if err != nil {
return nil, fmt.Errorf("storage: error listing object ACL for bucket %q, file %q: %v", bucket, object, err)
}
r := make([]ACLRule, 0, len(acls.Items))
for _, v := range acls.Items {
if m, ok := v.(map[string]interface{}); ok {
entity, ok1 := m["entity"].(string)
role, ok2 := m["role"].(string)
if ok1 && ok2 {
r = append(r, ACLRule{Entity: ACLEntity(entity), Role: ACLRole(role)})
}
}
}
return r, nil
}
// PutACLRule saves the named ACL entity with the provided role for the named object.
func PutACLRule(ctx context.Context, bucket, object string, entity ACLEntity, role ACLRole) error {
acl := &raw.ObjectAccessControl{
Bucket: bucket,
Entity: string(entity),
Role: string(role),
}
_, err := rawService(ctx).ObjectAccessControls.Update(bucket, object, string(entity), acl).Do()
if err != nil {
return fmt.Errorf("storage: error updating object ACL rule for bucket %q, file %q, entity %q: %v", bucket, object, entity, err)
}
return nil
}
// DeleteACLRule deletes the named ACL entity for the named object.
func DeleteACLRule(ctx context.Context, bucket, object string, entity ACLEntity) error {
err := rawService(ctx).ObjectAccessControls.Delete(bucket, object, string(entity)).Do()
if err != nil {
return fmt.Errorf("storage: error deleting object ACL rule for bucket %q, file %q, entity %q: %v", bucket, object, entity, err)
}
return nil
}
================================================
FILE: vendor/google.golang.org/cloud/storage/storage.go
================================================
// Copyright 2014 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
// Package storage contains a Google Cloud Storage client.
//
// This package is experimental and may make backwards-incompatible changes.
package storage
import (
"crypto"
"crypto/rand"
"crypto/rsa"
"crypto/sha256"
"crypto/x509"
"encoding/base64"
"encoding/pem"
"errors"
"fmt"
"io"
"net/http"
"net/url"
"strings"
"time"
"google.golang.org/cloud/internal"
"golang.org/x/net/context"
"google.golang.org/api/googleapi"
raw "google.golang.org/api/storage/v1"
)
var (
ErrBucketNotExist = errors.New("storage: bucket doesn't exist")
ErrObjectNotExist = errors.New("storage: object doesn't exist")
)
const (
// ScopeFullControl grants permissions to manage your
// data and permissions in Google Cloud Storage.
ScopeFullControl = raw.DevstorageFullControlScope
// ScopeReadOnly grants permissions to
// view your data in Google Cloud Storage.
ScopeReadOnly = raw.DevstorageReadOnlyScope
// ScopeReadWrite grants permissions to manage your
// data in Google Cloud Storage.
ScopeReadWrite = raw.DevstorageReadWriteScope
)
// TODO(jbd): Add storage.buckets.list.
// TODO(jbd): Add storage.buckets.insert.
// TODO(jbd): Add storage.buckets.update.
// TODO(jbd): Add storage.buckets.delete.
// TODO(jbd): Add storage.objects.watch.
// BucketInfo returns the metadata for the specified bucket.
func BucketInfo(ctx context.Context, name string) (*Bucket, error) {
resp, err := rawService(ctx).Buckets.Get(name).Projection("full").Do()
if e, ok := err.(*googleapi.Error); ok && e.Code == http.StatusNotFound {
return nil, ErrBucketNotExist
}
if err != nil {
return nil, err
}
return newBucket(resp), nil
}
// ListObjects lists objects from the bucket. You can specify a query
// to filter the results. If q is nil, no filtering is applied.
func ListObjects(ctx context.Context, bucket string, q *Query) (*Objects, error) {
c := rawService(ctx).Objects.List(bucket)
c.Projection("full")
if q != nil {
c.Delimiter(q.Delimiter)
c.Prefix(q.Prefix)
c.Versions(q.Versions)
c.PageToken(q.Cursor)
if q.MaxResults > 0 {
c.MaxResults(int64(q.MaxResults))
}
}
resp, err := c.Do()
if err != nil {
return nil, err
}
objects := &Objects{
Results: make([]*Object, len(resp.Items)),
Prefixes: make([]string, len(resp.Prefixes)),
}
for i, item := range resp.Items {
objects.Results[i] = newObject(item)
}
for i, prefix := range resp.Prefixes {
objects.Prefixes[i] = prefix
}
if resp.NextPageToken != "" {
next := Query{}
if q != nil {
// keep the other filtering
// criteria if there is a query
next = *q
}
next.Cursor = resp.NextPageToken
objects.Next = &next
}
return objects, nil
}
// SignedURLOptions allows you to restrict the access to the signed URL.
type SignedURLOptions struct {
// GoogleAccessID represents the authorizer of the signed URL generation.
// It is typically the Google service account client email address from
// the Google Developers Console in the form of "xxx@developer.gserviceaccount.com".
// Required.
GoogleAccessID string
// PrivateKey is the Google service account private key. It is obtainable
// from the Google Developers Console.
// At https://console.developers.google.com/project//apiui/credential,
// create a service account client ID or reuse one of your existing service account
// credentials. Click on the "Generate new P12 key" to generate and download
// a new private key. Once you download the P12 file, use the following command
// to convert it into a PEM file.
//
// $ openssl pkcs12 -in key.p12 -passin pass:notasecret -out key.pem -nodes
//
// Provide the contents of the PEM file as a byte slice.
// Required.
PrivateKey []byte
// Method is the HTTP method to be used with the signed URL.
// Signed URLs can be used with GET, HEAD, PUT, and DELETE requests.
// Required.
Method string
// Expires is the expiration time on the signed URL. It must be
// a datetime in the future.
// Required.
Expires time.Time
// ContentType is the content type header the client must provide
// to use the generated signed URL.
// Optional.
ContentType string
// Headers is a list of extention headers the client must provide
// in order to use the generated signed URL.
// Optional.
Headers []string
// MD5 is the base64 encoded MD5 checksum of the file.
// If provided, the client should provide the exact value on the request
// header in order to use the signed URL.
// Optional.
MD5 []byte
}
// SignedURL returns a URL for the specified object. Signed URLs allow
// the users access to a restricted resource for a limited time without having a
// Google account or signing in. For more information about the signed
// URLs, see https://cloud.google.com/storage/docs/accesscontrol#Signed-URLs.
func SignedURL(bucket, name string, opts *SignedURLOptions) (string, error) {
if opts == nil {
return "", errors.New("storage: missing required SignedURLOptions")
}
if opts.GoogleAccessID == "" || opts.PrivateKey == nil {
return "", errors.New("storage: missing required credentials to generate a signed URL")
}
if opts.Method == "" {
return "", errors.New("storage: missing required method option")
}
if opts.Expires.IsZero() {
return "", errors.New("storage: missing required expires option")
}
key, err := parseKey(opts.PrivateKey)
if err != nil {
return "", err
}
h := sha256.New()
fmt.Fprintf(h, "%s\n", opts.Method)
fmt.Fprintf(h, "%s\n", opts.MD5)
fmt.Fprintf(h, "%s\n", opts.ContentType)
fmt.Fprintf(h, "%d\n", opts.Expires.Unix())
fmt.Fprintf(h, "%s", strings.Join(opts.Headers, "\n"))
fmt.Fprintf(h, "/%s/%s", bucket, name)
b, err := rsa.SignPKCS1v15(
rand.Reader,
key,
crypto.SHA256,
h.Sum(nil),
)
if err != nil {
return "", err
}
encoded := base64.StdEncoding.EncodeToString(b)
u := &url.URL{
Scheme: "https",
Host: "storage.googleapis.com",
Path: fmt.Sprintf("/%s/%s", bucket, name),
}
q := u.Query()
q.Set("GoogleAccessId", opts.GoogleAccessID)
q.Set("Expires", fmt.Sprintf("%d", opts.Expires.Unix()))
q.Set("Signature", string(encoded))
u.RawQuery = q.Encode()
return u.String(), nil
}
// StatObject returns meta information about the specified object.
func StatObject(ctx context.Context, bucket, name string) (*Object, error) {
o, err := rawService(ctx).Objects.Get(bucket, name).Projection("full").Do()
if e, ok := err.(*googleapi.Error); ok && e.Code == http.StatusNotFound {
return nil, ErrObjectNotExist
}
if err != nil {
return nil, err
}
return newObject(o), nil
}
// UpdateAttrs updates an object with the provided attributes.
// All zero-value attributes are ignored.
func UpdateAttrs(ctx context.Context, bucket, name string, attrs ObjectAttrs) (*Object, error) {
o, err := rawService(ctx).Objects.Patch(bucket, name, attrs.toRawObject(bucket)).Projection("full").Do()
if e, ok := err.(*googleapi.Error); ok && e.Code == http.StatusNotFound {
return nil, ErrObjectNotExist
}
if err != nil {
return nil, err
}
return newObject(o), nil
}
// DeleteObject deletes the single specified object.
func DeleteObject(ctx context.Context, bucket, name string) error {
return rawService(ctx).Objects.Delete(bucket, name).Do()
}
// CopyObject copies the source object to the destination.
// The copied object's attributes are overwritten by attrs if non-nil.
func CopyObject(ctx context.Context, srcBucket, srcName string, destBucket, destName string, attrs *ObjectAttrs) (*Object, error) {
if srcBucket == "" || destBucket == "" {
return nil, errors.New("storage: srcBucket and destBucket must both be non-empty")
}
if srcName == "" || destName == "" {
return nil, errors.New("storage: srcName and destName must be non-empty")
}
var rawObject *raw.Object
if attrs != nil {
attrs.Name = destName
if attrs.ContentType == "" {
return nil, errors.New("storage: attrs.ContentType must be non-empty")
}
rawObject = attrs.toRawObject(destBucket)
}
o, err := rawService(ctx).Objects.Copy(
srcBucket, srcName, destBucket, destName, rawObject).Projection("full").Do()
if err != nil {
return nil, err
}
return newObject(o), nil
}
// NewReader creates a new io.ReadCloser to read the contents
// of the object.
func NewReader(ctx context.Context, bucket, name string) (io.ReadCloser, error) {
hc := internal.HTTPClient(ctx)
u := &url.URL{
Scheme: "https",
Host: "storage.googleapis.com",
Path: fmt.Sprintf("/%s/%s", bucket, name),
}
res, err := hc.Get(u.String())
if err != nil {
return nil, err
}
if res.StatusCode == http.StatusNotFound {
res.Body.Close()
return nil, ErrObjectNotExist
}
if res.StatusCode < 200 || res.StatusCode > 299 {
res.Body.Close()
return res.Body, fmt.Errorf("storage: can't read object %v/%v, status code: %v", bucket, name, res.Status)
}
return res.Body, nil
}
// NewWriter returns a storage Writer that writes to the GCS object
// identified by the specified name.
// If such an object doesn't exist, it creates one.
// Attributes can be set on the object by modifying the returned Writer's
// ObjectAttrs field before the first call to Write. The name parameter to this
// function is ignored if the Name field of the ObjectAttrs field is set to a
// non-empty string.
//
// It is the caller's responsibility to call Close when writing is done.
//
// The object is not available and any previous object with the same
// name is not replaced on Cloud Storage until Close is called.
func NewWriter(ctx context.Context, bucket, name string) *Writer {
return &Writer{
ctx: ctx,
bucket: bucket,
name: name,
donec: make(chan struct{}),
}
}
func rawService(ctx context.Context) *raw.Service {
return internal.Service(ctx, "storage", func(hc *http.Client) interface{} {
svc, _ := raw.New(hc)
return svc
}).(*raw.Service)
}
// parseKey converts the binary contents of a private key file
// to an *rsa.PrivateKey. It detects whether the private key is in a
// PEM container or not. If so, it extracts the the private key
// from PEM container before conversion. It only supports PEM
// containers with no passphrase.
func parseKey(key []byte) (*rsa.PrivateKey, error) {
if block, _ := pem.Decode(key); block != nil {
key = block.Bytes
}
parsedKey, err := x509.ParsePKCS8PrivateKey(key)
if err != nil {
parsedKey, err = x509.ParsePKCS1PrivateKey(key)
if err != nil {
return nil, err
}
}
parsed, ok := parsedKey.(*rsa.PrivateKey)
if !ok {
return nil, errors.New("oauth2: private key is invalid")
}
return parsed, nil
}
================================================
FILE: vendor/google.golang.org/cloud/storage/types.go
================================================
// Copyright 2014 Google Inc. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package storage
import (
"encoding/base64"
"io"
"sync"
"time"
"golang.org/x/net/context"
raw "google.golang.org/api/storage/v1"
)
// Bucket represents a Google Cloud Storage bucket.
type Bucket struct {
// Name is the name of the bucket.
Name string
// ACL is the list of access control rules on the bucket.
ACL []ACLRule
// DefaultObjectACL is the list of access controls to
// apply to new objects when no object ACL is provided.
DefaultObjectACL []ACLRule
// Location is the location of the bucket. It defaults to "US".
Location string
// Metageneration is the metadata generation of the bucket.
// Read-only.
Metageneration int64
// StorageClass is the storage class of the bucket. This defines
// how objects in the bucket are stored and determines the SLA
// and the cost of storage. Typical values are "STANDARD" and
// "DURABLE_REDUCED_AVAILABILITY". Defaults to "STANDARD".
StorageClass string
// Created is the creation time of the bucket.
// Read-only.
Created time.Time
}
func newBucket(b *raw.Bucket) *Bucket {
if b == nil {
return nil
}
bucket := &Bucket{
Name: b.Name,
Location: b.Location,
Metageneration: b.Metageneration,
StorageClass: b.StorageClass,
Created: convertTime(b.TimeCreated),
}
acl := make([]ACLRule, len(b.Acl))
for i, rule := range b.Acl {
acl[i] = ACLRule{
Entity: ACLEntity(rule.Entity),
Role: ACLRole(rule.Role),
}
}
bucket.ACL = acl
objACL := make([]ACLRule, len(b.DefaultObjectAcl))
for i, rule := range b.DefaultObjectAcl {
objACL[i] = ACLRule{
Entity: ACLEntity(rule.Entity),
Role: ACLRole(rule.Role),
}
}
bucket.DefaultObjectACL = objACL
return bucket
}
// ObjectAttrs is the user-editable object attributes.
type ObjectAttrs struct {
// Name is the name of the object.
Name string
// ContentType is the MIME type of the object's content.
// Optional.
ContentType string
// ContentLanguage is the optional RFC 1766 Content-Language of
// the object's content sent in response headers.
ContentLanguage string
// ContentEncoding is the optional Content-Encoding of the object
// sent it the response headers.
ContentEncoding string
// CacheControl is the optional Cache-Control header of the object
// sent in the response headers.
CacheControl string
// ACL is the list of access control rules for the object.
// Optional. If nil or empty, existing ACL rules are preserved.
ACL []ACLRule
// Metadata represents user-provided metadata, in key/value pairs.
// It can be nil if the current metadata values needs to preserved.
Metadata map[string]string
}
func (o ObjectAttrs) toRawObject(bucket string) *raw.Object {
var acl []*raw.ObjectAccessControl
if len(o.ACL) > 0 {
acl = make([]*raw.ObjectAccessControl, len(o.ACL))
for i, rule := range o.ACL {
acl[i] = &raw.ObjectAccessControl{
Entity: string(rule.Entity),
Role: string(rule.Role),
}
}
}
return &raw.Object{
Bucket: bucket,
Name: o.Name,
ContentType: o.ContentType,
ContentEncoding: o.ContentEncoding,
ContentLanguage: o.ContentLanguage,
CacheControl: o.CacheControl,
Acl: acl,
Metadata: o.Metadata,
}
}
// Object represents a Google Cloud Storage (GCS) object.
type Object struct {
// Bucket is the name of the bucket containing this GCS object.
Bucket string
// Name is the name of the object within the bucket.
Name string
// ContentType is the MIME type of the object's content.
ContentType string
// ContentLanguage is the content language of the object's content.
ContentLanguage string
// CacheControl is the Cache-Control header to be sent in the response
// headers when serving the object data.
CacheControl string
// ACL is the list of access control rules for the object.
ACL []ACLRule
// Owner is the owner of the object.
//
// If non-zero, it is in the form of "user-".
Owner string
// Size is the length of the object's content.
Size int64
// ContentEncoding is the encoding of the object's content.
ContentEncoding string
// MD5 is the MD5 hash of the object's content.
MD5 []byte
// CRC32C is the CRC32 checksum of the object's content using
// the Castagnoli93 polynomial.
CRC32C uint32
// MediaLink is an URL to the object's content.
MediaLink string
// Metadata represents user-provided metadata, in key/value pairs.
// It can be nil if no metadata is provided.
Metadata map[string]string
// Generation is the generation number of the object's content.
Generation int64
// MetaGeneration is the version of the metadata for this
// object at this generation. This field is used for preconditions
// and for detecting changes in metadata. A metageneration number
// is only meaningful in the context of a particular generation
// of a particular object.
MetaGeneration int64
// StorageClass is the storage class of the bucket.
// This value defines how objects in the bucket are stored and
// determines the SLA and the cost of storage. Typical values are
// "STANDARD" and "DURABLE_REDUCED_AVAILABILITY".
// It defaults to "STANDARD".
StorageClass string
// Deleted is the time the object was deleted.
// If not deleted, it is the zero value.
Deleted time.Time
// Updated is the creation or modification time of the object.
// For buckets with versioning enabled, changing an object's
// metadata does not change this property.
Updated time.Time
}
// convertTime converts a time in RFC3339 format to time.Time.
// If any error occurs in parsing, the zero-value time.Time is silently returned.
func convertTime(t string) time.Time {
var r time.Time
if t != "" {
r, _ = time.Parse(time.RFC3339, t)
}
return r
}
func newObject(o *raw.Object) *Object {
if o == nil {
return nil
}
acl := make([]ACLRule, len(o.Acl))
for i, rule := range o.Acl {
acl[i] = ACLRule{
Entity: ACLEntity(rule.Entity),
Role: ACLRole(rule.Role),
}
}
owner := ""
if o.Owner != nil {
owner = o.Owner.Entity
}
md5, _ := base64.StdEncoding.DecodeString(o.Md5Hash)
var crc32c uint32
d, err := base64.StdEncoding.DecodeString(o.Crc32c)
if err == nil && len(d) == 4 {
crc32c = uint32(d[0])<<24 + uint32(d[1])<<16 + uint32(d[2])<<8 + uint32(d[3])
}
return &Object{
Bucket: o.Bucket,
Name: o.Name,
ContentType: o.ContentType,
ContentLanguage: o.ContentLanguage,
CacheControl: o.CacheControl,
ACL: acl,
Owner: owner,
ContentEncoding: o.ContentEncoding,
Size: int64(o.Size),
MD5: md5,
CRC32C: crc32c,
MediaLink: o.MediaLink,
Metadata: o.Metadata,
Generation: o.Generation,
MetaGeneration: o.Metageneration,
StorageClass: o.StorageClass,
Deleted: convertTime(o.TimeDeleted),
Updated: convertTime(o.Updated),
}
}
// Query represents a query to filter objects from a bucket.
type Query struct {
// Delimiter returns results in a directory-like fashion.
// Results will contain only objects whose names, aside from the
// prefix, do not contain delimiter. Objects whose names,
// aside from the prefix, contain delimiter will have their name,
// truncated after the delimiter, returned in prefixes.
// Duplicate prefixes are omitted.
// Optional.
Delimiter string
// Prefix is the prefix filter to query objects
// whose names begin with this prefix.
// Optional.
Prefix string
// Versions indicates whether multiple versions of the same
// object will be included in the results.
Versions bool
// Cursor is a previously-returned page token
// representing part of the larger set of results to view.
// Optional.
Cursor string
// MaxResults is the maximum number of items plus prefixes
// to return. As duplicate prefixes are omitted,
// fewer total results may be returned than requested.
// The default page limit is used if it is negative or zero.
MaxResults int
}
// Objects represents a list of objects returned from
// a bucket look-p request and a query to retrieve more
// objects from the next pages.
type Objects struct {
// Results represent a list of object results.
Results []*Object
// Next is the continuation query to retrieve more
// results with the same filtering criteria. If there
// are no more results to retrieve, it is nil.
Next *Query
// Prefixes represents prefixes of objects
// matching-but-not-listed up to and including
// the requested delimiter.
Prefixes []string
}
// contentTyper implements ContentTyper to enable an
// io.ReadCloser to specify its MIME type.
type contentTyper struct {
io.Reader
t string
}
func (c *contentTyper) ContentType() string {
return c.t
}
// A Writer writes a Cloud Storage object.
type Writer struct {
// ObjectAttrs are optional attributes to set on the object. Any attributes
// must be initialized before the first Write call. Nil or zero-valued
// attributes are ignored.
ObjectAttrs
ctx context.Context
bucket string
name string
once sync.Once
opened bool
r io.Reader
pw *io.PipeWriter
donec chan struct{} // closed after err and obj are set.
err error
obj *Object
}
func (w *Writer) open() {
attrs := w.ObjectAttrs
// Always set the name, otherwise the backend
// rejects the request and responds with an HTTP 400.
if attrs.Name == "" {
attrs.Name = w.name
}
pr, pw := io.Pipe()
w.r = &contentTyper{pr, attrs.ContentType}
w.pw = pw
w.opened = true
go func() {
resp, err := rawService(w.ctx).Objects.Insert(
w.bucket, attrs.toRawObject(w.bucket)).Media(w.r).Projection("full").Do()
w.err = err
if err == nil {
w.obj = newObject(resp)
} else {
pr.CloseWithError(w.err)
}
close(w.donec)
}()
}
// Write appends to w.
func (w *Writer) Write(p []byte) (n int, err error) {
if w.err != nil {
return 0, w.err
}
if !w.opened {
w.open()
}
return w.pw.Write(p)
}
// Close completes the write operation and flushes any buffered data.
// If Close doesn't return an error, metadata about the written object
// can be retrieved by calling Object.
func (w *Writer) Close() error {
if !w.opened {
w.open()
}
if err := w.pw.Close(); err != nil {
return err
}
<-w.donec
return w.err
}
// Object returns metadata about a successfully-written object.
// It's only valid to call it after Close returns nil.
func (w *Writer) Object() *Object {
return w.obj
}
================================================
FILE: vendor/google.golang.org/grpc/.travis.yml
================================================
sudo: false
language: go
install:
- go get -v -t -d google.golang.org/grpc/...
script:
- go test -v -cpu 1,4 google.golang.org/grpc/...
- go test -v -race -cpu 1,4 google.golang.org/grpc/...
================================================
FILE: vendor/google.golang.org/grpc/CONTRIBUTING.md
================================================
# How to contribute
We definitely welcome patches and contribution to grpc! Here is some guideline
and information about how to do so.
## Getting started
### Legal requirements
In order to protect both you and ourselves, you will need to sign the
[Contributor License Agreement](https://cla.developers.google.com/clas).
### Filing Issues
When filing an issue, make sure to answer these five questions:
1. What version of Go are you using (`go version`)?
2. What operating system and processor architecture are you using?
3. What did you do?
4. What did you expect to see?
5. What did you see instead?
### Contributing code
Please read the Contribution Guidelines before sending patches.
We will not accept GitHub pull requests once Gerrit is setup (we will use Gerrit instead for code review).
Unless otherwise noted, the Go source files are distributed under the BSD-style license found in the LICENSE file.
================================================
FILE: vendor/google.golang.org/grpc/LICENSE
================================================
Copyright 2014, Google Inc.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above
copyright notice, this list of conditions and the following disclaimer
in the documentation and/or other materials provided with the
distribution.
* Neither the name of Google Inc. nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: vendor/google.golang.org/grpc/PATENTS
================================================
Additional IP Rights Grant (Patents)
"This implementation" means the copyrightable works distributed by
Google as part of the GRPC project.
Google hereby grants to You a perpetual, worldwide, non-exclusive,
no-charge, royalty-free, irrevocable (except as stated in this section)
patent license to make, have made, use, offer to sell, sell, import,
transfer and otherwise run, modify and propagate the contents of this
implementation of GRPC, where such license applies only to those patent
claims, both currently owned or controlled by Google and acquired in
the future, licensable by Google that are necessarily infringed by this
implementation of GRPC. This grant does not include claims that would be
infringed only as a consequence of further modification of this
implementation. If you or your agent or exclusive licensee institute or
order or agree to the institution of patent litigation against any
entity (including a cross-claim or counterclaim in a lawsuit) alleging
that this implementation of GRPC or any code incorporated within this
implementation of GRPC constitutes direct or contributory patent
infringement, or inducement of patent infringement, then any patent
rights granted to you under this License for this implementation of GRPC
shall terminate as of the date such litigation is filed.
================================================
FILE: vendor/google.golang.org/grpc/README.md
================================================
#gRPC-Go
[](https://travis-ci.org/grpc/grpc-go) [](https://godoc.org/google.golang.org/grpc)
The Go implementation of [gRPC](https://github.com/grpc/grpc)
Installation
------------
To install this package, you need to install Go 1.4 and setup your Go workspace on your computer. The simplest way to install the library is to run:
```
$ go get google.golang.org/grpc
```
Documentation
-------------
You can find more detailed documentation and examples in the [grpc-common repository](http://github.com/grpc/grpc-common).
Status
------
Alpha - ready for early adopters.
================================================
FILE: vendor/google.golang.org/grpc/benchmark/benchmark.go
================================================
/*
*
* Copyright 2014, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/*
Package benchmark implements the building blocks to setup end-to-end gRPC benchmarks.
*/
package benchmark
import (
"io"
"math"
"net"
"golang.org/x/net/context"
"google.golang.org/grpc"
testpb "google.golang.org/grpc/benchmark/grpc_testing"
"google.golang.org/grpc/grpclog"
)
func newPayload(t testpb.PayloadType, size int) *testpb.Payload {
if size < 0 {
grpclog.Fatalf("Requested a response with invalid length %d", size)
}
body := make([]byte, size)
switch t {
case testpb.PayloadType_COMPRESSABLE:
case testpb.PayloadType_UNCOMPRESSABLE:
grpclog.Fatalf("PayloadType UNCOMPRESSABLE is not supported")
default:
grpclog.Fatalf("Unsupported payload type: %d", t)
}
return &testpb.Payload{
Type: t,
Body: body,
}
}
type testServer struct {
}
func (s *testServer) UnaryCall(ctx context.Context, in *testpb.SimpleRequest) (*testpb.SimpleResponse, error) {
return &testpb.SimpleResponse{
Payload: newPayload(in.ResponseType, int(in.ResponseSize)),
}, nil
}
func (s *testServer) StreamingCall(stream testpb.TestService_StreamingCallServer) error {
for {
in, err := stream.Recv()
if err == io.EOF {
// read done.
return nil
}
if err != nil {
return err
}
if err := stream.Send(&testpb.SimpleResponse{
Payload: newPayload(in.ResponseType, int(in.ResponseSize)),
}); err != nil {
return err
}
}
}
// StartServer starts a gRPC server serving a benchmark service. It returns its
// listen address and a function to stop the server.
func StartServer() (string, func()) {
lis, err := net.Listen("tcp", ":0")
if err != nil {
grpclog.Fatalf("Failed to listen: %v", err)
}
s := grpc.NewServer(grpc.MaxConcurrentStreams(math.MaxUint32))
testpb.RegisterTestServiceServer(s, &testServer{})
go s.Serve(lis)
return lis.Addr().String(), func() {
s.Stop()
}
}
// DoUnaryCall performs an unary RPC with given stub and request and response sizes.
func DoUnaryCall(tc testpb.TestServiceClient, reqSize, respSize int) {
pl := newPayload(testpb.PayloadType_COMPRESSABLE, reqSize)
req := &testpb.SimpleRequest{
ResponseType: pl.Type,
ResponseSize: int32(respSize),
Payload: pl,
}
if _, err := tc.UnaryCall(context.Background(), req); err != nil {
grpclog.Fatal("/TestService/UnaryCall RPC failed: ", err)
}
}
// DoStreamingRoundTrip performs a round trip for a single streaming rpc.
func DoStreamingRoundTrip(tc testpb.TestServiceClient, stream testpb.TestService_StreamingCallClient, reqSize, respSize int) {
pl := newPayload(testpb.PayloadType_COMPRESSABLE, reqSize)
req := &testpb.SimpleRequest{
ResponseType: pl.Type,
ResponseSize: int32(respSize),
Payload: pl,
}
if err := stream.Send(req); err != nil {
grpclog.Fatalf("%v.StreamingCall(_) = _, %v", tc, err)
}
if _, err := stream.Recv(); err != nil {
grpclog.Fatal("%v.StreamingCall(_) = _, %v", tc, err)
}
}
// NewClientConn creates a gRPC client connection to addr.
func NewClientConn(addr string) *grpc.ClientConn {
conn, err := grpc.Dial(addr)
if err != nil {
grpclog.Fatalf("NewClientConn(%q) failed to create a ClientConn %v", addr, err)
}
return conn
}
================================================
FILE: vendor/google.golang.org/grpc/benchmark/client/main.go
================================================
package main
import (
"flag"
"math"
"net"
"net/http"
_ "net/http/pprof"
"sync"
"time"
"golang.org/x/net/context"
"google.golang.org/grpc"
"google.golang.org/grpc/benchmark"
testpb "google.golang.org/grpc/benchmark/grpc_testing"
"google.golang.org/grpc/benchmark/stats"
"google.golang.org/grpc/grpclog"
)
var (
server = flag.String("server", "", "The server address")
maxConcurrentRPCs = flag.Int("max_concurrent_rpcs", 1, "The max number of concurrent RPCs")
duration = flag.Int("duration", math.MaxInt32, "The duration in seconds to run the benchmark client")
rpcType = flag.Int("rpc_type", 0,
`Configure different client rpc type. Valid options are:
0 : unary call;
1 : streaming call.`)
)
func unaryCaller(client testpb.TestServiceClient) {
benchmark.DoUnaryCall(client, 1, 1)
}
func streamCaller(client testpb.TestServiceClient, stream testpb.TestService_StreamingCallClient) {
benchmark.DoStreamingRoundTrip(client, stream, 1, 1)
}
func buildConnection() (s *stats.Stats, conn *grpc.ClientConn, tc testpb.TestServiceClient) {
s = stats.NewStats(256)
conn = benchmark.NewClientConn(*server)
tc = testpb.NewTestServiceClient(conn)
return s, conn, tc
}
func closeLoopUnary() {
s, conn, tc := buildConnection()
for i := 0; i < 100; i++ {
unaryCaller(tc)
}
ch := make(chan int, *maxConcurrentRPCs*4)
var (
mu sync.Mutex
wg sync.WaitGroup
)
wg.Add(*maxConcurrentRPCs)
for i := 0; i < *maxConcurrentRPCs; i++ {
go func() {
for _ = range ch {
start := time.Now()
unaryCaller(tc)
elapse := time.Since(start)
mu.Lock()
s.Add(elapse)
mu.Unlock()
}
wg.Done()
}()
}
// Stop the client when time is up.
done := make(chan struct{})
go func() {
<-time.After(time.Duration(*duration) * time.Second)
close(done)
}()
ok := true
for ok {
select {
case ch <- 0:
case <-done:
ok = false
}
}
close(ch)
wg.Wait()
conn.Close()
grpclog.Println(s.String())
}
func closeLoopStream() {
s, conn, tc := buildConnection()
stream, err := tc.StreamingCall(context.Background())
if err != nil {
grpclog.Fatalf("%v.StreamingCall(_) = _, %v", tc, err)
}
for i := 0; i < 100; i++ {
streamCaller(tc, stream)
}
ch := make(chan int, *maxConcurrentRPCs*4)
var (
mu sync.Mutex
wg sync.WaitGroup
)
wg.Add(*maxConcurrentRPCs)
// Distribute RPCs over maxConcurrentCalls workers.
for i := 0; i < *maxConcurrentRPCs; i++ {
go func() {
for _ = range ch {
start := time.Now()
streamCaller(tc, stream)
elapse := time.Since(start)
mu.Lock()
s.Add(elapse)
mu.Unlock()
}
wg.Done()
}()
}
// Stop the client when time is up.
done := make(chan struct{})
go func() {
<-time.After(time.Duration(*duration) * time.Second)
close(done)
}()
ok := true
for ok {
select {
case ch <- 0:
case <-done:
ok = false
}
}
close(ch)
wg.Wait()
conn.Close()
grpclog.Println(s.String())
}
func main() {
flag.Parse()
go func() {
lis, err := net.Listen("tcp", ":0")
if err != nil {
grpclog.Fatalf("Failed to listen: %v", err)
}
grpclog.Println("Client profiling address: ", lis.Addr().String())
if err := http.Serve(lis, nil); err != nil {
grpclog.Fatalf("Failed to serve: %v", err)
}
}()
switch *rpcType {
case 0:
closeLoopUnary()
case 1:
closeLoopStream()
}
}
================================================
FILE: vendor/google.golang.org/grpc/benchmark/grpc_testing/test.pb.go
================================================
// Code generated by protoc-gen-go.
// source: test.proto
// DO NOT EDIT!
/*
Package grpc_testing is a generated protocol buffer package.
It is generated from these files:
test.proto
It has these top-level messages:
StatsRequest
ServerStats
Payload
HistogramData
ClientConfig
Mark
ClientArgs
ClientStats
ClientStatus
ServerConfig
ServerArgs
ServerStatus
SimpleRequest
SimpleResponse
*/
package grpc_testing
import proto "github.com/golang/protobuf/proto"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
type PayloadType int32
const (
// Compressable text format.
PayloadType_COMPRESSABLE PayloadType = 0
// Uncompressable binary format.
PayloadType_UNCOMPRESSABLE PayloadType = 1
// Randomly chosen from all other formats defined in this enum.
PayloadType_RANDOM PayloadType = 2
)
var PayloadType_name = map[int32]string{
0: "COMPRESSABLE",
1: "UNCOMPRESSABLE",
2: "RANDOM",
}
var PayloadType_value = map[string]int32{
"COMPRESSABLE": 0,
"UNCOMPRESSABLE": 1,
"RANDOM": 2,
}
func (x PayloadType) String() string {
return proto.EnumName(PayloadType_name, int32(x))
}
type ClientType int32
const (
ClientType_SYNCHRONOUS_CLIENT ClientType = 0
ClientType_ASYNC_CLIENT ClientType = 1
)
var ClientType_name = map[int32]string{
0: "SYNCHRONOUS_CLIENT",
1: "ASYNC_CLIENT",
}
var ClientType_value = map[string]int32{
"SYNCHRONOUS_CLIENT": 0,
"ASYNC_CLIENT": 1,
}
func (x ClientType) String() string {
return proto.EnumName(ClientType_name, int32(x))
}
type ServerType int32
const (
ServerType_SYNCHRONOUS_SERVER ServerType = 0
ServerType_ASYNC_SERVER ServerType = 1
)
var ServerType_name = map[int32]string{
0: "SYNCHRONOUS_SERVER",
1: "ASYNC_SERVER",
}
var ServerType_value = map[string]int32{
"SYNCHRONOUS_SERVER": 0,
"ASYNC_SERVER": 1,
}
func (x ServerType) String() string {
return proto.EnumName(ServerType_name, int32(x))
}
type RpcType int32
const (
RpcType_UNARY RpcType = 0
RpcType_STREAMING RpcType = 1
)
var RpcType_name = map[int32]string{
0: "UNARY",
1: "STREAMING",
}
var RpcType_value = map[string]int32{
"UNARY": 0,
"STREAMING": 1,
}
func (x RpcType) String() string {
return proto.EnumName(RpcType_name, int32(x))
}
type StatsRequest struct {
// run number
TestNum int32 `protobuf:"varint,1,opt,name=test_num" json:"test_num,omitempty"`
}
func (m *StatsRequest) Reset() { *m = StatsRequest{} }
func (m *StatsRequest) String() string { return proto.CompactTextString(m) }
func (*StatsRequest) ProtoMessage() {}
type ServerStats struct {
// wall clock time
TimeElapsed float64 `protobuf:"fixed64,1,opt,name=time_elapsed" json:"time_elapsed,omitempty"`
// user time used by the server process and threads
TimeUser float64 `protobuf:"fixed64,2,opt,name=time_user" json:"time_user,omitempty"`
// server time used by the server process and all threads
TimeSystem float64 `protobuf:"fixed64,3,opt,name=time_system" json:"time_system,omitempty"`
}
func (m *ServerStats) Reset() { *m = ServerStats{} }
func (m *ServerStats) String() string { return proto.CompactTextString(m) }
func (*ServerStats) ProtoMessage() {}
type Payload struct {
// The type of data in body.
Type PayloadType `protobuf:"varint,1,opt,name=type,enum=grpc.testing.PayloadType" json:"type,omitempty"`
// Primary contents of payload.
Body []byte `protobuf:"bytes,2,opt,name=body,proto3" json:"body,omitempty"`
}
func (m *Payload) Reset() { *m = Payload{} }
func (m *Payload) String() string { return proto.CompactTextString(m) }
func (*Payload) ProtoMessage() {}
type HistogramData struct {
Bucket []uint32 `protobuf:"varint,1,rep,name=bucket" json:"bucket,omitempty"`
MinSeen float64 `protobuf:"fixed64,2,opt,name=min_seen" json:"min_seen,omitempty"`
MaxSeen float64 `protobuf:"fixed64,3,opt,name=max_seen" json:"max_seen,omitempty"`
Sum float64 `protobuf:"fixed64,4,opt,name=sum" json:"sum,omitempty"`
SumOfSquares float64 `protobuf:"fixed64,5,opt,name=sum_of_squares" json:"sum_of_squares,omitempty"`
Count float64 `protobuf:"fixed64,6,opt,name=count" json:"count,omitempty"`
}
func (m *HistogramData) Reset() { *m = HistogramData{} }
func (m *HistogramData) String() string { return proto.CompactTextString(m) }
func (*HistogramData) ProtoMessage() {}
type ClientConfig struct {
ServerTargets []string `protobuf:"bytes,1,rep,name=server_targets" json:"server_targets,omitempty"`
ClientType ClientType `protobuf:"varint,2,opt,name=client_type,enum=grpc.testing.ClientType" json:"client_type,omitempty"`
EnableSsl bool `protobuf:"varint,3,opt,name=enable_ssl" json:"enable_ssl,omitempty"`
OutstandingRpcsPerChannel int32 `protobuf:"varint,4,opt,name=outstanding_rpcs_per_channel" json:"outstanding_rpcs_per_channel,omitempty"`
ClientChannels int32 `protobuf:"varint,5,opt,name=client_channels" json:"client_channels,omitempty"`
PayloadSize int32 `protobuf:"varint,6,opt,name=payload_size" json:"payload_size,omitempty"`
// only for async client:
AsyncClientThreads int32 `protobuf:"varint,7,opt,name=async_client_threads" json:"async_client_threads,omitempty"`
RpcType RpcType `protobuf:"varint,8,opt,name=rpc_type,enum=grpc.testing.RpcType" json:"rpc_type,omitempty"`
}
func (m *ClientConfig) Reset() { *m = ClientConfig{} }
func (m *ClientConfig) String() string { return proto.CompactTextString(m) }
func (*ClientConfig) ProtoMessage() {}
// Request current stats
type Mark struct {
}
func (m *Mark) Reset() { *m = Mark{} }
func (m *Mark) String() string { return proto.CompactTextString(m) }
func (*Mark) ProtoMessage() {}
type ClientArgs struct {
Setup *ClientConfig `protobuf:"bytes,1,opt,name=setup" json:"setup,omitempty"`
Mark *Mark `protobuf:"bytes,2,opt,name=mark" json:"mark,omitempty"`
}
func (m *ClientArgs) Reset() { *m = ClientArgs{} }
func (m *ClientArgs) String() string { return proto.CompactTextString(m) }
func (*ClientArgs) ProtoMessage() {}
func (m *ClientArgs) GetSetup() *ClientConfig {
if m != nil {
return m.Setup
}
return nil
}
func (m *ClientArgs) GetMark() *Mark {
if m != nil {
return m.Mark
}
return nil
}
type ClientStats struct {
Latencies *HistogramData `protobuf:"bytes,1,opt,name=latencies" json:"latencies,omitempty"`
TimeElapsed float64 `protobuf:"fixed64,3,opt,name=time_elapsed" json:"time_elapsed,omitempty"`
TimeUser float64 `protobuf:"fixed64,4,opt,name=time_user" json:"time_user,omitempty"`
TimeSystem float64 `protobuf:"fixed64,5,opt,name=time_system" json:"time_system,omitempty"`
}
func (m *ClientStats) Reset() { *m = ClientStats{} }
func (m *ClientStats) String() string { return proto.CompactTextString(m) }
func (*ClientStats) ProtoMessage() {}
func (m *ClientStats) GetLatencies() *HistogramData {
if m != nil {
return m.Latencies
}
return nil
}
type ClientStatus struct {
Stats *ClientStats `protobuf:"bytes,1,opt,name=stats" json:"stats,omitempty"`
}
func (m *ClientStatus) Reset() { *m = ClientStatus{} }
func (m *ClientStatus) String() string { return proto.CompactTextString(m) }
func (*ClientStatus) ProtoMessage() {}
func (m *ClientStatus) GetStats() *ClientStats {
if m != nil {
return m.Stats
}
return nil
}
type ServerConfig struct {
ServerType ServerType `protobuf:"varint,1,opt,name=server_type,enum=grpc.testing.ServerType" json:"server_type,omitempty"`
Threads int32 `protobuf:"varint,2,opt,name=threads" json:"threads,omitempty"`
EnableSsl bool `protobuf:"varint,3,opt,name=enable_ssl" json:"enable_ssl,omitempty"`
}
func (m *ServerConfig) Reset() { *m = ServerConfig{} }
func (m *ServerConfig) String() string { return proto.CompactTextString(m) }
func (*ServerConfig) ProtoMessage() {}
type ServerArgs struct {
Setup *ServerConfig `protobuf:"bytes,1,opt,name=setup" json:"setup,omitempty"`
Mark *Mark `protobuf:"bytes,2,opt,name=mark" json:"mark,omitempty"`
}
func (m *ServerArgs) Reset() { *m = ServerArgs{} }
func (m *ServerArgs) String() string { return proto.CompactTextString(m) }
func (*ServerArgs) ProtoMessage() {}
func (m *ServerArgs) GetSetup() *ServerConfig {
if m != nil {
return m.Setup
}
return nil
}
func (m *ServerArgs) GetMark() *Mark {
if m != nil {
return m.Mark
}
return nil
}
type ServerStatus struct {
Stats *ServerStats `protobuf:"bytes,1,opt,name=stats" json:"stats,omitempty"`
Port int32 `protobuf:"varint,2,opt,name=port" json:"port,omitempty"`
}
func (m *ServerStatus) Reset() { *m = ServerStatus{} }
func (m *ServerStatus) String() string { return proto.CompactTextString(m) }
func (*ServerStatus) ProtoMessage() {}
func (m *ServerStatus) GetStats() *ServerStats {
if m != nil {
return m.Stats
}
return nil
}
type SimpleRequest struct {
// Desired payload type in the response from the server.
// If response_type is RANDOM, server randomly chooses one from other formats.
ResponseType PayloadType `protobuf:"varint,1,opt,name=response_type,enum=grpc.testing.PayloadType" json:"response_type,omitempty"`
// Desired payload size in the response from the server.
// If response_type is COMPRESSABLE, this denotes the size before compression.
ResponseSize int32 `protobuf:"varint,2,opt,name=response_size" json:"response_size,omitempty"`
// Optional input payload sent along with the request.
Payload *Payload `protobuf:"bytes,3,opt,name=payload" json:"payload,omitempty"`
}
func (m *SimpleRequest) Reset() { *m = SimpleRequest{} }
func (m *SimpleRequest) String() string { return proto.CompactTextString(m) }
func (*SimpleRequest) ProtoMessage() {}
func (m *SimpleRequest) GetPayload() *Payload {
if m != nil {
return m.Payload
}
return nil
}
type SimpleResponse struct {
Payload *Payload `protobuf:"bytes,1,opt,name=payload" json:"payload,omitempty"`
}
func (m *SimpleResponse) Reset() { *m = SimpleResponse{} }
func (m *SimpleResponse) String() string { return proto.CompactTextString(m) }
func (*SimpleResponse) ProtoMessage() {}
func (m *SimpleResponse) GetPayload() *Payload {
if m != nil {
return m.Payload
}
return nil
}
func init() {
proto.RegisterEnum("grpc.testing.PayloadType", PayloadType_name, PayloadType_value)
proto.RegisterEnum("grpc.testing.ClientType", ClientType_name, ClientType_value)
proto.RegisterEnum("grpc.testing.ServerType", ServerType_name, ServerType_value)
proto.RegisterEnum("grpc.testing.RpcType", RpcType_name, RpcType_value)
}
// Client API for TestService service
type TestServiceClient interface {
// One request followed by one response.
// The server returns the client payload as-is.
UnaryCall(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error)
// One request followed by one response.
// The server returns the client payload as-is.
StreamingCall(ctx context.Context, opts ...grpc.CallOption) (TestService_StreamingCallClient, error)
}
type testServiceClient struct {
cc *grpc.ClientConn
}
func NewTestServiceClient(cc *grpc.ClientConn) TestServiceClient {
return &testServiceClient{cc}
}
func (c *testServiceClient) UnaryCall(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error) {
out := new(SimpleResponse)
err := grpc.Invoke(ctx, "/grpc.testing.TestService/UnaryCall", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *testServiceClient) StreamingCall(ctx context.Context, opts ...grpc.CallOption) (TestService_StreamingCallClient, error) {
stream, err := grpc.NewClientStream(ctx, &_TestService_serviceDesc.Streams[0], c.cc, "/grpc.testing.TestService/StreamingCall", opts...)
if err != nil {
return nil, err
}
x := &testServiceStreamingCallClient{stream}
return x, nil
}
type TestService_StreamingCallClient interface {
Send(*SimpleRequest) error
Recv() (*SimpleResponse, error)
grpc.ClientStream
}
type testServiceStreamingCallClient struct {
grpc.ClientStream
}
func (x *testServiceStreamingCallClient) Send(m *SimpleRequest) error {
return x.ClientStream.SendMsg(m)
}
func (x *testServiceStreamingCallClient) Recv() (*SimpleResponse, error) {
m := new(SimpleResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
// Server API for TestService service
type TestServiceServer interface {
// One request followed by one response.
// The server returns the client payload as-is.
UnaryCall(context.Context, *SimpleRequest) (*SimpleResponse, error)
// One request followed by one response.
// The server returns the client payload as-is.
StreamingCall(TestService_StreamingCallServer) error
}
func RegisterTestServiceServer(s *grpc.Server, srv TestServiceServer) {
s.RegisterService(&_TestService_serviceDesc, srv)
}
func _TestService_UnaryCall_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
in := new(SimpleRequest)
if err := codec.Unmarshal(buf, in); err != nil {
return nil, err
}
out, err := srv.(TestServiceServer).UnaryCall(ctx, in)
if err != nil {
return nil, err
}
return out, nil
}
func _TestService_StreamingCall_Handler(srv interface{}, stream grpc.ServerStream) error {
return srv.(TestServiceServer).StreamingCall(&testServiceStreamingCallServer{stream})
}
type TestService_StreamingCallServer interface {
Send(*SimpleResponse) error
Recv() (*SimpleRequest, error)
grpc.ServerStream
}
type testServiceStreamingCallServer struct {
grpc.ServerStream
}
func (x *testServiceStreamingCallServer) Send(m *SimpleResponse) error {
return x.ServerStream.SendMsg(m)
}
func (x *testServiceStreamingCallServer) Recv() (*SimpleRequest, error) {
m := new(SimpleRequest)
if err := x.ServerStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
var _TestService_serviceDesc = grpc.ServiceDesc{
ServiceName: "grpc.testing.TestService",
HandlerType: (*TestServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "UnaryCall",
Handler: _TestService_UnaryCall_Handler,
},
},
Streams: []grpc.StreamDesc{
{
StreamName: "StreamingCall",
Handler: _TestService_StreamingCall_Handler,
ServerStreams: true,
ClientStreams: true,
},
},
}
// Client API for Worker service
type WorkerClient interface {
// Start test with specified workload
RunTest(ctx context.Context, opts ...grpc.CallOption) (Worker_RunTestClient, error)
// Start test with specified workload
RunServer(ctx context.Context, opts ...grpc.CallOption) (Worker_RunServerClient, error)
}
type workerClient struct {
cc *grpc.ClientConn
}
func NewWorkerClient(cc *grpc.ClientConn) WorkerClient {
return &workerClient{cc}
}
func (c *workerClient) RunTest(ctx context.Context, opts ...grpc.CallOption) (Worker_RunTestClient, error) {
stream, err := grpc.NewClientStream(ctx, &_Worker_serviceDesc.Streams[0], c.cc, "/grpc.testing.Worker/RunTest", opts...)
if err != nil {
return nil, err
}
x := &workerRunTestClient{stream}
return x, nil
}
type Worker_RunTestClient interface {
Send(*ClientArgs) error
Recv() (*ClientStatus, error)
grpc.ClientStream
}
type workerRunTestClient struct {
grpc.ClientStream
}
func (x *workerRunTestClient) Send(m *ClientArgs) error {
return x.ClientStream.SendMsg(m)
}
func (x *workerRunTestClient) Recv() (*ClientStatus, error) {
m := new(ClientStatus)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *workerClient) RunServer(ctx context.Context, opts ...grpc.CallOption) (Worker_RunServerClient, error) {
stream, err := grpc.NewClientStream(ctx, &_Worker_serviceDesc.Streams[1], c.cc, "/grpc.testing.Worker/RunServer", opts...)
if err != nil {
return nil, err
}
x := &workerRunServerClient{stream}
return x, nil
}
type Worker_RunServerClient interface {
Send(*ServerArgs) error
Recv() (*ServerStatus, error)
grpc.ClientStream
}
type workerRunServerClient struct {
grpc.ClientStream
}
func (x *workerRunServerClient) Send(m *ServerArgs) error {
return x.ClientStream.SendMsg(m)
}
func (x *workerRunServerClient) Recv() (*ServerStatus, error) {
m := new(ServerStatus)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
// Server API for Worker service
type WorkerServer interface {
// Start test with specified workload
RunTest(Worker_RunTestServer) error
// Start test with specified workload
RunServer(Worker_RunServerServer) error
}
func RegisterWorkerServer(s *grpc.Server, srv WorkerServer) {
s.RegisterService(&_Worker_serviceDesc, srv)
}
func _Worker_RunTest_Handler(srv interface{}, stream grpc.ServerStream) error {
return srv.(WorkerServer).RunTest(&workerRunTestServer{stream})
}
type Worker_RunTestServer interface {
Send(*ClientStatus) error
Recv() (*ClientArgs, error)
grpc.ServerStream
}
type workerRunTestServer struct {
grpc.ServerStream
}
func (x *workerRunTestServer) Send(m *ClientStatus) error {
return x.ServerStream.SendMsg(m)
}
func (x *workerRunTestServer) Recv() (*ClientArgs, error) {
m := new(ClientArgs)
if err := x.ServerStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func _Worker_RunServer_Handler(srv interface{}, stream grpc.ServerStream) error {
return srv.(WorkerServer).RunServer(&workerRunServerServer{stream})
}
type Worker_RunServerServer interface {
Send(*ServerStatus) error
Recv() (*ServerArgs, error)
grpc.ServerStream
}
type workerRunServerServer struct {
grpc.ServerStream
}
func (x *workerRunServerServer) Send(m *ServerStatus) error {
return x.ServerStream.SendMsg(m)
}
func (x *workerRunServerServer) Recv() (*ServerArgs, error) {
m := new(ServerArgs)
if err := x.ServerStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
var _Worker_serviceDesc = grpc.ServiceDesc{
ServiceName: "grpc.testing.Worker",
HandlerType: (*WorkerServer)(nil),
Methods: []grpc.MethodDesc{},
Streams: []grpc.StreamDesc{
{
StreamName: "RunTest",
Handler: _Worker_RunTest_Handler,
ServerStreams: true,
ClientStreams: true,
},
{
StreamName: "RunServer",
Handler: _Worker_RunServer_Handler,
ServerStreams: true,
ClientStreams: true,
},
},
}
================================================
FILE: vendor/google.golang.org/grpc/benchmark/grpc_testing/test.proto
================================================
// An integration test service that covers all the method signature permutations
// of unary/streaming requests/responses.
syntax = "proto3";
package grpc.testing;
enum PayloadType {
// Compressable text format.
COMPRESSABLE = 0;
// Uncompressable binary format.
UNCOMPRESSABLE = 1;
// Randomly chosen from all other formats defined in this enum.
RANDOM = 2;
}
message StatsRequest {
// run number
optional int32 test_num = 1;
}
message ServerStats {
// wall clock time
double time_elapsed = 1;
// user time used by the server process and threads
double time_user = 2;
// server time used by the server process and all threads
double time_system = 3;
}
message Payload {
// The type of data in body.
PayloadType type = 1;
// Primary contents of payload.
bytes body = 2;
}
message HistogramData {
repeated uint32 bucket = 1;
double min_seen = 2;
double max_seen = 3;
double sum = 4;
double sum_of_squares = 5;
double count = 6;
}
enum ClientType {
SYNCHRONOUS_CLIENT = 0;
ASYNC_CLIENT = 1;
}
enum ServerType {
SYNCHRONOUS_SERVER = 0;
ASYNC_SERVER = 1;
}
enum RpcType {
UNARY = 0;
STREAMING = 1;
}
message ClientConfig {
repeated string server_targets = 1;
ClientType client_type = 2;
bool enable_ssl = 3;
int32 outstanding_rpcs_per_channel = 4;
int32 client_channels = 5;
int32 payload_size = 6;
// only for async client:
int32 async_client_threads = 7;
RpcType rpc_type = 8;
}
// Request current stats
message Mark {}
message ClientArgs {
oneof argtype {
ClientConfig setup = 1;
Mark mark = 2;
}
}
message ClientStats {
HistogramData latencies = 1;
double time_elapsed = 3;
double time_user = 4;
double time_system = 5;
}
message ClientStatus {
ClientStats stats = 1;
}
message ServerConfig {
ServerType server_type = 1;
int32 threads = 2;
bool enable_ssl = 3;
}
message ServerArgs {
oneof argtype {
ServerConfig setup = 1;
Mark mark = 2;
}
}
message ServerStatus {
ServerStats stats = 1;
int32 port = 2;
}
message SimpleRequest {
// Desired payload type in the response from the server.
// If response_type is RANDOM, server randomly chooses one from other formats.
PayloadType response_type = 1;
// Desired payload size in the response from the server.
// If response_type is COMPRESSABLE, this denotes the size before compression.
int32 response_size = 2;
// Optional input payload sent along with the request.
Payload payload = 3;
}
message SimpleResponse {
Payload payload = 1;
}
service TestService {
// One request followed by one response.
// The server returns the client payload as-is.
rpc UnaryCall(SimpleRequest) returns (SimpleResponse);
// One request followed by one response.
// The server returns the client payload as-is.
rpc StreamingCall(stream SimpleRequest) returns (stream SimpleResponse);
}
service Worker {
// Start test with specified workload
rpc RunTest(stream ClientArgs) returns (stream ClientStatus);
// Start test with specified workload
rpc RunServer(stream ServerArgs) returns (stream ServerStatus);
}
================================================
FILE: vendor/google.golang.org/grpc/benchmark/server/main.go
================================================
package main
import (
"flag"
"math"
"net"
"net/http"
_ "net/http/pprof"
"time"
"google.golang.org/grpc/benchmark"
"google.golang.org/grpc/grpclog"
)
var (
duration = flag.Int("duration", math.MaxInt32, "The duration in seconds to run the benchmark server")
)
func main() {
flag.Parse()
go func() {
lis, err := net.Listen("tcp", ":0")
if err != nil {
grpclog.Fatalf("Failed to listen: %v", err)
}
grpclog.Println("Server profiling address: ", lis.Addr().String())
if err := http.Serve(lis, nil); err != nil {
grpclog.Fatalf("Failed to serve: %v", err)
}
}()
addr, stopper := benchmark.StartServer()
grpclog.Println("Server Address: ", addr)
<-time.After(time.Duration(*duration) * time.Second)
stopper()
}
================================================
FILE: vendor/google.golang.org/grpc/benchmark/stats/counter.go
================================================
package stats
import (
"sync"
"time"
)
var (
// TimeNow is used for testing.
TimeNow = time.Now
)
const (
hour = 0
tenminutes = 1
minute = 2
)
// Counter is a counter that keeps track of its recent values over a given
// period of time, and with a given resolution. Use newCounter() to instantiate.
type Counter struct {
mu sync.RWMutex
ts [3]*timeseries
lastUpdate time.Time
}
// newCounter returns a new Counter.
func newCounter() *Counter {
now := TimeNow()
c := &Counter{}
c.ts[hour] = newTimeSeries(now, time.Hour, time.Minute)
c.ts[tenminutes] = newTimeSeries(now, 10*time.Minute, 10*time.Second)
c.ts[minute] = newTimeSeries(now, time.Minute, time.Second)
return c
}
func (c *Counter) advance() time.Time {
now := TimeNow()
for _, ts := range c.ts {
ts.advanceTime(now)
}
return now
}
// Value returns the current value of the counter.
func (c *Counter) Value() int64 {
c.mu.RLock()
defer c.mu.RUnlock()
return c.ts[minute].headValue()
}
// LastUpdate returns the last update time of the counter.
func (c *Counter) LastUpdate() time.Time {
c.mu.RLock()
defer c.mu.RUnlock()
return c.lastUpdate
}
// Set updates the current value of the counter.
func (c *Counter) Set(value int64) {
c.mu.Lock()
defer c.mu.Unlock()
c.lastUpdate = c.advance()
for _, ts := range c.ts {
ts.set(value)
}
}
// Incr increments the current value of the counter by 'delta'.
func (c *Counter) Incr(delta int64) {
c.mu.Lock()
defer c.mu.Unlock()
c.lastUpdate = c.advance()
for _, ts := range c.ts {
ts.incr(delta)
}
}
// Delta1h returns the delta for the last hour.
func (c *Counter) Delta1h() int64 {
c.mu.RLock()
defer c.mu.RUnlock()
c.advance()
return c.ts[hour].delta()
}
// Delta10m returns the delta for the last 10 minutes.
func (c *Counter) Delta10m() int64 {
c.mu.RLock()
defer c.mu.RUnlock()
c.advance()
return c.ts[tenminutes].delta()
}
// Delta1m returns the delta for the last minute.
func (c *Counter) Delta1m() int64 {
c.mu.RLock()
defer c.mu.RUnlock()
c.advance()
return c.ts[minute].delta()
}
// Rate1h returns the rate of change of the counter in the last hour.
func (c *Counter) Rate1h() float64 {
c.mu.RLock()
defer c.mu.RUnlock()
c.advance()
return c.ts[hour].rate()
}
// Rate10m returns the rate of change of the counter in the last 10 minutes.
func (c *Counter) Rate10m() float64 {
c.mu.RLock()
defer c.mu.RUnlock()
c.advance()
return c.ts[tenminutes].rate()
}
// Rate1m returns the rate of change of the counter in the last minute.
func (c *Counter) Rate1m() float64 {
c.mu.RLock()
defer c.mu.RUnlock()
c.advance()
return c.ts[minute].rate()
}
// Reset resets the counter to an empty state.
func (c *Counter) Reset() {
c.mu.Lock()
defer c.mu.Unlock()
now := TimeNow()
for _, ts := range c.ts {
ts.reset(now)
}
}
================================================
FILE: vendor/google.golang.org/grpc/benchmark/stats/histogram.go
================================================
package stats
import (
"bytes"
"fmt"
"io"
"strconv"
"strings"
"time"
)
// HistogramValue is the value of Histogram objects.
type HistogramValue struct {
// Count is the total number of values added to the histogram.
Count int64
// Sum is the sum of all the values added to the histogram.
Sum int64
// Min is the minimum of all the values added to the histogram.
Min int64
// Max is the maximum of all the values added to the histogram.
Max int64
// Buckets contains all the buckets of the histogram.
Buckets []HistogramBucket
}
// HistogramBucket is one histogram bucket.
type HistogramBucket struct {
// LowBound is the lower bound of the bucket.
LowBound int64
// Count is the number of values in the bucket.
Count int64
}
// Print writes textual output of the histogram values.
func (v HistogramValue) Print(w io.Writer) {
avg := float64(v.Sum) / float64(v.Count)
fmt.Fprintf(w, "Count: %d Min: %d Max: %d Avg: %.2f\n", v.Count, v.Min, v.Max, avg)
fmt.Fprintf(w, "%s\n", strings.Repeat("-", 60))
if v.Count <= 0 {
return
}
maxBucketDigitLen := len(strconv.FormatInt(v.Buckets[len(v.Buckets)-1].LowBound, 10))
if maxBucketDigitLen < 3 {
// For "inf".
maxBucketDigitLen = 3
}
maxCountDigitLen := len(strconv.FormatInt(v.Count, 10))
percentMulti := 100 / float64(v.Count)
accCount := int64(0)
for i, b := range v.Buckets {
fmt.Fprintf(w, "[%*d, ", maxBucketDigitLen, b.LowBound)
if i+1 < len(v.Buckets) {
fmt.Fprintf(w, "%*d)", maxBucketDigitLen, v.Buckets[i+1].LowBound)
} else {
fmt.Fprintf(w, "%*s)", maxBucketDigitLen, "inf")
}
accCount += b.Count
fmt.Fprintf(w, " %*d %5.1f%% %5.1f%%", maxCountDigitLen, b.Count, float64(b.Count)*percentMulti, float64(accCount)*percentMulti)
const barScale = 0.1
barLength := int(float64(b.Count)*percentMulti*barScale + 0.5)
fmt.Fprintf(w, " %s\n", strings.Repeat("#", barLength))
}
}
// String returns the textual output of the histogram values as string.
func (v HistogramValue) String() string {
var b bytes.Buffer
v.Print(&b)
return b.String()
}
// A Histogram accumulates values in the form of a histogram. The type of the
// values is int64, which is suitable for keeping track of things like RPC
// latency in milliseconds. New histogram objects should be obtained via the
// New() function.
type Histogram struct {
opts HistogramOptions
buckets []bucketInternal
count *Counter
sum *Counter
tracker *Tracker
}
// HistogramOptions contains the parameters that define the histogram's buckets.
type HistogramOptions struct {
// NumBuckets is the number of buckets.
NumBuckets int
// GrowthFactor is the growth factor of the buckets. A value of 0.1
// indicates that bucket N+1 will be 10% larger than bucket N.
GrowthFactor float64
// SmallestBucketSize is the size of the first bucket. Bucket sizes are
// rounded down to the nearest integer.
SmallestBucketSize float64
// MinValue is the lower bound of the first bucket.
MinValue int64
}
// bucketInternal is the internal representation of a bucket, which includes a
// rate counter.
type bucketInternal struct {
lowBound int64
count *Counter
}
// NewHistogram returns a pointer to a new Histogram object that was created
// with the provided options.
func NewHistogram(opts HistogramOptions) *Histogram {
if opts.NumBuckets == 0 {
opts.NumBuckets = 32
}
if opts.SmallestBucketSize == 0.0 {
opts.SmallestBucketSize = 1.0
}
h := Histogram{
opts: opts,
buckets: make([]bucketInternal, opts.NumBuckets),
count: newCounter(),
sum: newCounter(),
tracker: newTracker(),
}
low := opts.MinValue
delta := opts.SmallestBucketSize
for i := 0; i < opts.NumBuckets; i++ {
h.buckets[i].lowBound = low
h.buckets[i].count = newCounter()
low = low + int64(delta)
delta = delta * (1.0 + opts.GrowthFactor)
}
return &h
}
// Opts returns a copy of the options used to create the Histogram.
func (h *Histogram) Opts() HistogramOptions {
return h.opts
}
// Add adds a value to the histogram.
func (h *Histogram) Add(value int64) error {
bucket, err := h.findBucket(value)
if err != nil {
return err
}
h.buckets[bucket].count.Incr(1)
h.count.Incr(1)
h.sum.Incr(value)
h.tracker.Push(value)
return nil
}
// LastUpdate returns the time at which the object was last updated.
func (h *Histogram) LastUpdate() time.Time {
return h.count.LastUpdate()
}
// Value returns the accumulated state of the histogram since it was created.
func (h *Histogram) Value() HistogramValue {
b := make([]HistogramBucket, len(h.buckets))
for i, v := range h.buckets {
b[i] = HistogramBucket{
LowBound: v.lowBound,
Count: v.count.Value(),
}
}
v := HistogramValue{
Count: h.count.Value(),
Sum: h.sum.Value(),
Min: h.tracker.Min(),
Max: h.tracker.Max(),
Buckets: b,
}
return v
}
// Delta1h returns the change in the last hour.
func (h *Histogram) Delta1h() HistogramValue {
b := make([]HistogramBucket, len(h.buckets))
for i, v := range h.buckets {
b[i] = HistogramBucket{
LowBound: v.lowBound,
Count: v.count.Delta1h(),
}
}
v := HistogramValue{
Count: h.count.Delta1h(),
Sum: h.sum.Delta1h(),
Min: h.tracker.Min1h(),
Max: h.tracker.Max1h(),
Buckets: b,
}
return v
}
// Delta10m returns the change in the last 10 minutes.
func (h *Histogram) Delta10m() HistogramValue {
b := make([]HistogramBucket, len(h.buckets))
for i, v := range h.buckets {
b[i] = HistogramBucket{
LowBound: v.lowBound,
Count: v.count.Delta10m(),
}
}
v := HistogramValue{
Count: h.count.Delta10m(),
Sum: h.sum.Delta10m(),
Min: h.tracker.Min10m(),
Max: h.tracker.Max10m(),
Buckets: b,
}
return v
}
// Delta1m returns the change in the last 10 minutes.
func (h *Histogram) Delta1m() HistogramValue {
b := make([]HistogramBucket, len(h.buckets))
for i, v := range h.buckets {
b[i] = HistogramBucket{
LowBound: v.lowBound,
Count: v.count.Delta1m(),
}
}
v := HistogramValue{
Count: h.count.Delta1m(),
Sum: h.sum.Delta1m(),
Min: h.tracker.Min1m(),
Max: h.tracker.Max1m(),
Buckets: b,
}
return v
}
// findBucket does a binary search to find in which bucket the value goes.
func (h *Histogram) findBucket(value int64) (int, error) {
lastBucket := len(h.buckets) - 1
min, max := 0, lastBucket
for max >= min {
b := (min + max) / 2
if value >= h.buckets[b].lowBound && (b == lastBucket || value < h.buckets[b+1].lowBound) {
return b, nil
}
if value < h.buckets[b].lowBound {
max = b - 1
continue
}
min = b + 1
}
return 0, fmt.Errorf("no bucket for value: %f", value)
}
================================================
FILE: vendor/google.golang.org/grpc/benchmark/stats/stats.go
================================================
package stats
import (
"bytes"
"fmt"
"io"
"math"
"time"
)
// Stats is a simple helper for gathering additional statistics like histogram
// during benchmarks. This is not thread safe.
type Stats struct {
numBuckets int
unit time.Duration
min, max int64
histogram *Histogram
durations durationSlice
dirty bool
}
type durationSlice []time.Duration
// NewStats creates a new Stats instance. If numBuckets is not positive,
// the default value (16) will be used.
func NewStats(numBuckets int) *Stats {
if numBuckets <= 0 {
numBuckets = 16
}
return &Stats{
// Use one more bucket for the last unbounded bucket.
numBuckets: numBuckets + 1,
durations: make(durationSlice, 0, 100000),
}
}
// Add adds an elapsed time per operation to the stats.
func (stats *Stats) Add(d time.Duration) {
stats.durations = append(stats.durations, d)
stats.dirty = true
}
// Clear resets the stats, removing all values.
func (stats *Stats) Clear() {
stats.durations = stats.durations[:0]
stats.histogram = nil
stats.dirty = false
}
// maybeUpdate updates internal stat data if there was any newly added
// stats since this was updated.
func (stats *Stats) maybeUpdate() {
if !stats.dirty {
return
}
stats.min = math.MaxInt64
stats.max = 0
for _, d := range stats.durations {
if stats.min > int64(d) {
stats.min = int64(d)
}
if stats.max < int64(d) {
stats.max = int64(d)
}
}
// Use the largest unit that can represent the minimum time duration.
stats.unit = time.Nanosecond
for _, u := range []time.Duration{time.Microsecond, time.Millisecond, time.Second} {
if stats.min <= int64(u) {
break
}
stats.unit = u
}
// Adjust the min/max according to the new unit.
stats.min /= int64(stats.unit)
stats.max /= int64(stats.unit)
numBuckets := stats.numBuckets
if n := int(stats.max - stats.min + 1); n < numBuckets {
numBuckets = n
}
stats.histogram = NewHistogram(HistogramOptions{
NumBuckets: numBuckets,
// max(i.e., Nth lower bound) = min + (1 + growthFactor)^(numBuckets-2).
GrowthFactor: math.Pow(float64(stats.max-stats.min), 1/float64(stats.numBuckets-2)) - 1,
SmallestBucketSize: 1.0,
MinValue: stats.min})
for _, d := range stats.durations {
stats.histogram.Add(int64(d / stats.unit))
}
stats.dirty = false
}
// Print writes textual output of the Stats.
func (stats *Stats) Print(w io.Writer) {
stats.maybeUpdate()
if stats.histogram == nil {
fmt.Fprint(w, "Histogram (empty)\n")
} else {
fmt.Fprintf(w, "Histogram (unit: %s)\n", fmt.Sprintf("%v", stats.unit)[1:])
stats.histogram.Value().Print(w)
}
}
// String returns the textual output of the Stats as string.
func (stats *Stats) String() string {
var b bytes.Buffer
stats.Print(&b)
return b.String()
}
================================================
FILE: vendor/google.golang.org/grpc/benchmark/stats/timeseries.go
================================================
package stats
import (
"math"
"time"
)
// timeseries holds the history of a changing value over a predefined period of
// time.
type timeseries struct {
size int // The number of time slots. Equivalent to len(slots).
resolution time.Duration // The time resolution of each slot.
stepCount int64 // The number of intervals seen since creation.
head int // The position of the current time in slots.
time time.Time // The time at the beginning of the current time slot.
slots []int64 // A circular buffer of time slots.
}
// newTimeSeries returns a newly allocated timeseries that covers the requested
// period with the given resolution.
func newTimeSeries(initialTime time.Time, period, resolution time.Duration) *timeseries {
size := int(period.Nanoseconds()/resolution.Nanoseconds()) + 1
return ×eries{
size: size,
resolution: resolution,
stepCount: 1,
time: initialTime,
slots: make([]int64, size),
}
}
// advanceTimeWithFill moves the timeseries forward to time t and fills in any
// slots that get skipped in the process with the given value. Values older than
// the timeseries period are lost.
func (ts *timeseries) advanceTimeWithFill(t time.Time, value int64) {
advanceTo := t.Truncate(ts.resolution)
if !advanceTo.After(ts.time) {
// This is shortcut for the most common case of a busy counter
// where updates come in many times per ts.resolution.
ts.time = advanceTo
return
}
steps := int(advanceTo.Sub(ts.time).Nanoseconds() / ts.resolution.Nanoseconds())
ts.stepCount += int64(steps)
if steps > ts.size {
steps = ts.size
}
for steps > 0 {
ts.head = (ts.head + 1) % ts.size
ts.slots[ts.head] = value
steps--
}
ts.time = advanceTo
}
// advanceTime moves the timeseries forward to time t and fills in any slots
// that get skipped in the process with the head value. Values older than the
// timeseries period are lost.
func (ts *timeseries) advanceTime(t time.Time) {
ts.advanceTimeWithFill(t, ts.slots[ts.head])
}
// set sets the current value of the timeseries.
func (ts *timeseries) set(value int64) {
ts.slots[ts.head] = value
}
// incr sets the current value of the timeseries.
func (ts *timeseries) incr(delta int64) {
ts.slots[ts.head] += delta
}
// headValue returns the latest value from the timeseries.
func (ts *timeseries) headValue() int64 {
return ts.slots[ts.head]
}
// headTime returns the time of the latest value from the timeseries.
func (ts *timeseries) headTime() time.Time {
return ts.time
}
// tailValue returns the oldest value from the timeseries.
func (ts *timeseries) tailValue() int64 {
if ts.stepCount < int64(ts.size) {
return 0
}
return ts.slots[(ts.head+1)%ts.size]
}
// tailTime returns the time of the oldest value from the timeseries.
func (ts *timeseries) tailTime() time.Time {
size := int64(ts.size)
if ts.stepCount < size {
size = ts.stepCount
}
return ts.time.Add(-time.Duration(size-1) * ts.resolution)
}
// delta returns the difference between the newest and oldest values from the
// timeseries.
func (ts *timeseries) delta() int64 {
return ts.headValue() - ts.tailValue()
}
// rate returns the rate of change between the oldest and newest values from
// the timeseries in units per second.
func (ts *timeseries) rate() float64 {
deltaTime := ts.headTime().Sub(ts.tailTime()).Seconds()
if deltaTime == 0 {
return 0
}
return float64(ts.delta()) / deltaTime
}
// min returns the smallest value from the timeseries.
func (ts *timeseries) min() int64 {
to := ts.size
if ts.stepCount < int64(ts.size) {
to = ts.head + 1
}
tail := (ts.head + 1) % ts.size
min := int64(math.MaxInt64)
for b := 0; b < to; b++ {
if b != tail && ts.slots[b] < min {
min = ts.slots[b]
}
}
return min
}
// max returns the largest value from the timeseries.
func (ts *timeseries) max() int64 {
to := ts.size
if ts.stepCount < int64(ts.size) {
to = ts.head + 1
}
tail := (ts.head + 1) % ts.size
max := int64(math.MinInt64)
for b := 0; b < to; b++ {
if b != tail && ts.slots[b] > max {
max = ts.slots[b]
}
}
return max
}
// reset resets the timeseries to an empty state.
func (ts *timeseries) reset(t time.Time) {
ts.head = 0
ts.time = t
ts.stepCount = 1
ts.slots = make([]int64, ts.size)
}
================================================
FILE: vendor/google.golang.org/grpc/benchmark/stats/tracker.go
================================================
package stats
import (
"math"
"sync"
"time"
)
// Tracker is a min/max value tracker that keeps track of its min/max values
// over a given period of time, and with a given resolution. The initial min
// and max values are math.MaxInt64 and math.MinInt64 respectively.
type Tracker struct {
mu sync.RWMutex
min, max int64 // All time min/max.
minTS, maxTS [3]*timeseries
lastUpdate time.Time
}
// newTracker returns a new Tracker.
func newTracker() *Tracker {
now := TimeNow()
t := &Tracker{}
t.minTS[hour] = newTimeSeries(now, time.Hour, time.Minute)
t.minTS[tenminutes] = newTimeSeries(now, 10*time.Minute, 10*time.Second)
t.minTS[minute] = newTimeSeries(now, time.Minute, time.Second)
t.maxTS[hour] = newTimeSeries(now, time.Hour, time.Minute)
t.maxTS[tenminutes] = newTimeSeries(now, 10*time.Minute, 10*time.Second)
t.maxTS[minute] = newTimeSeries(now, time.Minute, time.Second)
t.init()
return t
}
func (t *Tracker) init() {
t.min = math.MaxInt64
t.max = math.MinInt64
for _, ts := range t.minTS {
ts.set(math.MaxInt64)
}
for _, ts := range t.maxTS {
ts.set(math.MinInt64)
}
}
func (t *Tracker) advance() time.Time {
now := TimeNow()
for _, ts := range t.minTS {
ts.advanceTimeWithFill(now, math.MaxInt64)
}
for _, ts := range t.maxTS {
ts.advanceTimeWithFill(now, math.MinInt64)
}
return now
}
// LastUpdate returns the last update time of the range.
func (t *Tracker) LastUpdate() time.Time {
t.mu.RLock()
defer t.mu.RUnlock()
return t.lastUpdate
}
// Push adds a new value if it is a new minimum or maximum.
func (t *Tracker) Push(value int64) {
t.mu.Lock()
defer t.mu.Unlock()
t.lastUpdate = t.advance()
if t.min > value {
t.min = value
}
if t.max < value {
t.max = value
}
for _, ts := range t.minTS {
if ts.headValue() > value {
ts.set(value)
}
}
for _, ts := range t.maxTS {
if ts.headValue() < value {
ts.set(value)
}
}
}
// Min returns the minimum value of the tracker
func (t *Tracker) Min() int64 {
t.mu.RLock()
defer t.mu.RUnlock()
return t.min
}
// Max returns the maximum value of the tracker.
func (t *Tracker) Max() int64 {
t.mu.RLock()
defer t.mu.RUnlock()
return t.max
}
// Min1h returns the minimum value for the last hour.
func (t *Tracker) Min1h() int64 {
t.mu.Lock()
defer t.mu.Unlock()
t.advance()
return t.minTS[hour].min()
}
// Max1h returns the maximum value for the last hour.
func (t *Tracker) Max1h() int64 {
t.mu.Lock()
defer t.mu.Unlock()
t.advance()
return t.maxTS[hour].max()
}
// Min10m returns the minimum value for the last 10 minutes.
func (t *Tracker) Min10m() int64 {
t.mu.Lock()
defer t.mu.Unlock()
t.advance()
return t.minTS[tenminutes].min()
}
// Max10m returns the maximum value for the last 10 minutes.
func (t *Tracker) Max10m() int64 {
t.mu.Lock()
defer t.mu.Unlock()
t.advance()
return t.maxTS[tenminutes].max()
}
// Min1m returns the minimum value for the last 1 minute.
func (t *Tracker) Min1m() int64 {
t.mu.Lock()
defer t.mu.Unlock()
t.advance()
return t.minTS[minute].min()
}
// Max1m returns the maximum value for the last 1 minute.
func (t *Tracker) Max1m() int64 {
t.mu.Lock()
defer t.mu.Unlock()
t.advance()
return t.maxTS[minute].max()
}
// Reset resets the range to an empty state.
func (t *Tracker) Reset() {
t.mu.Lock()
defer t.mu.Unlock()
now := TimeNow()
for _, ts := range t.minTS {
ts.reset(now)
}
for _, ts := range t.maxTS {
ts.reset(now)
}
t.init()
}
================================================
FILE: vendor/google.golang.org/grpc/benchmark/stats/util.go
================================================
package stats
import (
"bufio"
"bytes"
"fmt"
"os"
"runtime"
"sort"
"strings"
"sync"
"testing"
)
var (
curB *testing.B
curBenchName string
curStats map[string]*Stats
orgStdout *os.File
nextOutPos int
injectCond *sync.Cond
injectDone chan struct{}
)
// AddStats adds a new unnamed Stats instance to the current benchmark. You need
// to run benchmarks by calling RunTestMain() to inject the stats to the
// benchmark results. If numBuckets is not positive, the default value (16) will
// be used. Please note that this calls b.ResetTimer() since it may be blocked
// until the previous benchmark stats is printed out. So AddStats() should
// typically be called at the very beginning of each benchmark function.
func AddStats(b *testing.B, numBuckets int) *Stats {
return AddStatsWithName(b, "", numBuckets)
}
// AddStatsWithName adds a new named Stats instance to the current benchmark.
// With this, you can add multiple stats in a single benchmark. You need
// to run benchmarks by calling RunTestMain() to inject the stats to the
// benchmark results. If numBuckets is not positive, the default value (16) will
// be used. Please note that this calls b.ResetTimer() since it may be blocked
// until the previous benchmark stats is printed out. So AddStatsWithName()
// should typically be called at the very beginning of each benchmark function.
func AddStatsWithName(b *testing.B, name string, numBuckets int) *Stats {
var benchName string
for i := 1; ; i++ {
pc, _, _, ok := runtime.Caller(i)
if !ok {
panic("benchmark function not found")
}
p := strings.Split(runtime.FuncForPC(pc).Name(), ".")
benchName = p[len(p)-1]
if strings.HasPrefix(benchName, "Benchmark") {
break
}
}
procs := runtime.GOMAXPROCS(-1)
if procs != 1 {
benchName = fmt.Sprintf("%s-%d", benchName, procs)
}
stats := NewStats(numBuckets)
if injectCond != nil {
// We need to wait until the previous benchmark stats is printed out.
injectCond.L.Lock()
for curB != nil && curBenchName != benchName {
injectCond.Wait()
}
curB = b
curBenchName = benchName
curStats[name] = stats
injectCond.L.Unlock()
}
b.ResetTimer()
return stats
}
// RunTestMain runs the tests with enabling injection of benchmark stats. It
// returns an exit code to pass to os.Exit.
func RunTestMain(m *testing.M) int {
startStatsInjector()
defer stopStatsInjector()
return m.Run()
}
// startStatsInjector starts stats injection to benchmark results.
func startStatsInjector() {
orgStdout = os.Stdout
r, w, _ := os.Pipe()
os.Stdout = w
nextOutPos = 0
resetCurBenchStats()
injectCond = sync.NewCond(&sync.Mutex{})
injectDone = make(chan struct{})
go func() {
defer close(injectDone)
scanner := bufio.NewScanner(r)
scanner.Split(splitLines)
for scanner.Scan() {
injectStatsIfFinished(scanner.Text())
}
if err := scanner.Err(); err != nil {
panic(err)
}
}()
}
// stopStatsInjector stops stats injection and restores os.Stdout.
func stopStatsInjector() {
os.Stdout.Close()
<-injectDone
injectCond = nil
os.Stdout = orgStdout
}
// splitLines is a split function for a bufio.Scanner that returns each line
// of text, teeing texts to the original stdout even before each line ends.
func splitLines(data []byte, eof bool) (advance int, token []byte, err error) {
if eof && len(data) == 0 {
return 0, nil, nil
}
if i := bytes.IndexByte(data, '\n'); i >= 0 {
orgStdout.Write(data[nextOutPos : i+1])
nextOutPos = 0
return i + 1, data[0:i], nil
}
orgStdout.Write(data[nextOutPos:])
nextOutPos = len(data)
if eof {
// This is a final, non-terminated line. Return it.
return len(data), data, nil
}
return 0, nil, nil
}
// injectStatsIfFinished prints out the stats if the current benchmark finishes.
func injectStatsIfFinished(line string) {
injectCond.L.Lock()
defer injectCond.L.Unlock()
// We assume that the benchmark results start with the benchmark name.
if curB == nil || !strings.HasPrefix(line, curBenchName) {
return
}
if !curB.Failed() {
// Output all stats in alphabetical order.
names := make([]string, 0, len(curStats))
for name := range curStats {
names = append(names, name)
}
sort.Strings(names)
for _, name := range names {
stats := curStats[name]
// The output of stats starts with a header like "Histogram (unit: ms)"
// followed by statistical properties and the buckets. Add the stats name
// if it is a named stats and indent them as Go testing outputs.
lines := strings.Split(stats.String(), "\n")
if n := len(lines); n > 0 {
if name != "" {
name = ": " + name
}
fmt.Fprintf(orgStdout, "--- %s%s\n", lines[0], name)
for _, line := range lines[1 : n-1] {
fmt.Fprintf(orgStdout, "\t%s\n", line)
}
}
}
}
resetCurBenchStats()
injectCond.Signal()
}
// resetCurBenchStats resets the current benchmark stats.
func resetCurBenchStats() {
curB = nil
curBenchName = ""
curStats = make(map[string]*Stats)
}
================================================
FILE: vendor/google.golang.org/grpc/call.go
================================================
/*
*
* Copyright 2014, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package grpc
import (
"io"
"golang.org/x/net/context"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/metadata"
"google.golang.org/grpc/transport"
)
// recvResponse receives and parses an RPC response.
// On error, it returns the error and indicates whether the call should be retried.
//
// TODO(zhaoq): Check whether the received message sequence is valid.
func recvResponse(codec Codec, t transport.ClientTransport, c *callInfo, stream *transport.Stream, reply interface{}) error {
// Try to acquire header metadata from the server if there is any.
var err error
c.headerMD, err = stream.Header()
if err != nil {
return err
}
p := &parser{s: stream}
for {
if err = recv(p, codec, reply); err != nil {
if err == io.EOF {
break
}
return err
}
}
c.trailerMD = stream.Trailer()
return nil
}
// sendRequest writes out various information of an RPC such as Context and Message.
func sendRequest(ctx context.Context, codec Codec, callHdr *transport.CallHdr, t transport.ClientTransport, args interface{}, opts *transport.Options) (_ *transport.Stream, err error) {
stream, err := t.NewStream(ctx, callHdr)
if err != nil {
return nil, err
}
defer func() {
if err != nil {
if _, ok := err.(transport.ConnectionError); !ok {
t.CloseStream(stream, err)
}
}
}()
// TODO(zhaoq): Support compression.
outBuf, err := encode(codec, args, compressionNone)
if err != nil {
return nil, transport.StreamErrorf(codes.Internal, "grpc: %v", err)
}
err = t.Write(stream, outBuf, opts)
if err != nil {
return nil, err
}
// Sent successfully.
return stream, nil
}
// callInfo contains all related configuration and information about an RPC.
type callInfo struct {
failFast bool
headerMD metadata.MD
trailerMD metadata.MD
}
// Invoke is called by the generated code. It sends the RPC request on the
// wire and returns after response is received.
func Invoke(ctx context.Context, method string, args, reply interface{}, cc *ClientConn, opts ...CallOption) error {
var c callInfo
for _, o := range opts {
if err := o.before(&c); err != nil {
return toRPCErr(err)
}
}
defer func() {
for _, o := range opts {
o.after(&c)
}
}()
callHdr := &transport.CallHdr{
Host: cc.authority,
Method: method,
}
topts := &transport.Options{
Last: true,
Delay: false,
}
var (
ts int // track the transport sequence number
lastErr error // record the error that happened
)
for {
var (
err error
t transport.ClientTransport
stream *transport.Stream
)
// TODO(zhaoq): Need a formal spec of retry strategy for non-failfast rpcs.
if lastErr != nil && c.failFast {
return toRPCErr(lastErr)
}
t, ts, err = cc.wait(ctx, ts)
if err != nil {
if lastErr != nil {
// This was a retry; return the error from the last attempt.
return toRPCErr(lastErr)
}
return toRPCErr(err)
}
stream, err = sendRequest(ctx, cc.dopts.codec, callHdr, t, args, topts)
if err != nil {
if _, ok := err.(transport.ConnectionError); ok {
lastErr = err
continue
}
if lastErr != nil {
return toRPCErr(lastErr)
}
return toRPCErr(err)
}
// Receive the response
lastErr = recvResponse(cc.dopts.codec, t, &c, stream, reply)
if _, ok := lastErr.(transport.ConnectionError); ok {
continue
}
t.CloseStream(stream, lastErr)
if lastErr != nil {
return toRPCErr(lastErr)
}
return Errorf(stream.StatusCode(), stream.StatusDesc())
}
}
================================================
FILE: vendor/google.golang.org/grpc/clientconn.go
================================================
/*
*
* Copyright 2014, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package grpc
import (
"errors"
"net"
"strings"
"sync"
"time"
"golang.org/x/net/context"
"google.golang.org/grpc/credentials"
"google.golang.org/grpc/grpclog"
"google.golang.org/grpc/transport"
)
var (
// ErrUnspecTarget indicates that the target address is unspecified.
ErrUnspecTarget = errors.New("grpc: target is unspecified")
// ErrClientConnClosing indicates that the operation is illegal because
// the session is closing.
ErrClientConnClosing = errors.New("grpc: the client connection is closing")
// ErrClientConnTimeout indicates that the connection could not be
// established or re-established within the specified timeout.
ErrClientConnTimeout = errors.New("grpc: timed out trying to connect")
)
// dialOptions configure a Dial call. dialOptions are set by the DialOption
// values passed to Dial.
type dialOptions struct {
codec Codec
copts transport.ConnectOptions
}
// DialOption configures how we set up the connection.
type DialOption func(*dialOptions)
// WithCodec returns a DialOption which sets a codec for message marshaling and unmarshaling.
func WithCodec(c Codec) DialOption {
return func(o *dialOptions) {
o.codec = c
}
}
// WithTransportCredentials returns a DialOption which configures a
// connection level security credentials (e.g., TLS/SSL).
func WithTransportCredentials(creds credentials.TransportAuthenticator) DialOption {
return func(o *dialOptions) {
o.copts.AuthOptions = append(o.copts.AuthOptions, creds)
}
}
// WithPerRPCCredentials returns a DialOption which sets
// credentials which will place auth state on each outbound RPC.
func WithPerRPCCredentials(creds credentials.Credentials) DialOption {
return func(o *dialOptions) {
o.copts.AuthOptions = append(o.copts.AuthOptions, creds)
}
}
// WithTimeout returns a DialOption that configures a timeout for dialing a client connection.
func WithTimeout(d time.Duration) DialOption {
return func(o *dialOptions) {
o.copts.Timeout = d
}
}
// WithDialer returns a DialOption that specifies a function to use for dialing network addresses.
func WithDialer(f func(addr string, timeout time.Duration) (net.Conn, error)) DialOption {
return func(o *dialOptions) {
o.copts.Dialer = f
}
}
// Dial creates a client connection the given target.
// TODO(zhaoq): Have an option to make Dial return immediately without waiting
// for connection to complete.
func Dial(target string, opts ...DialOption) (*ClientConn, error) {
if target == "" {
return nil, ErrUnspecTarget
}
cc := &ClientConn{
target: target,
}
for _, opt := range opts {
opt(&cc.dopts)
}
colonPos := strings.LastIndex(target, ":")
if colonPos == -1 {
colonPos = len(target)
}
cc.authority = target[:colonPos]
if cc.dopts.codec == nil {
// Set the default codec.
cc.dopts.codec = protoCodec{}
}
if err := cc.resetTransport(false); err != nil {
return nil, err
}
cc.shutdownChan = make(chan struct{})
// Start to monitor the error status of transport.
go cc.transportMonitor()
return cc, nil
}
// ClientConn represents a client connection to an RPC service.
type ClientConn struct {
target string
authority string
dopts dialOptions
shutdownChan chan struct{}
mu sync.Mutex
// ready is closed and becomes nil when a new transport is up or failed
// due to timeout.
ready chan struct{}
// Indicates the ClientConn is under destruction.
closing bool
// Every time a new transport is created, this is incremented by 1. Used
// to avoid trying to recreate a transport while the new one is already
// under construction.
transportSeq int
transport transport.ClientTransport
}
func (cc *ClientConn) resetTransport(closeTransport bool) error {
var retries int
start := time.Now()
for {
cc.mu.Lock()
t := cc.transport
ts := cc.transportSeq
// Avoid wait() picking up a dying transport unnecessarily.
cc.transportSeq = 0
if cc.closing {
cc.mu.Unlock()
return ErrClientConnClosing
}
cc.mu.Unlock()
if closeTransport {
t.Close()
}
// Adjust timeout for the current try.
copts := cc.dopts.copts
if copts.Timeout < 0 {
cc.Close()
return ErrClientConnTimeout
}
if copts.Timeout > 0 {
copts.Timeout -= time.Since(start)
if copts.Timeout <= 0 {
cc.Close()
return ErrClientConnTimeout
}
}
newTransport, err := transport.NewClientTransport(cc.target, &copts)
if err != nil {
sleepTime := backoff(retries)
// Fail early before falling into sleep.
if cc.dopts.copts.Timeout > 0 && cc.dopts.copts.Timeout < sleepTime+time.Since(start) {
cc.Close()
return ErrClientConnTimeout
}
closeTransport = false
time.Sleep(sleepTime)
retries++
grpclog.Printf("grpc: ClientConn.resetTransport failed to create client transport: %v; Reconnecting to %q", err, cc.target)
continue
}
cc.mu.Lock()
if cc.closing {
// cc.Close() has been invoked.
cc.mu.Unlock()
newTransport.Close()
return ErrClientConnClosing
}
cc.transport = newTransport
cc.transportSeq = ts + 1
if cc.ready != nil {
close(cc.ready)
cc.ready = nil
}
cc.mu.Unlock()
return nil
}
}
// Run in a goroutine to track the error in transport and create the
// new transport if an error happens. It returns when the channel is closing.
func (cc *ClientConn) transportMonitor() {
for {
select {
// shutdownChan is needed to detect the channel teardown when
// the ClientConn is idle (i.e., no RPC in flight).
case <-cc.shutdownChan:
return
case <-cc.transport.Error():
if err := cc.resetTransport(true); err != nil {
// The channel is closing.
grpclog.Printf("grpc: ClientConn.transportMonitor exits due to: %v", err)
return
}
continue
}
}
}
// When wait returns, either the new transport is up or ClientConn is
// closing. Used to avoid working on a dying transport. It updates and
// returns the transport and its version when there is no error.
func (cc *ClientConn) wait(ctx context.Context, ts int) (transport.ClientTransport, int, error) {
for {
cc.mu.Lock()
switch {
case cc.closing:
cc.mu.Unlock()
return nil, 0, ErrClientConnClosing
case ts < cc.transportSeq:
// Worked on a dying transport. Try the new one immediately.
defer cc.mu.Unlock()
return cc.transport, cc.transportSeq, nil
default:
ready := cc.ready
if ready == nil {
ready = make(chan struct{})
cc.ready = ready
}
cc.mu.Unlock()
select {
case <-ctx.Done():
return nil, 0, transport.ContextErr(ctx.Err())
// Wait until the new transport is ready or failed.
case <-ready:
}
}
}
}
// Close starts to tear down the ClientConn. Returns ErrClientConnClosing if
// it has been closed (mostly due to dial time-out).
// TODO(zhaoq): Make this synchronous to avoid unbounded memory consumption in
// some edge cases (e.g., the caller opens and closes many ClientConn's in a
// tight loop.
func (cc *ClientConn) Close() error {
cc.mu.Lock()
defer cc.mu.Unlock()
if cc.closing {
return ErrClientConnClosing
}
cc.closing = true
if cc.ready != nil {
close(cc.ready)
cc.ready = nil
}
if cc.transport != nil {
cc.transport.Close()
}
if cc.shutdownChan != nil {
close(cc.shutdownChan)
}
return nil
}
================================================
FILE: vendor/google.golang.org/grpc/codegen.sh
================================================
#!/bin/bash
# This script serves as an example to demonstrate how to generate the gRPC-Go
# interface and the related messages from .proto file.
#
# It assumes the installation of i) Google proto buffer compiler at
# https://github.com/google/protobuf (after v2.6.1) and ii) the Go codegen
# plugin at https://github.com/golang/protobuf (after 2015-02-20). If you have
# not, please install them first.
#
# We recommend running this script at $GOPATH or $GOPATH/src.
#
# If this is not what you need, feel free to make your own scripts. Again, this
# script is for demonstration purpose.
#
proto=$1
protoc --go_out=plugins=grpc:. $proto
================================================
FILE: vendor/google.golang.org/grpc/codes/code_string.go
================================================
// generated by stringer -type=Code; DO NOT EDIT
package codes
import "fmt"
const _Code_name = "OKCanceledUnknownInvalidArgumentDeadlineExceededNotFoundAlreadyExistsPermissionDeniedResourceExhaustedFailedPreconditionAbortedOutOfRangeUnimplementedInternalUnavailableDataLossUnauthenticated"
var _Code_index = [...]uint8{0, 2, 10, 17, 32, 48, 56, 69, 85, 102, 120, 127, 137, 150, 158, 169, 177, 192}
func (i Code) String() string {
if i+1 >= Code(len(_Code_index)) {
return fmt.Sprintf("Code(%d)", i)
}
return _Code_name[_Code_index[i]:_Code_index[i+1]]
}
================================================
FILE: vendor/google.golang.org/grpc/codes/codes.go
================================================
/*
*
* Copyright 2014, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
// Package codes defines the canonical error codes used by gRPC. It is
// consistent across various languages.
package codes
// A Code is an unsigned 32-bit error code as defined in the gRPC spec.
type Code uint32
//go:generate stringer -type=Code
const (
// OK is returned on success.
OK Code = 0
// Canceled indicates the operation was cancelled (typically by the caller).
Canceled Code = 1
// Unknown error. An example of where this error may be returned is
// if a Status value received from another address space belongs to
// an error-space that is not known in this address space. Also
// errors raised by APIs that do not return enough error information
// may be converted to this error.
Unknown Code = 2
// InvalidArgument indicates client specified an invalid argument.
// Note that this differs from FailedPrecondition. It indicates arguments
// that are problematic regardless of the state of the system
// (e.g., a malformed file name).
InvalidArgument Code = 3
// DeadlineExceeded means operation expired before completion.
// For operations that change the state of the system, this error may be
// returned even if the operation has completed successfully. For
// example, a successful response from a server could have been delayed
// long enough for the deadline to expire.
DeadlineExceeded Code = 4
// NotFound means some requested entity (e.g., file or directory) was
// not found.
NotFound Code = 5
// AlreadyExists means an attempt to create an entity failed because one
// already exists.
AlreadyExists Code = 6
// PermissionDenied indicates the caller does not have permission to
// execute the specified operation. It must not be used for rejections
// caused by exhausting some resource (use ResourceExhausted
// instead for those errors). It must not be
// used if the caller cannot be identified (use Unauthenticated
// instead for those errors).
PermissionDenied Code = 7
// Unauthenticated indicates the request does not have valid
// authentication credentials for the operation.
Unauthenticated Code = 16
// ResourceExhausted indicates some resource has been exhausted, perhaps
// a per-user quota, or perhaps the entire file system is out of space.
ResourceExhausted Code = 8
// FailedPrecondition indicates operation was rejected because the
// system is not in a state required for the operation's execution.
// For example, directory to be deleted may be non-empty, an rmdir
// operation is applied to a non-directory, etc.
//
// A litmus test that may help a service implementor in deciding
// between FailedPrecondition, Aborted, and Unavailable:
// (a) Use Unavailable if the client can retry just the failing call.
// (b) Use Aborted if the client should retry at a higher-level
// (e.g., restarting a read-modify-write sequence).
// (c) Use FailedPrecondition if the client should not retry until
// the system state has been explicitly fixed. E.g., if an "rmdir"
// fails because the directory is non-empty, FailedPrecondition
// should be returned since the client should not retry unless
// they have first fixed up the directory by deleting files from it.
// (d) Use FailedPrecondition if the client performs conditional
// REST Get/Update/Delete on a resource and the resource on the
// server does not match the condition. E.g., conflicting
// read-modify-write on the same resource.
FailedPrecondition Code = 9
// Aborted indicates the operation was aborted, typically due to a
// concurrency issue like sequencer check failures, transaction aborts,
// etc.
//
// See litmus test above for deciding between FailedPrecondition,
// Aborted, and Unavailable.
Aborted Code = 10
// OutOfRange means operation was attempted past the valid range.
// E.g., seeking or reading past end of file.
//
// Unlike InvalidArgument, this error indicates a problem that may
// be fixed if the system state changes. For example, a 32-bit file
// system will generate InvalidArgument if asked to read at an
// offset that is not in the range [0,2^32-1], but it will generate
// OutOfRange if asked to read from an offset past the current
// file size.
//
// There is a fair bit of overlap between FailedPrecondition and
// OutOfRange. We recommend using OutOfRange (the more specific
// error) when it applies so that callers who are iterating through
// a space can easily look for an OutOfRange error to detect when
// they are done.
OutOfRange Code = 11
// Unimplemented indicates operation is not implemented or not
// supported/enabled in this service.
Unimplemented Code = 12
// Internal errors. Means some invariants expected by underlying
// system has been broken. If you see one of these errors,
// something is very broken.
Internal Code = 13
// Unavailable indicates the service is currently unavailable.
// This is a most likely a transient condition and may be corrected
// by retrying with a backoff.
//
// See litmus test above for deciding between FailedPrecondition,
// Aborted, and Unavailable.
Unavailable Code = 14
// DataLoss indicates unrecoverable data loss or corruption.
DataLoss Code = 15
)
================================================
FILE: vendor/google.golang.org/grpc/credentials/credentials.go
================================================
/*
*
* Copyright 2014, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
// Package credentials implements various credentials supported by gRPC library,
// which encapsulate all the state needed by a client to authenticate with a
// server and make various assertions, e.g., about the client's identity, role,
// or whether it is authorized to make a particular call.
package credentials
import (
"crypto/tls"
"crypto/x509"
"fmt"
"io/ioutil"
"net"
"strings"
"time"
"golang.org/x/net/context"
"golang.org/x/oauth2"
"golang.org/x/oauth2/google"
"golang.org/x/oauth2/jwt"
)
var (
// alpnProtoStr are the specified application level protocols for gRPC.
alpnProtoStr = []string{"h2", "h2-14", "h2-15", "h2-16"}
)
// Credentials defines the common interface all supported credentials must
// implement.
type Credentials interface {
// GetRequestMetadata gets the current request metadata, refreshing
// tokens if required. This should be called by the transport layer on
// each request, and the data should be populated in headers or other
// context. When supported by the underlying implementation, ctx can
// be used for timeout and cancellation.
// TODO(zhaoq): Define the set of the qualified keys instead of leaving
// it as an arbitrary string.
GetRequestMetadata(ctx context.Context) (map[string]string, error)
}
// ProtocolInfo provides information regarding the gRPC wire protocol version,
// security protocol, security protocol version in use, etc.
type ProtocolInfo struct {
// ProtocolVersion is the gRPC wire protocol version.
ProtocolVersion string
// SecurityProtocol is the security protocol in use.
SecurityProtocol string
// SecurityVersion is the security protocol version.
SecurityVersion string
}
// TransportAuthenticator defines the common interface for all the live gRPC wire
// protocols and supported transport security protocols (e.g., TLS, SSL).
type TransportAuthenticator interface {
// ClientHandshake does the authentication handshake specified by the corresponding
// authentication protocol on rawConn for clients.
ClientHandshake(addr string, rawConn net.Conn, timeout time.Duration) (net.Conn, error)
// ServerHandshake does the authentication handshake for servers.
ServerHandshake(rawConn net.Conn) (net.Conn, error)
// Info provides the ProtocolInfo of this TransportAuthenticator.
Info() ProtocolInfo
Credentials
}
// tlsCreds is the credentials required for authenticating a connection using TLS.
type tlsCreds struct {
// TLS configuration
config tls.Config
}
func (c *tlsCreds) Info() ProtocolInfo {
return ProtocolInfo{
SecurityProtocol: "tls",
SecurityVersion: "1.2",
}
}
// GetRequestMetadata returns nil, nil since TLS credentials does not have
// metadata.
func (c *tlsCreds) GetRequestMetadata(ctx context.Context) (map[string]string, error) {
return nil, nil
}
type timeoutError struct{}
func (timeoutError) Error() string { return "credentials: Dial timed out" }
func (timeoutError) Timeout() bool { return true }
func (timeoutError) Temporary() bool { return true }
func (c *tlsCreds) ClientHandshake(addr string, rawConn net.Conn, timeout time.Duration) (_ net.Conn, err error) {
// borrow some code from tls.DialWithDialer
var errChannel chan error
if timeout != 0 {
errChannel = make(chan error, 2)
time.AfterFunc(timeout, func() {
errChannel <- timeoutError{}
})
}
if c.config.ServerName == "" {
colonPos := strings.LastIndex(addr, ":")
if colonPos == -1 {
colonPos = len(addr)
}
c.config.ServerName = addr[:colonPos]
}
conn := tls.Client(rawConn, &c.config)
if timeout == 0 {
err = conn.Handshake()
} else {
go func() {
errChannel <- conn.Handshake()
}()
err = <-errChannel
}
if err != nil {
rawConn.Close()
return nil, err
}
return conn, nil
}
func (c *tlsCreds) ServerHandshake(rawConn net.Conn) (net.Conn, error) {
conn := tls.Server(rawConn, &c.config)
if err := conn.Handshake(); err != nil {
rawConn.Close()
return nil, err
}
return conn, nil
}
// NewTLS uses c to construct a TransportAuthenticator based on TLS.
func NewTLS(c *tls.Config) TransportAuthenticator {
tc := &tlsCreds{*c}
tc.config.NextProtos = alpnProtoStr
return tc
}
// NewClientTLSFromCert constructs a TLS from the input certificate for client.
func NewClientTLSFromCert(cp *x509.CertPool, serverName string) TransportAuthenticator {
return NewTLS(&tls.Config{ServerName: serverName, RootCAs: cp})
}
// NewClientTLSFromFile constructs a TLS from the input certificate file for client.
func NewClientTLSFromFile(certFile, serverName string) (TransportAuthenticator, error) {
b, err := ioutil.ReadFile(certFile)
if err != nil {
return nil, err
}
cp := x509.NewCertPool()
if !cp.AppendCertsFromPEM(b) {
return nil, fmt.Errorf("credentials: failed to append certificates")
}
return NewTLS(&tls.Config{ServerName: serverName, RootCAs: cp}), nil
}
// NewServerTLSFromCert constructs a TLS from the input certificate for server.
func NewServerTLSFromCert(cert *tls.Certificate) TransportAuthenticator {
return NewTLS(&tls.Config{Certificates: []tls.Certificate{*cert}})
}
// NewServerTLSFromFile constructs a TLS from the input certificate file and key
// file for server.
func NewServerTLSFromFile(certFile, keyFile string) (TransportAuthenticator, error) {
cert, err := tls.LoadX509KeyPair(certFile, keyFile)
if err != nil {
return nil, err
}
return NewTLS(&tls.Config{Certificates: []tls.Certificate{cert}}), nil
}
// TokenSource supplies credentials from an oauth2.TokenSource.
type TokenSource struct {
oauth2.TokenSource
}
// GetRequestMetadata gets the request metadata as a map from a TokenSource.
func (ts TokenSource) GetRequestMetadata(ctx context.Context) (map[string]string, error) {
token, err := ts.Token()
if err != nil {
return nil, err
}
return map[string]string{
"authorization": token.TokenType + " " + token.AccessToken,
}, nil
}
// NewComputeEngine constructs the credentials that fetches access tokens from
// Google Compute Engine (GCE)'s metadata server. It is only valid to use this
// if your program is running on a GCE instance.
// TODO(dsymonds): Deprecate and remove this.
func NewComputeEngine() Credentials {
return TokenSource{google.ComputeTokenSource("")}
}
// serviceAccount represents credentials via JWT signing key.
type serviceAccount struct {
config *jwt.Config
}
func (s serviceAccount) GetRequestMetadata(ctx context.Context) (map[string]string, error) {
token, err := s.config.TokenSource(ctx).Token()
if err != nil {
return nil, err
}
return map[string]string{
"authorization": token.TokenType + " " + token.AccessToken,
}, nil
}
// NewServiceAccountFromKey constructs the credentials using the JSON key slice
// from a Google Developers service account.
func NewServiceAccountFromKey(jsonKey []byte, scope ...string) (Credentials, error) {
config, err := google.JWTConfigFromJSON(jsonKey, scope...)
if err != nil {
return nil, err
}
return serviceAccount{config: config}, nil
}
// NewServiceAccountFromFile constructs the credentials using the JSON key file
// of a Google Developers service account.
func NewServiceAccountFromFile(keyFile string, scope ...string) (Credentials, error) {
jsonKey, err := ioutil.ReadFile(keyFile)
if err != nil {
return nil, fmt.Errorf("credentials: failed to read the service account key file: %v", err)
}
return NewServiceAccountFromKey(jsonKey, scope...)
}
// NewApplicationDefault returns "Application Default Credentials". For more
// detail, see https://developers.google.com/accounts/docs/application-default-credentials.
func NewApplicationDefault(ctx context.Context, scope ...string) (Credentials, error) {
t, err := google.DefaultTokenSource(ctx, scope...)
if err != nil {
return nil, err
}
return TokenSource{t}, nil
}
================================================
FILE: vendor/google.golang.org/grpc/doc.go
================================================
/*
Package grpc implements an RPC system called gRPC.
See https://github.com/grpc/grpc for more information about gRPC.
*/
package grpc
================================================
FILE: vendor/google.golang.org/grpc/examples/route_guide/README.md
================================================
# Description
The route guide server and client demonstrate how to use grpc go libraries to
perform unary, client streaming, server streaming and full duplex RPCs.
Please refer to [Getting Started Guide for Go] (https://github.com/grpc/grpc-common/blob/master/go/gotutorial.md) for more information.
See the definition of the route guide service in proto/route_guide.proto.
# Run the sample code
To compile and run the server, assuming you are in the root of the route_guide
folder, i.e., .../examples/route_guide/, simply:
```sh
$ go run server/server.go
```
Likewise, to run the client:
```sh
$ go run client/client.go
```
# Optional command line flags
The server and client both take optional command line flags. For example, the
client and server run without TLS by default. To enable TLS:
```sh
$ go run server/server.go -tls=true
```
and
```sh
$ go run client/client.go -tls=true
```
================================================
FILE: vendor/google.golang.org/grpc/examples/route_guide/client/client.go
================================================
/*
*
* Copyright 2015, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
// Package main implements a simple gRPC client that demonstrates how to use gRPC-Go libraries
// to perform unary, client streaming, server streaming and full duplex RPCs.
//
// It interacts with the route guide service whose definition can be found in proto/route_guide.proto.
package main
import (
"flag"
"io"
"math/rand"
"time"
"golang.org/x/net/context"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials"
pb "google.golang.org/grpc/examples/route_guide/proto"
"google.golang.org/grpc/grpclog"
)
var (
tls = flag.Bool("tls", false, "Connection uses TLS if true, else plain TCP")
caFile = flag.String("ca_file", "testdata/ca.pem", "The file containning the CA root cert file")
serverAddr = flag.String("server_addr", "127.0.0.1:10000", "The server address in the format of host:port")
serverHostOverride = flag.String("server_host_override", "x.test.youtube.com", "The server name use to verify the hostname returned by TLS handshake")
)
// printFeature gets the feature for the given point.
func printFeature(client pb.RouteGuideClient, point *pb.Point) {
grpclog.Printf("Getting feature for point (%d, %d)", point.Latitude, point.Longitude)
feature, err := client.GetFeature(context.Background(), point)
if err != nil {
grpclog.Fatalf("%v.GetFeatures(_) = _, %v: ", client, err)
}
grpclog.Println(feature)
}
// printFeatures lists all the features within the given bounding Rectangle.
func printFeatures(client pb.RouteGuideClient, rect *pb.Rectangle) {
grpclog.Printf("Looking for features within %v", rect)
stream, err := client.ListFeatures(context.Background(), rect)
if err != nil {
grpclog.Fatalf("%v.ListFeatures(_) = _, %v", client, err)
}
for {
feature, err := stream.Recv()
if err == io.EOF {
break
}
if err != nil {
grpclog.Fatalf("%v.ListFeatures(_) = _, %v", client, err)
}
grpclog.Println(feature)
}
}
// runRecordRoute sends a sequence of points to server and expects to get a RouteSummary from server.
func runRecordRoute(client pb.RouteGuideClient) {
// Create a random number of random points
r := rand.New(rand.NewSource(time.Now().UnixNano()))
pointCount := int(r.Int31n(100)) + 2 // Traverse at least two points
var points []*pb.Point
for i := 0; i < pointCount; i++ {
points = append(points, randomPoint(r))
}
grpclog.Printf("Traversing %d points.", len(points))
stream, err := client.RecordRoute(context.Background())
if err != nil {
grpclog.Fatalf("%v.RecordRoute(_) = _, %v", client, err)
}
for _, point := range points {
if err := stream.Send(point); err != nil {
grpclog.Fatalf("%v.Send(%v) = %v", stream, point, err)
}
}
reply, err := stream.CloseAndRecv()
if err != nil {
grpclog.Fatalf("%v.CloseAndRecv() got error %v, want %v", stream, err, nil)
}
grpclog.Printf("Route summary: %v", reply)
}
// runRouteChat receives a sequence of route notes, while sending notes for various locations.
func runRouteChat(client pb.RouteGuideClient) {
notes := []*pb.RouteNote{
{&pb.Point{0, 1}, "First message"},
{&pb.Point{0, 2}, "Second message"},
{&pb.Point{0, 3}, "Third message"},
{&pb.Point{0, 1}, "Fourth message"},
{&pb.Point{0, 2}, "Fifth message"},
{&pb.Point{0, 3}, "Sixth message"},
}
stream, err := client.RouteChat(context.Background())
if err != nil {
grpclog.Fatalf("%v.RouteChat(_) = _, %v", client, err)
}
waitc := make(chan struct{})
go func() {
for {
in, err := stream.Recv()
if err == io.EOF {
// read done.
close(waitc)
return
}
if err != nil {
grpclog.Fatalf("Failed to receive a note : %v", err)
}
grpclog.Printf("Got message %s at point(%d, %d)", in.Message, in.Location.Latitude, in.Location.Longitude)
}
}()
for _, note := range notes {
if err := stream.Send(note); err != nil {
grpclog.Fatalf("Failed to send a note: %v", err)
}
}
stream.CloseSend()
<-waitc
}
func randomPoint(r *rand.Rand) *pb.Point {
lat := (r.Int31n(180) - 90) * 1e7
long := (r.Int31n(360) - 180) * 1e7
return &pb.Point{lat, long}
}
func main() {
flag.Parse()
var opts []grpc.DialOption
if *tls {
var sn string
if *serverHostOverride != "" {
sn = *serverHostOverride
}
var creds credentials.TransportAuthenticator
if *caFile != "" {
var err error
creds, err = credentials.NewClientTLSFromFile(*caFile, sn)
if err != nil {
grpclog.Fatalf("Failed to create TLS credentials %v", err)
}
} else {
creds = credentials.NewClientTLSFromCert(nil, sn)
}
opts = append(opts, grpc.WithTransportCredentials(creds))
}
conn, err := grpc.Dial(*serverAddr, opts...)
if err != nil {
grpclog.Fatalf("fail to dial: %v", err)
}
defer conn.Close()
client := pb.NewRouteGuideClient(conn)
// Looking for a valid feature
printFeature(client, &pb.Point{409146138, -746188906})
// Feature missing.
printFeature(client, &pb.Point{0, 0})
// Looking for features between 40, -75 and 42, -73.
printFeatures(client, &pb.Rectangle{&pb.Point{400000000, -750000000}, &pb.Point{420000000, -730000000}})
// RecordRoute
runRecordRoute(client)
// RouteChat
runRouteChat(client)
}
================================================
FILE: vendor/google.golang.org/grpc/examples/route_guide/proto/route_guide.pb.go
================================================
// Code generated by protoc-gen-go.
// source: route_guide.proto
// DO NOT EDIT!
/*
Package proto is a generated protocol buffer package.
It is generated from these files:
route_guide.proto
It has these top-level messages:
Point
Rectangle
Feature
RouteNote
RouteSummary
*/
package proto
import proto1 "github.com/golang/protobuf/proto"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto1.Marshal
// Points are represented as latitude-longitude pairs in the E7 representation
// (degrees multiplied by 10**7 and rounded to the nearest integer).
// Latitudes should be in the range +/- 90 degrees and longitude should be in
// the range +/- 180 degrees (inclusive).
type Point struct {
Latitude int32 `protobuf:"varint,1,opt,name=latitude" json:"latitude,omitempty"`
Longitude int32 `protobuf:"varint,2,opt,name=longitude" json:"longitude,omitempty"`
}
func (m *Point) Reset() { *m = Point{} }
func (m *Point) String() string { return proto1.CompactTextString(m) }
func (*Point) ProtoMessage() {}
// A latitude-longitude rectangle, represented as two diagonally opposite
// points "lo" and "hi".
type Rectangle struct {
// One corner of the rectangle.
Lo *Point `protobuf:"bytes,1,opt,name=lo" json:"lo,omitempty"`
// The other corner of the rectangle.
Hi *Point `protobuf:"bytes,2,opt,name=hi" json:"hi,omitempty"`
}
func (m *Rectangle) Reset() { *m = Rectangle{} }
func (m *Rectangle) String() string { return proto1.CompactTextString(m) }
func (*Rectangle) ProtoMessage() {}
func (m *Rectangle) GetLo() *Point {
if m != nil {
return m.Lo
}
return nil
}
func (m *Rectangle) GetHi() *Point {
if m != nil {
return m.Hi
}
return nil
}
// A feature names something at a given point.
//
// If a feature could not be named, the name is empty.
type Feature struct {
// The name of the feature.
Name string `protobuf:"bytes,1,opt,name=name" json:"name,omitempty"`
// The point where the feature is detected.
Location *Point `protobuf:"bytes,2,opt,name=location" json:"location,omitempty"`
}
func (m *Feature) Reset() { *m = Feature{} }
func (m *Feature) String() string { return proto1.CompactTextString(m) }
func (*Feature) ProtoMessage() {}
func (m *Feature) GetLocation() *Point {
if m != nil {
return m.Location
}
return nil
}
// A RouteNote is a message sent while at a given point.
type RouteNote struct {
// The location from which the message is sent.
Location *Point `protobuf:"bytes,1,opt,name=location" json:"location,omitempty"`
// The message to be sent.
Message string `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
}
func (m *RouteNote) Reset() { *m = RouteNote{} }
func (m *RouteNote) String() string { return proto1.CompactTextString(m) }
func (*RouteNote) ProtoMessage() {}
func (m *RouteNote) GetLocation() *Point {
if m != nil {
return m.Location
}
return nil
}
// A RouteSummary is received in response to a RecordRoute rpc.
//
// It contains the number of individual points received, the number of
// detected features, and the total distance covered as the cumulative sum of
// the distance between each point.
type RouteSummary struct {
// The number of points received.
PointCount int32 `protobuf:"varint,1,opt,name=point_count" json:"point_count,omitempty"`
// The number of known features passed while traversing the route.
FeatureCount int32 `protobuf:"varint,2,opt,name=feature_count" json:"feature_count,omitempty"`
// The distance covered in metres.
Distance int32 `protobuf:"varint,3,opt,name=distance" json:"distance,omitempty"`
// The duration of the traversal in seconds.
ElapsedTime int32 `protobuf:"varint,4,opt,name=elapsed_time" json:"elapsed_time,omitempty"`
}
func (m *RouteSummary) Reset() { *m = RouteSummary{} }
func (m *RouteSummary) String() string { return proto1.CompactTextString(m) }
func (*RouteSummary) ProtoMessage() {}
func init() {
}
// Client API for RouteGuide service
type RouteGuideClient interface {
// A simple RPC.
//
// Obtains the feature at a given position.
//
// If no feature is found for the given point, a feature with an empty name
// should be returned.
GetFeature(ctx context.Context, in *Point, opts ...grpc.CallOption) (*Feature, error)
// A server-to-client streaming RPC.
//
// Obtains the Features available within the given Rectangle. Results are
// streamed rather than returned at once (e.g. in a response message with a
// repeated field), as the rectangle may cover a large area and contain a
// huge number of features.
ListFeatures(ctx context.Context, in *Rectangle, opts ...grpc.CallOption) (RouteGuide_ListFeaturesClient, error)
// A client-to-server streaming RPC.
//
// Accepts a stream of Points on a route being traversed, returning a
// RouteSummary when traversal is completed.
RecordRoute(ctx context.Context, opts ...grpc.CallOption) (RouteGuide_RecordRouteClient, error)
// A Bidirectional streaming RPC.
//
// Accepts a stream of RouteNotes sent while a route is being traversed,
// while receiving other RouteNotes (e.g. from other users).
RouteChat(ctx context.Context, opts ...grpc.CallOption) (RouteGuide_RouteChatClient, error)
}
type routeGuideClient struct {
cc *grpc.ClientConn
}
func NewRouteGuideClient(cc *grpc.ClientConn) RouteGuideClient {
return &routeGuideClient{cc}
}
func (c *routeGuideClient) GetFeature(ctx context.Context, in *Point, opts ...grpc.CallOption) (*Feature, error) {
out := new(Feature)
err := grpc.Invoke(ctx, "/proto.RouteGuide/GetFeature", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *routeGuideClient) ListFeatures(ctx context.Context, in *Rectangle, opts ...grpc.CallOption) (RouteGuide_ListFeaturesClient, error) {
stream, err := grpc.NewClientStream(ctx, &_RouteGuide_serviceDesc.Streams[0], c.cc, "/proto.RouteGuide/ListFeatures", opts...)
if err != nil {
return nil, err
}
x := &routeGuideListFeaturesClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type RouteGuide_ListFeaturesClient interface {
Recv() (*Feature, error)
grpc.ClientStream
}
type routeGuideListFeaturesClient struct {
grpc.ClientStream
}
func (x *routeGuideListFeaturesClient) Recv() (*Feature, error) {
m := new(Feature)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *routeGuideClient) RecordRoute(ctx context.Context, opts ...grpc.CallOption) (RouteGuide_RecordRouteClient, error) {
stream, err := grpc.NewClientStream(ctx, &_RouteGuide_serviceDesc.Streams[1], c.cc, "/proto.RouteGuide/RecordRoute", opts...)
if err != nil {
return nil, err
}
x := &routeGuideRecordRouteClient{stream}
return x, nil
}
type RouteGuide_RecordRouteClient interface {
Send(*Point) error
CloseAndRecv() (*RouteSummary, error)
grpc.ClientStream
}
type routeGuideRecordRouteClient struct {
grpc.ClientStream
}
func (x *routeGuideRecordRouteClient) Send(m *Point) error {
return x.ClientStream.SendMsg(m)
}
func (x *routeGuideRecordRouteClient) CloseAndRecv() (*RouteSummary, error) {
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
m := new(RouteSummary)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *routeGuideClient) RouteChat(ctx context.Context, opts ...grpc.CallOption) (RouteGuide_RouteChatClient, error) {
stream, err := grpc.NewClientStream(ctx, &_RouteGuide_serviceDesc.Streams[2], c.cc, "/proto.RouteGuide/RouteChat", opts...)
if err != nil {
return nil, err
}
x := &routeGuideRouteChatClient{stream}
return x, nil
}
type RouteGuide_RouteChatClient interface {
Send(*RouteNote) error
Recv() (*RouteNote, error)
grpc.ClientStream
}
type routeGuideRouteChatClient struct {
grpc.ClientStream
}
func (x *routeGuideRouteChatClient) Send(m *RouteNote) error {
return x.ClientStream.SendMsg(m)
}
func (x *routeGuideRouteChatClient) Recv() (*RouteNote, error) {
m := new(RouteNote)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
// Server API for RouteGuide service
type RouteGuideServer interface {
// A simple RPC.
//
// Obtains the feature at a given position.
//
// If no feature is found for the given point, a feature with an empty name
// should be returned.
GetFeature(context.Context, *Point) (*Feature, error)
// A server-to-client streaming RPC.
//
// Obtains the Features available within the given Rectangle. Results are
// streamed rather than returned at once (e.g. in a response message with a
// repeated field), as the rectangle may cover a large area and contain a
// huge number of features.
ListFeatures(*Rectangle, RouteGuide_ListFeaturesServer) error
// A client-to-server streaming RPC.
//
// Accepts a stream of Points on a route being traversed, returning a
// RouteSummary when traversal is completed.
RecordRoute(RouteGuide_RecordRouteServer) error
// A Bidirectional streaming RPC.
//
// Accepts a stream of RouteNotes sent while a route is being traversed,
// while receiving other RouteNotes (e.g. from other users).
RouteChat(RouteGuide_RouteChatServer) error
}
func RegisterRouteGuideServer(s *grpc.Server, srv RouteGuideServer) {
s.RegisterService(&_RouteGuide_serviceDesc, srv)
}
func _RouteGuide_GetFeature_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
in := new(Point)
if err := codec.Unmarshal(buf, in); err != nil {
return nil, err
}
out, err := srv.(RouteGuideServer).GetFeature(ctx, in)
if err != nil {
return nil, err
}
return out, nil
}
func _RouteGuide_ListFeatures_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(Rectangle)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(RouteGuideServer).ListFeatures(m, &routeGuideListFeaturesServer{stream})
}
type RouteGuide_ListFeaturesServer interface {
Send(*Feature) error
grpc.ServerStream
}
type routeGuideListFeaturesServer struct {
grpc.ServerStream
}
func (x *routeGuideListFeaturesServer) Send(m *Feature) error {
return x.ServerStream.SendMsg(m)
}
func _RouteGuide_RecordRoute_Handler(srv interface{}, stream grpc.ServerStream) error {
return srv.(RouteGuideServer).RecordRoute(&routeGuideRecordRouteServer{stream})
}
type RouteGuide_RecordRouteServer interface {
SendAndClose(*RouteSummary) error
Recv() (*Point, error)
grpc.ServerStream
}
type routeGuideRecordRouteServer struct {
grpc.ServerStream
}
func (x *routeGuideRecordRouteServer) SendAndClose(m *RouteSummary) error {
return x.ServerStream.SendMsg(m)
}
func (x *routeGuideRecordRouteServer) Recv() (*Point, error) {
m := new(Point)
if err := x.ServerStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func _RouteGuide_RouteChat_Handler(srv interface{}, stream grpc.ServerStream) error {
return srv.(RouteGuideServer).RouteChat(&routeGuideRouteChatServer{stream})
}
type RouteGuide_RouteChatServer interface {
Send(*RouteNote) error
Recv() (*RouteNote, error)
grpc.ServerStream
}
type routeGuideRouteChatServer struct {
grpc.ServerStream
}
func (x *routeGuideRouteChatServer) Send(m *RouteNote) error {
return x.ServerStream.SendMsg(m)
}
func (x *routeGuideRouteChatServer) Recv() (*RouteNote, error) {
m := new(RouteNote)
if err := x.ServerStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
var _RouteGuide_serviceDesc = grpc.ServiceDesc{
ServiceName: "proto.RouteGuide",
HandlerType: (*RouteGuideServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "GetFeature",
Handler: _RouteGuide_GetFeature_Handler,
},
},
Streams: []grpc.StreamDesc{
{
StreamName: "ListFeatures",
Handler: _RouteGuide_ListFeatures_Handler,
ServerStreams: true,
},
{
StreamName: "RecordRoute",
Handler: _RouteGuide_RecordRoute_Handler,
ClientStreams: true,
},
{
StreamName: "RouteChat",
Handler: _RouteGuide_RouteChat_Handler,
ServerStreams: true,
ClientStreams: true,
},
},
}
================================================
FILE: vendor/google.golang.org/grpc/examples/route_guide/proto/route_guide.proto
================================================
// Copyright 2015, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
syntax = "proto3";
package proto;
// Interface exported by the server.
service RouteGuide {
// A simple RPC.
//
// Obtains the feature at a given position.
//
// If no feature is found for the given point, a feature with an empty name
// should be returned.
rpc GetFeature(Point) returns (Feature) {}
// A server-to-client streaming RPC.
//
// Obtains the Features available within the given Rectangle. Results are
// streamed rather than returned at once (e.g. in a response message with a
// repeated field), as the rectangle may cover a large area and contain a
// huge number of features.
rpc ListFeatures(Rectangle) returns (stream Feature) {}
// A client-to-server streaming RPC.
//
// Accepts a stream of Points on a route being traversed, returning a
// RouteSummary when traversal is completed.
rpc RecordRoute(stream Point) returns (RouteSummary) {}
// A Bidirectional streaming RPC.
//
// Accepts a stream of RouteNotes sent while a route is being traversed,
// while receiving other RouteNotes (e.g. from other users).
rpc RouteChat(stream RouteNote) returns (stream RouteNote) {}
}
// Points are represented as latitude-longitude pairs in the E7 representation
// (degrees multiplied by 10**7 and rounded to the nearest integer).
// Latitudes should be in the range +/- 90 degrees and longitude should be in
// the range +/- 180 degrees (inclusive).
message Point {
int32 latitude = 1;
int32 longitude = 2;
}
// A latitude-longitude rectangle, represented as two diagonally opposite
// points "lo" and "hi".
message Rectangle {
// One corner of the rectangle.
Point lo = 1;
// The other corner of the rectangle.
Point hi = 2;
}
// A feature names something at a given point.
//
// If a feature could not be named, the name is empty.
message Feature {
// The name of the feature.
string name = 1;
// The point where the feature is detected.
Point location = 2;
}
// A RouteNote is a message sent while at a given point.
message RouteNote {
// The location from which the message is sent.
Point location = 1;
// The message to be sent.
string message = 2;
}
// A RouteSummary is received in response to a RecordRoute rpc.
//
// It contains the number of individual points received, the number of
// detected features, and the total distance covered as the cumulative sum of
// the distance between each point.
message RouteSummary {
// The number of points received.
int32 point_count = 1;
// The number of known features passed while traversing the route.
int32 feature_count = 2;
// The distance covered in metres.
int32 distance = 3;
// The duration of the traversal in seconds.
int32 elapsed_time = 4;
}
================================================
FILE: vendor/google.golang.org/grpc/examples/route_guide/server/server.go
================================================
/*
*
* Copyright 2015, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
// Package main implements a simple gRPC server that demonstrates how to use gRPC-Go libraries
// to perform unary, client streaming, server streaming and full duplex RPCs.
//
// It implements the route guide service whose definition can be found in proto/route_guide.proto.
package main
import (
"encoding/json"
"flag"
"fmt"
"io"
"io/ioutil"
"math"
"net"
"time"
"golang.org/x/net/context"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials"
"google.golang.org/grpc/grpclog"
proto "github.com/golang/protobuf/proto"
pb "google.golang.org/grpc/examples/route_guide/proto"
)
var (
tls = flag.Bool("tls", false, "Connection uses TLS if true, else plain TCP")
certFile = flag.String("cert_file", "testdata/server1.pem", "The TLS cert file")
keyFile = flag.String("key_file", "testdata/server1.key", "The TLS key file")
jsonDBFile = flag.String("json_db_file", "testdata/route_guide_db.json", "A json file containing a list of features")
port = flag.Int("port", 10000, "The server port")
)
type routeGuideServer struct {
savedFeatures []*pb.Feature
routeNotes map[string][]*pb.RouteNote
}
// GetFeature returns the feature at the given point.
func (s *routeGuideServer) GetFeature(ctx context.Context, point *pb.Point) (*pb.Feature, error) {
for _, feature := range s.savedFeatures {
if proto.Equal(feature.Location, point) {
return feature, nil
}
}
// No feature was found, return an unnamed feature
return &pb.Feature{"", point}, nil
}
// ListFeatures lists all features comtained within the given bounding Rectangle.
func (s *routeGuideServer) ListFeatures(rect *pb.Rectangle, stream pb.RouteGuide_ListFeaturesServer) error {
for _, feature := range s.savedFeatures {
if inRange(feature.Location, rect) {
if err := stream.Send(feature); err != nil {
return err
}
}
}
return nil
}
// RecordRoute records a route composited of a sequence of points.
//
// It gets a stream of points, and responds with statistics about the "trip":
// number of points, number of known features visited, total distance traveled, and
// total time spent.
func (s *routeGuideServer) RecordRoute(stream pb.RouteGuide_RecordRouteServer) error {
var pointCount, featureCount, distance int32
var lastPoint *pb.Point
startTime := time.Now()
for {
point, err := stream.Recv()
if err == io.EOF {
endTime := time.Now()
return stream.SendAndClose(&pb.RouteSummary{
PointCount: pointCount,
FeatureCount: featureCount,
Distance: distance,
ElapsedTime: int32(endTime.Sub(startTime).Seconds()),
})
}
if err != nil {
return err
}
pointCount++
for _, feature := range s.savedFeatures {
if proto.Equal(feature.Location, point) {
featureCount++
}
}
if lastPoint != nil {
distance += calcDistance(lastPoint, point)
}
lastPoint = point
}
}
// RouteChat receives a stream of message/location pairs, and responds with a stream of all
// previous messages at each of those locations.
func (s *routeGuideServer) RouteChat(stream pb.RouteGuide_RouteChatServer) error {
for {
in, err := stream.Recv()
if err == io.EOF {
return nil
}
if err != nil {
return err
}
key := serialize(in.Location)
if _, present := s.routeNotes[key]; !present {
s.routeNotes[key] = []*pb.RouteNote{in}
} else {
s.routeNotes[key] = append(s.routeNotes[key], in)
}
for _, note := range s.routeNotes[key] {
if err := stream.Send(note); err != nil {
return err
}
}
}
}
// loadFeatures loads features from a JSON file.
func (s *routeGuideServer) loadFeatures(filePath string) {
file, err := ioutil.ReadFile(filePath)
if err != nil {
grpclog.Fatalf("Failed to load default features: %v", err)
}
if err := json.Unmarshal(file, &s.savedFeatures); err != nil {
grpclog.Fatalf("Failed to load default features: %v", err)
}
}
func toRadians(num float64) float64 {
return num * math.Pi / float64(180)
}
// calcDistance calculates the distance between two points using the "haversine" formula.
// This code was taken from http://www.movable-type.co.uk/scripts/latlong.html.
func calcDistance(p1 *pb.Point, p2 *pb.Point) int32 {
const CordFactor float64 = 1e7
const R float64 = float64(6371000) // metres
lat1 := float64(p1.Latitude) / CordFactor
lat2 := float64(p2.Latitude) / CordFactor
lng1 := float64(p1.Longitude) / CordFactor
lng2 := float64(p2.Longitude) / CordFactor
φ1 := toRadians(lat1)
φ2 := toRadians(lat2)
Δφ := toRadians(lat2 - lat1)
Δλ := toRadians(lng2 - lng1)
a := math.Sin(Δφ/2)*math.Sin(Δφ/2) +
math.Cos(φ1)*math.Cos(φ2)*
math.Sin(Δλ/2)*math.Sin(Δλ/2)
c := 2 * math.Atan2(math.Sqrt(a), math.Sqrt(1-a))
distance := R * c
return int32(distance)
}
func inRange(point *pb.Point, rect *pb.Rectangle) bool {
left := math.Min(float64(rect.Lo.Longitude), float64(rect.Hi.Longitude))
right := math.Max(float64(rect.Lo.Longitude), float64(rect.Hi.Longitude))
top := math.Max(float64(rect.Lo.Latitude), float64(rect.Hi.Latitude))
bottom := math.Min(float64(rect.Lo.Latitude), float64(rect.Hi.Latitude))
if float64(point.Longitude) >= left &&
float64(point.Longitude) <= right &&
float64(point.Latitude) >= bottom &&
float64(point.Latitude) <= top {
return true
}
return false
}
func serialize(point *pb.Point) string {
return fmt.Sprintf("%d %d", point.Latitude, point.Longitude)
}
func newServer() *routeGuideServer {
s := new(routeGuideServer)
s.loadFeatures(*jsonDBFile)
s.routeNotes = make(map[string][]*pb.RouteNote)
return s
}
func main() {
flag.Parse()
lis, err := net.Listen("tcp", fmt.Sprintf(":%d", *port))
if err != nil {
grpclog.Fatalf("failed to listen: %v", err)
}
var opts []grpc.ServerOption
if *tls {
creds, err := credentials.NewServerTLSFromFile(*certFile, *keyFile)
if err != nil {
grpclog.Fatalf("Failed to generate credentials %v", err)
}
opts = []grpc.ServerOption{grpc.Creds(creds)}
}
grpcServer := grpc.NewServer(opts...)
pb.RegisterRouteGuideServer(grpcServer, newServer())
grpcServer.Serve(lis)
}
================================================
FILE: vendor/google.golang.org/grpc/grpc-auth-support.md
================================================
# Authentication
As outlined here gRPC supports a number of different mechanisms for asserting identity between an client and server. We'll present some code-samples here demonstrating how to provide TLS support encryption and identity assertions as well as passing OAuth2 tokens to services that support it.
# Enabling TLS on a gRPC client
```Go
conn, err := grpc.Dial(serverAddr, grpc.WithTransportCredentials(credentials.NewClientTLSFromCert(nil, ""))
```
# Enabling TLS on a gRPC server
```Go
creds, err := credentials.NewServerTLSFromFile(certFile, keyFile)
if err != nil {
log.Fatalf("Failed to generate credentials %v", err)
}
lis, err := net.Listen("tcp", ":0")
server := grpc.NewServer(grpc.Creds(creds))
...
server.Serve(lis)
```
# Authenticating with Google
## Google Compute Engine (GCE)
```Go
conn, err := grpc.Dial(serverAddr, grpc.WithTransportCredentials(credentials.NewClientTLSFromCert(nil, ""), grpc.WithPerRPCCredentials(credentials.NewComputeEngine())))
```
## JWT
```Go
jwtCreds, err := credentials.NewServiceAccountFromFile(*serviceAccountKeyFile, *oauthScope)
if err != nil {
log.Fatalf("Failed to create JWT credentials: %v", err)
}
conn, err := grpc.Dial(serverAddr, grpc.WithTransportCredentials(credentials.NewClientTLSFromCert(nil, ""), grpc.WithPerRPCCredentials(jwtCreds)))
```
================================================
FILE: vendor/google.golang.org/grpc/grpclog/logger.go
================================================
/*
*
* Copyright 2015, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/*
Package log defines logging for grpc.
*/
package grpclog
import (
"log"
"os"
"github.com/golang/glog"
)
var (
// GLogger is a Logger that uses glog. This is the default logger.
GLogger Logger = &glogger{}
// StdLogger is a Logger that uses golang's standard logger.
StdLogger Logger = log.New(os.Stderr, "", log.LstdFlags)
logger = GLogger
)
// Logger mimics golang's standard Logger as an interface.
type Logger interface {
Fatal(args ...interface{})
Fatalf(format string, args ...interface{})
Fatalln(args ...interface{})
Print(args ...interface{})
Printf(format string, args ...interface{})
Println(args ...interface{})
}
// SetLogger sets the logger that is used in grpc.
func SetLogger(l Logger) {
logger = l
}
// Fatal is equivalent to Print() followed by a call to os.Exit() with a non-zero exit code.
func Fatal(args ...interface{}) {
logger.Fatal(args...)
}
// Fatal is equivalent to Printf() followed by a call to os.Exit() with a non-zero exit code.
func Fatalf(format string, args ...interface{}) {
logger.Fatalf(format, args...)
}
// Fatal is equivalent to Println() followed by a call to os.Exit()) with a non-zero exit code.
func Fatalln(args ...interface{}) {
logger.Fatalln(args...)
}
// Print prints to the logger. Arguments are handled in the manner of fmt.Print.
func Print(args ...interface{}) {
logger.Print(args...)
}
// Printf prints to the logger. Arguments are handled in the manner of fmt.Printf.
func Printf(format string, args ...interface{}) {
logger.Printf(format, args...)
}
// Println prints to the logger. Arguments are handled in the manner of fmt.Println.
func Println(args ...interface{}) {
logger.Println(args...)
}
type glogger struct{}
func (g *glogger) Fatal(args ...interface{}) {
glog.Fatal(args...)
}
func (g *glogger) Fatalf(format string, args ...interface{}) {
glog.Fatalf(format, args...)
}
func (g *glogger) Fatalln(args ...interface{}) {
glog.Fatalln(args...)
}
func (g *glogger) Print(args ...interface{}) {
glog.Info(args...)
}
func (g *glogger) Printf(format string, args ...interface{}) {
glog.Infof(format, args...)
}
func (g *glogger) Println(args ...interface{}) {
glog.Infoln(args...)
}
================================================
FILE: vendor/google.golang.org/grpc/interop/client/client.go
================================================
/*
*
* Copyright 2014, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package main
import (
"flag"
"io"
"io/ioutil"
"net"
"strconv"
"strings"
"github.com/golang/protobuf/proto"
"golang.org/x/net/context"
"google.golang.org/grpc"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/credentials"
"google.golang.org/grpc/grpclog"
testpb "google.golang.org/grpc/interop/grpc_testing"
"google.golang.org/grpc/metadata"
)
var (
useTLS = flag.Bool("use_tls", false, "Connection uses TLS if true, else plain TCP")
caFile = flag.String("tls_ca_file", "testdata/ca.pem", "The file containning the CA root cert file")
serviceAccountKeyFile = flag.String("service_account_key_file", "", "Path to service account json key file")
oauthScope = flag.String("oauth_scope", "", "The scope for OAuth2 tokens")
defaultServiceAccount = flag.String("default_service_account", "", "Email of GCE default service account")
serverHost = flag.String("server_host", "127.0.0.1", "The server host name")
serverPort = flag.Int("server_port", 10000, "The server port number")
tlsServerName = flag.String("server_host_override", "x.test.youtube.com", "The server name use to verify the hostname returned by TLS handshake if it is not empty. Otherwise, --server_host is used.")
testCase = flag.String("test_case", "large_unary",
`Configure different test cases. Valid options are:
empty_unary : empty (zero bytes) request and response;
large_unary : single request and (large) response;
client_streaming : request streaming with single response;
server_streaming : single request with response streaming;
ping_pong : full-duplex streaming;
compute_engine_creds: large_unary with compute engine auth;
service_account_creds: large_unary with service account auth;
cancel_after_begin: cancellation after metadata has been sent but before payloads are sent;
cancel_after_first_response: cancellation after receiving 1st message from the server.`)
)
var (
reqSizes = []int{27182, 8, 1828, 45904}
respSizes = []int{31415, 9, 2653, 58979}
largeReqSize = 271828
largeRespSize = 314159
)
func newPayload(t testpb.PayloadType, size int) *testpb.Payload {
if size < 0 {
grpclog.Fatalf("Requested a response with invalid length %d", size)
}
body := make([]byte, size)
switch t {
case testpb.PayloadType_COMPRESSABLE:
case testpb.PayloadType_UNCOMPRESSABLE:
grpclog.Fatalf("PayloadType UNCOMPRESSABLE is not supported")
default:
grpclog.Fatalf("Unsupported payload type: %d", t)
}
return &testpb.Payload{
Type: t.Enum(),
Body: body,
}
}
func doEmptyUnaryCall(tc testpb.TestServiceClient) {
reply, err := tc.EmptyCall(context.Background(), &testpb.Empty{})
if err != nil {
grpclog.Fatal("/TestService/EmptyCall RPC failed: ", err)
}
if !proto.Equal(&testpb.Empty{}, reply) {
grpclog.Fatalf("/TestService/EmptyCall receives %v, want %v", reply, testpb.Empty{})
}
grpclog.Println("EmptyUnaryCall done")
}
func doLargeUnaryCall(tc testpb.TestServiceClient) {
pl := newPayload(testpb.PayloadType_COMPRESSABLE, largeReqSize)
req := &testpb.SimpleRequest{
ResponseType: testpb.PayloadType_COMPRESSABLE.Enum(),
ResponseSize: proto.Int32(int32(largeRespSize)),
Payload: pl,
}
reply, err := tc.UnaryCall(context.Background(), req)
if err != nil {
grpclog.Fatal("/TestService/UnaryCall RPC failed: ", err)
}
t := reply.GetPayload().GetType()
s := len(reply.GetPayload().GetBody())
if t != testpb.PayloadType_COMPRESSABLE || s != largeRespSize {
grpclog.Fatalf("Got the reply with type %d len %d; want %d, %d", t, s, testpb.PayloadType_COMPRESSABLE, largeRespSize)
}
grpclog.Println("LargeUnaryCall done")
}
func doClientStreaming(tc testpb.TestServiceClient) {
stream, err := tc.StreamingInputCall(context.Background())
if err != nil {
grpclog.Fatalf("%v.StreamingInputCall(_) = _, %v", tc, err)
}
var sum int
for _, s := range reqSizes {
pl := newPayload(testpb.PayloadType_COMPRESSABLE, s)
req := &testpb.StreamingInputCallRequest{
Payload: pl,
}
if err := stream.Send(req); err != nil {
grpclog.Fatalf("%v.Send(%v) = %v", stream, req, err)
}
sum += s
grpclog.Printf("Sent a request of size %d, aggregated size %d", s, sum)
}
reply, err := stream.CloseAndRecv()
if err != nil {
grpclog.Fatalf("%v.CloseAndRecv() got error %v, want %v", stream, err, nil)
}
if reply.GetAggregatedPayloadSize() != int32(sum) {
grpclog.Fatalf("%v.CloseAndRecv().GetAggregatePayloadSize() = %v; want %v", stream, reply.GetAggregatedPayloadSize(), sum)
}
grpclog.Println("ClientStreaming done")
}
func doServerStreaming(tc testpb.TestServiceClient) {
respParam := make([]*testpb.ResponseParameters, len(respSizes))
for i, s := range respSizes {
respParam[i] = &testpb.ResponseParameters{
Size: proto.Int32(int32(s)),
}
}
req := &testpb.StreamingOutputCallRequest{
ResponseType: testpb.PayloadType_COMPRESSABLE.Enum(),
ResponseParameters: respParam,
}
stream, err := tc.StreamingOutputCall(context.Background(), req)
if err != nil {
grpclog.Fatalf("%v.StreamingOutputCall(_) = _, %v", tc, err)
}
var rpcStatus error
var respCnt int
var index int
for {
reply, err := stream.Recv()
if err != nil {
rpcStatus = err
break
}
t := reply.GetPayload().GetType()
if t != testpb.PayloadType_COMPRESSABLE {
grpclog.Fatalf("Got the reply of type %d, want %d", t, testpb.PayloadType_COMPRESSABLE)
}
size := len(reply.GetPayload().GetBody())
if size != int(respSizes[index]) {
grpclog.Fatalf("Got reply body of length %d, want %d", size, respSizes[index])
}
index++
respCnt++
}
if rpcStatus != io.EOF {
grpclog.Fatalf("Failed to finish the server streaming rpc: %v", err)
}
if respCnt != len(respSizes) {
grpclog.Fatalf("Got %d reply, want %d", len(respSizes), respCnt)
}
grpclog.Println("ServerStreaming done")
}
func doPingPong(tc testpb.TestServiceClient) {
stream, err := tc.FullDuplexCall(context.Background())
if err != nil {
grpclog.Fatalf("%v.FullDuplexCall(_) = _, %v", tc, err)
}
var index int
for index < len(reqSizes) {
respParam := []*testpb.ResponseParameters{
{
Size: proto.Int32(int32(respSizes[index])),
},
}
pl := newPayload(testpb.PayloadType_COMPRESSABLE, reqSizes[index])
req := &testpb.StreamingOutputCallRequest{
ResponseType: testpb.PayloadType_COMPRESSABLE.Enum(),
ResponseParameters: respParam,
Payload: pl,
}
if err := stream.Send(req); err != nil {
grpclog.Fatalf("%v.Send(%v) = %v", stream, req, err)
}
reply, err := stream.Recv()
if err != nil {
grpclog.Fatalf("%v.Recv() = %v", stream, err)
}
t := reply.GetPayload().GetType()
if t != testpb.PayloadType_COMPRESSABLE {
grpclog.Fatalf("Got the reply of type %d, want %d", t, testpb.PayloadType_COMPRESSABLE)
}
size := len(reply.GetPayload().GetBody())
if size != int(respSizes[index]) {
grpclog.Fatalf("Got reply body of length %d, want %d", size, respSizes[index])
}
index++
}
if err := stream.CloseSend(); err != nil {
grpclog.Fatalf("%v.CloseSend() got %v, want %v", stream, err, nil)
}
if _, err := stream.Recv(); err != io.EOF {
grpclog.Fatalf("%v failed to complele the ping pong test: %v", stream, err)
}
grpclog.Println("Pingpong done")
}
func doComputeEngineCreds(tc testpb.TestServiceClient) {
pl := newPayload(testpb.PayloadType_COMPRESSABLE, largeReqSize)
req := &testpb.SimpleRequest{
ResponseType: testpb.PayloadType_COMPRESSABLE.Enum(),
ResponseSize: proto.Int32(int32(largeRespSize)),
Payload: pl,
FillUsername: proto.Bool(true),
FillOauthScope: proto.Bool(true),
}
reply, err := tc.UnaryCall(context.Background(), req)
if err != nil {
grpclog.Fatal("/TestService/UnaryCall RPC failed: ", err)
}
user := reply.GetUsername()
scope := reply.GetOauthScope()
if user != *defaultServiceAccount {
grpclog.Fatalf("Got user name %q, want %q.", user, *defaultServiceAccount)
}
if !strings.Contains(*oauthScope, scope) {
grpclog.Fatalf("Got OAuth scope %q which is NOT a substring of %q.", scope, *oauthScope)
}
grpclog.Println("ComputeEngineCreds done")
}
func getServiceAccountJSONKey() []byte {
jsonKey, err := ioutil.ReadFile(*serviceAccountKeyFile)
if err != nil {
grpclog.Fatalf("Failed to read the service account key file: %v", err)
}
return jsonKey
}
func doServiceAccountCreds(tc testpb.TestServiceClient) {
pl := newPayload(testpb.PayloadType_COMPRESSABLE, largeReqSize)
req := &testpb.SimpleRequest{
ResponseType: testpb.PayloadType_COMPRESSABLE.Enum(),
ResponseSize: proto.Int32(int32(largeRespSize)),
Payload: pl,
FillUsername: proto.Bool(true),
FillOauthScope: proto.Bool(true),
}
reply, err := tc.UnaryCall(context.Background(), req)
if err != nil {
grpclog.Fatal("/TestService/UnaryCall RPC failed: ", err)
}
jsonKey := getServiceAccountJSONKey()
user := reply.GetUsername()
scope := reply.GetOauthScope()
if !strings.Contains(string(jsonKey), user) {
grpclog.Fatalf("Got user name %q which is NOT a substring of %q.", user, jsonKey)
}
if !strings.Contains(*oauthScope, scope) {
grpclog.Fatalf("Got OAuth scope %q which is NOT a substring of %q.", scope, *oauthScope)
}
grpclog.Println("ServiceAccountCreds done")
}
var (
testMetadata = metadata.MD{
"key1": "value1",
"key2": "value2",
}
)
func doCancelAfterBegin(tc testpb.TestServiceClient) {
ctx, cancel := context.WithCancel(metadata.NewContext(context.Background(), testMetadata))
stream, err := tc.StreamingInputCall(ctx)
if err != nil {
grpclog.Fatalf("%v.StreamingInputCall(_) = _, %v", tc, err)
}
cancel()
_, err = stream.CloseAndRecv()
if grpc.Code(err) != codes.Canceled {
grpclog.Fatalf("%v.CloseAndRecv() got error code %d, want %d", stream, grpc.Code(err), codes.Canceled)
}
grpclog.Println("CancelAfterBegin done")
}
func doCancelAfterFirstResponse(tc testpb.TestServiceClient) {
ctx, cancel := context.WithCancel(context.Background())
stream, err := tc.FullDuplexCall(ctx)
if err != nil {
grpclog.Fatalf("%v.FullDuplexCall(_) = _, %v", tc, err)
}
respParam := []*testpb.ResponseParameters{
{
Size: proto.Int32(31415),
},
}
pl := newPayload(testpb.PayloadType_COMPRESSABLE, 27182)
req := &testpb.StreamingOutputCallRequest{
ResponseType: testpb.PayloadType_COMPRESSABLE.Enum(),
ResponseParameters: respParam,
Payload: pl,
}
if err := stream.Send(req); err != nil {
grpclog.Fatalf("%v.Send(%v) = %v", stream, req, err)
}
if _, err := stream.Recv(); err != nil {
grpclog.Fatalf("%v.Recv() = %v", stream, err)
}
cancel()
if _, err := stream.Recv(); grpc.Code(err) != codes.Canceled {
grpclog.Fatalf("%v compleled with error code %d, want %d", stream, grpc.Code(err), codes.Canceled)
}
grpclog.Println("CancelAfterFirstResponse done")
}
func main() {
flag.Parse()
serverAddr := net.JoinHostPort(*serverHost, strconv.Itoa(*serverPort))
var opts []grpc.DialOption
if *useTLS {
var sn string
if *tlsServerName != "" {
sn = *tlsServerName
}
var creds credentials.TransportAuthenticator
if *caFile != "" {
var err error
creds, err = credentials.NewClientTLSFromFile(*caFile, sn)
if err != nil {
grpclog.Fatalf("Failed to create TLS credentials %v", err)
}
} else {
creds = credentials.NewClientTLSFromCert(nil, sn)
}
opts = append(opts, grpc.WithTransportCredentials(creds))
if *testCase == "compute_engine_creds" {
opts = append(opts, grpc.WithPerRPCCredentials(credentials.NewComputeEngine()))
} else if *testCase == "service_account_creds" {
jwtCreds, err := credentials.NewServiceAccountFromFile(*serviceAccountKeyFile, *oauthScope)
if err != nil {
grpclog.Fatalf("Failed to create JWT credentials: %v", err)
}
opts = append(opts, grpc.WithPerRPCCredentials(jwtCreds))
}
}
conn, err := grpc.Dial(serverAddr, opts...)
if err != nil {
grpclog.Fatalf("Fail to dial: %v", err)
}
defer conn.Close()
tc := testpb.NewTestServiceClient(conn)
switch *testCase {
case "empty_unary":
doEmptyUnaryCall(tc)
case "large_unary":
doLargeUnaryCall(tc)
case "client_streaming":
doClientStreaming(tc)
case "server_streaming":
doServerStreaming(tc)
case "ping_pong":
doPingPong(tc)
case "compute_engine_creds":
if !*useTLS {
grpclog.Fatalf("TLS is not enabled. TLS is required to execute compute_engine_creds test case.")
}
doComputeEngineCreds(tc)
case "service_account_creds":
if !*useTLS {
grpclog.Fatalf("TLS is not enabled. TLS is required to execute service_account_creds test case.")
}
doServiceAccountCreds(tc)
case "cancel_after_begin":
doCancelAfterBegin(tc)
case "cancel_after_first_response":
doCancelAfterFirstResponse(tc)
default:
grpclog.Fatal("Unsupported test case: ", *testCase)
}
}
================================================
FILE: vendor/google.golang.org/grpc/interop/grpc_testing/test.pb.go
================================================
// Code generated by protoc-gen-go.
// source: src/google.golang.org/grpc/test/grpc_testing/test.proto
// DO NOT EDIT!
/*
Package grpc_testing is a generated protocol buffer package.
It is generated from these files:
src/google.golang.org/grpc/test/grpc_testing/test.proto
It has these top-level messages:
Empty
Payload
SimpleRequest
SimpleResponse
StreamingInputCallRequest
StreamingInputCallResponse
ResponseParameters
StreamingOutputCallRequest
StreamingOutputCallResponse
*/
package grpc_testing
import proto "github.com/golang/protobuf/proto"
import math "math"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = math.Inf
// The type of payload that should be returned.
type PayloadType int32
const (
// Compressable text format.
PayloadType_COMPRESSABLE PayloadType = 0
// Uncompressable binary format.
PayloadType_UNCOMPRESSABLE PayloadType = 1
// Randomly chosen from all other formats defined in this enum.
PayloadType_RANDOM PayloadType = 2
)
var PayloadType_name = map[int32]string{
0: "COMPRESSABLE",
1: "UNCOMPRESSABLE",
2: "RANDOM",
}
var PayloadType_value = map[string]int32{
"COMPRESSABLE": 0,
"UNCOMPRESSABLE": 1,
"RANDOM": 2,
}
func (x PayloadType) Enum() *PayloadType {
p := new(PayloadType)
*p = x
return p
}
func (x PayloadType) String() string {
return proto.EnumName(PayloadType_name, int32(x))
}
func (x *PayloadType) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(PayloadType_value, data, "PayloadType")
if err != nil {
return err
}
*x = PayloadType(value)
return nil
}
type Empty struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *Empty) Reset() { *m = Empty{} }
func (m *Empty) String() string { return proto.CompactTextString(m) }
func (*Empty) ProtoMessage() {}
// A block of data, to simply increase gRPC message size.
type Payload struct {
// The type of data in body.
Type *PayloadType `protobuf:"varint,1,opt,name=type,enum=grpc.testing.PayloadType" json:"type,omitempty"`
// Primary contents of payload.
Body []byte `protobuf:"bytes,2,opt,name=body" json:"body,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Payload) Reset() { *m = Payload{} }
func (m *Payload) String() string { return proto.CompactTextString(m) }
func (*Payload) ProtoMessage() {}
func (m *Payload) GetType() PayloadType {
if m != nil && m.Type != nil {
return *m.Type
}
return PayloadType_COMPRESSABLE
}
func (m *Payload) GetBody() []byte {
if m != nil {
return m.Body
}
return nil
}
// Unary request.
type SimpleRequest struct {
// Desired payload type in the response from the server.
// If response_type is RANDOM, server randomly chooses one from other formats.
ResponseType *PayloadType `protobuf:"varint,1,opt,name=response_type,enum=grpc.testing.PayloadType" json:"response_type,omitempty"`
// Desired payload size in the response from the server.
// If response_type is COMPRESSABLE, this denotes the size before compression.
ResponseSize *int32 `protobuf:"varint,2,opt,name=response_size" json:"response_size,omitempty"`
// Optional input payload sent along with the request.
Payload *Payload `protobuf:"bytes,3,opt,name=payload" json:"payload,omitempty"`
// Whether SimpleResponse should include username.
FillUsername *bool `protobuf:"varint,4,opt,name=fill_username" json:"fill_username,omitempty"`
// Whether SimpleResponse should include OAuth scope.
FillOauthScope *bool `protobuf:"varint,5,opt,name=fill_oauth_scope" json:"fill_oauth_scope,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *SimpleRequest) Reset() { *m = SimpleRequest{} }
func (m *SimpleRequest) String() string { return proto.CompactTextString(m) }
func (*SimpleRequest) ProtoMessage() {}
func (m *SimpleRequest) GetResponseType() PayloadType {
if m != nil && m.ResponseType != nil {
return *m.ResponseType
}
return PayloadType_COMPRESSABLE
}
func (m *SimpleRequest) GetResponseSize() int32 {
if m != nil && m.ResponseSize != nil {
return *m.ResponseSize
}
return 0
}
func (m *SimpleRequest) GetPayload() *Payload {
if m != nil {
return m.Payload
}
return nil
}
func (m *SimpleRequest) GetFillUsername() bool {
if m != nil && m.FillUsername != nil {
return *m.FillUsername
}
return false
}
func (m *SimpleRequest) GetFillOauthScope() bool {
if m != nil && m.FillOauthScope != nil {
return *m.FillOauthScope
}
return false
}
// Unary response, as configured by the request.
type SimpleResponse struct {
// Payload to increase message size.
Payload *Payload `protobuf:"bytes,1,opt,name=payload" json:"payload,omitempty"`
// The user the request came from, for verifying authentication was
// successful when the client expected it.
Username *string `protobuf:"bytes,2,opt,name=username" json:"username,omitempty"`
// OAuth scope.
OauthScope *string `protobuf:"bytes,3,opt,name=oauth_scope" json:"oauth_scope,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *SimpleResponse) Reset() { *m = SimpleResponse{} }
func (m *SimpleResponse) String() string { return proto.CompactTextString(m) }
func (*SimpleResponse) ProtoMessage() {}
func (m *SimpleResponse) GetPayload() *Payload {
if m != nil {
return m.Payload
}
return nil
}
func (m *SimpleResponse) GetUsername() string {
if m != nil && m.Username != nil {
return *m.Username
}
return ""
}
func (m *SimpleResponse) GetOauthScope() string {
if m != nil && m.OauthScope != nil {
return *m.OauthScope
}
return ""
}
// Client-streaming request.
type StreamingInputCallRequest struct {
// Optional input payload sent along with the request.
Payload *Payload `protobuf:"bytes,1,opt,name=payload" json:"payload,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *StreamingInputCallRequest) Reset() { *m = StreamingInputCallRequest{} }
func (m *StreamingInputCallRequest) String() string { return proto.CompactTextString(m) }
func (*StreamingInputCallRequest) ProtoMessage() {}
func (m *StreamingInputCallRequest) GetPayload() *Payload {
if m != nil {
return m.Payload
}
return nil
}
// Client-streaming response.
type StreamingInputCallResponse struct {
// Aggregated size of payloads received from the client.
AggregatedPayloadSize *int32 `protobuf:"varint,1,opt,name=aggregated_payload_size" json:"aggregated_payload_size,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *StreamingInputCallResponse) Reset() { *m = StreamingInputCallResponse{} }
func (m *StreamingInputCallResponse) String() string { return proto.CompactTextString(m) }
func (*StreamingInputCallResponse) ProtoMessage() {}
func (m *StreamingInputCallResponse) GetAggregatedPayloadSize() int32 {
if m != nil && m.AggregatedPayloadSize != nil {
return *m.AggregatedPayloadSize
}
return 0
}
// Configuration for a particular response.
type ResponseParameters struct {
// Desired payload sizes in responses from the server.
// If response_type is COMPRESSABLE, this denotes the size before compression.
Size *int32 `protobuf:"varint,1,opt,name=size" json:"size,omitempty"`
// Desired interval between consecutive responses in the response stream in
// microseconds.
IntervalUs *int32 `protobuf:"varint,2,opt,name=interval_us" json:"interval_us,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ResponseParameters) Reset() { *m = ResponseParameters{} }
func (m *ResponseParameters) String() string { return proto.CompactTextString(m) }
func (*ResponseParameters) ProtoMessage() {}
func (m *ResponseParameters) GetSize() int32 {
if m != nil && m.Size != nil {
return *m.Size
}
return 0
}
func (m *ResponseParameters) GetIntervalUs() int32 {
if m != nil && m.IntervalUs != nil {
return *m.IntervalUs
}
return 0
}
// Server-streaming request.
type StreamingOutputCallRequest struct {
// Desired payload type in the response from the server.
// If response_type is RANDOM, the payload from each response in the stream
// might be of different types. This is to simulate a mixed type of payload
// stream.
ResponseType *PayloadType `protobuf:"varint,1,opt,name=response_type,enum=grpc.testing.PayloadType" json:"response_type,omitempty"`
// Configuration for each expected response message.
ResponseParameters []*ResponseParameters `protobuf:"bytes,2,rep,name=response_parameters" json:"response_parameters,omitempty"`
// Optional input payload sent along with the request.
Payload *Payload `protobuf:"bytes,3,opt,name=payload" json:"payload,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *StreamingOutputCallRequest) Reset() { *m = StreamingOutputCallRequest{} }
func (m *StreamingOutputCallRequest) String() string { return proto.CompactTextString(m) }
func (*StreamingOutputCallRequest) ProtoMessage() {}
func (m *StreamingOutputCallRequest) GetResponseType() PayloadType {
if m != nil && m.ResponseType != nil {
return *m.ResponseType
}
return PayloadType_COMPRESSABLE
}
func (m *StreamingOutputCallRequest) GetResponseParameters() []*ResponseParameters {
if m != nil {
return m.ResponseParameters
}
return nil
}
func (m *StreamingOutputCallRequest) GetPayload() *Payload {
if m != nil {
return m.Payload
}
return nil
}
// Server-streaming response, as configured by the request and parameters.
type StreamingOutputCallResponse struct {
// Payload to increase response size.
Payload *Payload `protobuf:"bytes,1,opt,name=payload" json:"payload,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *StreamingOutputCallResponse) Reset() { *m = StreamingOutputCallResponse{} }
func (m *StreamingOutputCallResponse) String() string { return proto.CompactTextString(m) }
func (*StreamingOutputCallResponse) ProtoMessage() {}
func (m *StreamingOutputCallResponse) GetPayload() *Payload {
if m != nil {
return m.Payload
}
return nil
}
func init() {
proto.RegisterEnum("grpc.testing.PayloadType", PayloadType_name, PayloadType_value)
}
// Client API for TestService service
type TestServiceClient interface {
// One empty request followed by one empty response.
EmptyCall(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error)
// One request followed by one response.
// The server returns the client payload as-is.
UnaryCall(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error)
// One request followed by a sequence of responses (streamed download).
// The server returns the payload with client desired type and sizes.
StreamingOutputCall(ctx context.Context, in *StreamingOutputCallRequest, opts ...grpc.CallOption) (TestService_StreamingOutputCallClient, error)
// A sequence of requests followed by one response (streamed upload).
// The server returns the aggregated size of client payload as the result.
StreamingInputCall(ctx context.Context, opts ...grpc.CallOption) (TestService_StreamingInputCallClient, error)
// A sequence of requests with each request served by the server immediately.
// As one request could lead to multiple responses, this interface
// demonstrates the idea of full duplexing.
FullDuplexCall(ctx context.Context, opts ...grpc.CallOption) (TestService_FullDuplexCallClient, error)
// A sequence of requests followed by a sequence of responses.
// The server buffers all the client requests and then serves them in order. A
// stream of responses are returned to the client when the server starts with
// first request.
HalfDuplexCall(ctx context.Context, opts ...grpc.CallOption) (TestService_HalfDuplexCallClient, error)
}
type testServiceClient struct {
cc *grpc.ClientConn
}
func NewTestServiceClient(cc *grpc.ClientConn) TestServiceClient {
return &testServiceClient{cc}
}
func (c *testServiceClient) EmptyCall(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error) {
out := new(Empty)
err := grpc.Invoke(ctx, "/grpc.testing.TestService/EmptyCall", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *testServiceClient) UnaryCall(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error) {
out := new(SimpleResponse)
err := grpc.Invoke(ctx, "/grpc.testing.TestService/UnaryCall", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *testServiceClient) StreamingOutputCall(ctx context.Context, in *StreamingOutputCallRequest, opts ...grpc.CallOption) (TestService_StreamingOutputCallClient, error) {
stream, err := grpc.NewClientStream(ctx, &_TestService_serviceDesc.Streams[0], c.cc, "/grpc.testing.TestService/StreamingOutputCall", opts...)
if err != nil {
return nil, err
}
x := &testServiceStreamingOutputCallClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type TestService_StreamingOutputCallClient interface {
Recv() (*StreamingOutputCallResponse, error)
grpc.ClientStream
}
type testServiceStreamingOutputCallClient struct {
grpc.ClientStream
}
func (x *testServiceStreamingOutputCallClient) Recv() (*StreamingOutputCallResponse, error) {
m := new(StreamingOutputCallResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *testServiceClient) StreamingInputCall(ctx context.Context, opts ...grpc.CallOption) (TestService_StreamingInputCallClient, error) {
stream, err := grpc.NewClientStream(ctx, &_TestService_serviceDesc.Streams[1], c.cc, "/grpc.testing.TestService/StreamingInputCall", opts...)
if err != nil {
return nil, err
}
x := &testServiceStreamingInputCallClient{stream}
return x, nil
}
type TestService_StreamingInputCallClient interface {
Send(*StreamingInputCallRequest) error
CloseAndRecv() (*StreamingInputCallResponse, error)
grpc.ClientStream
}
type testServiceStreamingInputCallClient struct {
grpc.ClientStream
}
func (x *testServiceStreamingInputCallClient) Send(m *StreamingInputCallRequest) error {
return x.ClientStream.SendMsg(m)
}
func (x *testServiceStreamingInputCallClient) CloseAndRecv() (*StreamingInputCallResponse, error) {
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
m := new(StreamingInputCallResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *testServiceClient) FullDuplexCall(ctx context.Context, opts ...grpc.CallOption) (TestService_FullDuplexCallClient, error) {
stream, err := grpc.NewClientStream(ctx, &_TestService_serviceDesc.Streams[2], c.cc, "/grpc.testing.TestService/FullDuplexCall", opts...)
if err != nil {
return nil, err
}
x := &testServiceFullDuplexCallClient{stream}
return x, nil
}
type TestService_FullDuplexCallClient interface {
Send(*StreamingOutputCallRequest) error
Recv() (*StreamingOutputCallResponse, error)
grpc.ClientStream
}
type testServiceFullDuplexCallClient struct {
grpc.ClientStream
}
func (x *testServiceFullDuplexCallClient) Send(m *StreamingOutputCallRequest) error {
return x.ClientStream.SendMsg(m)
}
func (x *testServiceFullDuplexCallClient) Recv() (*StreamingOutputCallResponse, error) {
m := new(StreamingOutputCallResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *testServiceClient) HalfDuplexCall(ctx context.Context, opts ...grpc.CallOption) (TestService_HalfDuplexCallClient, error) {
stream, err := grpc.NewClientStream(ctx, &_TestService_serviceDesc.Streams[3], c.cc, "/grpc.testing.TestService/HalfDuplexCall", opts...)
if err != nil {
return nil, err
}
x := &testServiceHalfDuplexCallClient{stream}
return x, nil
}
type TestService_HalfDuplexCallClient interface {
Send(*StreamingOutputCallRequest) error
Recv() (*StreamingOutputCallResponse, error)
grpc.ClientStream
}
type testServiceHalfDuplexCallClient struct {
grpc.ClientStream
}
func (x *testServiceHalfDuplexCallClient) Send(m *StreamingOutputCallRequest) error {
return x.ClientStream.SendMsg(m)
}
func (x *testServiceHalfDuplexCallClient) Recv() (*StreamingOutputCallResponse, error) {
m := new(StreamingOutputCallResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
// Server API for TestService service
type TestServiceServer interface {
// One empty request followed by one empty response.
EmptyCall(context.Context, *Empty) (*Empty, error)
// One request followed by one response.
// The server returns the client payload as-is.
UnaryCall(context.Context, *SimpleRequest) (*SimpleResponse, error)
// One request followed by a sequence of responses (streamed download).
// The server returns the payload with client desired type and sizes.
StreamingOutputCall(*StreamingOutputCallRequest, TestService_StreamingOutputCallServer) error
// A sequence of requests followed by one response (streamed upload).
// The server returns the aggregated size of client payload as the result.
StreamingInputCall(TestService_StreamingInputCallServer) error
// A sequence of requests with each request served by the server immediately.
// As one request could lead to multiple responses, this interface
// demonstrates the idea of full duplexing.
FullDuplexCall(TestService_FullDuplexCallServer) error
// A sequence of requests followed by a sequence of responses.
// The server buffers all the client requests and then serves them in order. A
// stream of responses are returned to the client when the server starts with
// first request.
HalfDuplexCall(TestService_HalfDuplexCallServer) error
}
func RegisterTestServiceServer(s *grpc.Server, srv TestServiceServer) {
s.RegisterService(&_TestService_serviceDesc, srv)
}
func _TestService_EmptyCall_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
in := new(Empty)
if err := codec.Unmarshal(buf, in); err != nil {
return nil, err
}
out, err := srv.(TestServiceServer).EmptyCall(ctx, in)
if err != nil {
return nil, err
}
return out, nil
}
func _TestService_UnaryCall_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
in := new(SimpleRequest)
if err := codec.Unmarshal(buf, in); err != nil {
return nil, err
}
out, err := srv.(TestServiceServer).UnaryCall(ctx, in)
if err != nil {
return nil, err
}
return out, nil
}
func _TestService_StreamingOutputCall_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(StreamingOutputCallRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(TestServiceServer).StreamingOutputCall(m, &testServiceStreamingOutputCallServer{stream})
}
type TestService_StreamingOutputCallServer interface {
Send(*StreamingOutputCallResponse) error
grpc.ServerStream
}
type testServiceStreamingOutputCallServer struct {
grpc.ServerStream
}
func (x *testServiceStreamingOutputCallServer) Send(m *StreamingOutputCallResponse) error {
return x.ServerStream.SendMsg(m)
}
func _TestService_StreamingInputCall_Handler(srv interface{}, stream grpc.ServerStream) error {
return srv.(TestServiceServer).StreamingInputCall(&testServiceStreamingInputCallServer{stream})
}
type TestService_StreamingInputCallServer interface {
SendAndClose(*StreamingInputCallResponse) error
Recv() (*StreamingInputCallRequest, error)
grpc.ServerStream
}
type testServiceStreamingInputCallServer struct {
grpc.ServerStream
}
func (x *testServiceStreamingInputCallServer) SendAndClose(m *StreamingInputCallResponse) error {
return x.ServerStream.SendMsg(m)
}
func (x *testServiceStreamingInputCallServer) Recv() (*StreamingInputCallRequest, error) {
m := new(StreamingInputCallRequest)
if err := x.ServerStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func _TestService_FullDuplexCall_Handler(srv interface{}, stream grpc.ServerStream) error {
return srv.(TestServiceServer).FullDuplexCall(&testServiceFullDuplexCallServer{stream})
}
type TestService_FullDuplexCallServer interface {
Send(*StreamingOutputCallResponse) error
Recv() (*StreamingOutputCallRequest, error)
grpc.ServerStream
}
type testServiceFullDuplexCallServer struct {
grpc.ServerStream
}
func (x *testServiceFullDuplexCallServer) Send(m *StreamingOutputCallResponse) error {
return x.ServerStream.SendMsg(m)
}
func (x *testServiceFullDuplexCallServer) Recv() (*StreamingOutputCallRequest, error) {
m := new(StreamingOutputCallRequest)
if err := x.ServerStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func _TestService_HalfDuplexCall_Handler(srv interface{}, stream grpc.ServerStream) error {
return srv.(TestServiceServer).HalfDuplexCall(&testServiceHalfDuplexCallServer{stream})
}
type TestService_HalfDuplexCallServer interface {
Send(*StreamingOutputCallResponse) error
Recv() (*StreamingOutputCallRequest, error)
grpc.ServerStream
}
type testServiceHalfDuplexCallServer struct {
grpc.ServerStream
}
func (x *testServiceHalfDuplexCallServer) Send(m *StreamingOutputCallResponse) error {
return x.ServerStream.SendMsg(m)
}
func (x *testServiceHalfDuplexCallServer) Recv() (*StreamingOutputCallRequest, error) {
m := new(StreamingOutputCallRequest)
if err := x.ServerStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
var _TestService_serviceDesc = grpc.ServiceDesc{
ServiceName: "grpc.testing.TestService",
HandlerType: (*TestServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "EmptyCall",
Handler: _TestService_EmptyCall_Handler,
},
{
MethodName: "UnaryCall",
Handler: _TestService_UnaryCall_Handler,
},
},
Streams: []grpc.StreamDesc{
{
StreamName: "StreamingOutputCall",
Handler: _TestService_StreamingOutputCall_Handler,
ServerStreams: true,
},
{
StreamName: "StreamingInputCall",
Handler: _TestService_StreamingInputCall_Handler,
ClientStreams: true,
},
{
StreamName: "FullDuplexCall",
Handler: _TestService_FullDuplexCall_Handler,
ServerStreams: true,
ClientStreams: true,
},
{
StreamName: "HalfDuplexCall",
Handler: _TestService_HalfDuplexCall_Handler,
ServerStreams: true,
ClientStreams: true,
},
},
}
================================================
FILE: vendor/google.golang.org/grpc/interop/grpc_testing/test.proto
================================================
// An integration test service that covers all the method signature permutations
// of unary/streaming requests/responses.
syntax = "proto2";
package grpc.testing;
message Empty {}
// The type of payload that should be returned.
enum PayloadType {
// Compressable text format.
COMPRESSABLE = 0;
// Uncompressable binary format.
UNCOMPRESSABLE = 1;
// Randomly chosen from all other formats defined in this enum.
RANDOM = 2;
}
// A block of data, to simply increase gRPC message size.
message Payload {
// The type of data in body.
optional PayloadType type = 1;
// Primary contents of payload.
optional bytes body = 2;
}
// Unary request.
message SimpleRequest {
// Desired payload type in the response from the server.
// If response_type is RANDOM, server randomly chooses one from other formats.
optional PayloadType response_type = 1;
// Desired payload size in the response from the server.
// If response_type is COMPRESSABLE, this denotes the size before compression.
optional int32 response_size = 2;
// Optional input payload sent along with the request.
optional Payload payload = 3;
// Whether SimpleResponse should include username.
optional bool fill_username = 4;
// Whether SimpleResponse should include OAuth scope.
optional bool fill_oauth_scope = 5;
}
// Unary response, as configured by the request.
message SimpleResponse {
// Payload to increase message size.
optional Payload payload = 1;
// The user the request came from, for verifying authentication was
// successful when the client expected it.
optional string username = 2;
// OAuth scope.
optional string oauth_scope = 3;
}
// Client-streaming request.
message StreamingInputCallRequest {
// Optional input payload sent along with the request.
optional Payload payload = 1;
// Not expecting any payload from the response.
}
// Client-streaming response.
message StreamingInputCallResponse {
// Aggregated size of payloads received from the client.
optional int32 aggregated_payload_size = 1;
}
// Configuration for a particular response.
message ResponseParameters {
// Desired payload sizes in responses from the server.
// If response_type is COMPRESSABLE, this denotes the size before compression.
optional int32 size = 1;
// Desired interval between consecutive responses in the response stream in
// microseconds.
optional int32 interval_us = 2;
}
// Server-streaming request.
message StreamingOutputCallRequest {
// Desired payload type in the response from the server.
// If response_type is RANDOM, the payload from each response in the stream
// might be of different types. This is to simulate a mixed type of payload
// stream.
optional PayloadType response_type = 1;
// Configuration for each expected response message.
repeated ResponseParameters response_parameters = 2;
// Optional input payload sent along with the request.
optional Payload payload = 3;
}
// Server-streaming response, as configured by the request and parameters.
message StreamingOutputCallResponse {
// Payload to increase response size.
optional Payload payload = 1;
}
// A simple service to test the various types of RPCs and experiment with
// performance with various types of payload.
service TestService {
// One empty request followed by one empty response.
rpc EmptyCall(Empty) returns (Empty);
// One request followed by one response.
// The server returns the client payload as-is.
rpc UnaryCall(SimpleRequest) returns (SimpleResponse);
// One request followed by a sequence of responses (streamed download).
// The server returns the payload with client desired type and sizes.
rpc StreamingOutputCall(StreamingOutputCallRequest)
returns (stream StreamingOutputCallResponse);
// A sequence of requests followed by one response (streamed upload).
// The server returns the aggregated size of client payload as the result.
rpc StreamingInputCall(stream StreamingInputCallRequest)
returns (StreamingInputCallResponse);
// A sequence of requests with each request served by the server immediately.
// As one request could lead to multiple responses, this interface
// demonstrates the idea of full duplexing.
rpc FullDuplexCall(stream StreamingOutputCallRequest)
returns (stream StreamingOutputCallResponse);
// A sequence of requests followed by a sequence of responses.
// The server buffers all the client requests and then serves them in order. A
// stream of responses are returned to the client when the server starts with
// first request.
rpc HalfDuplexCall(stream StreamingOutputCallRequest)
returns (stream StreamingOutputCallResponse);
}
================================================
FILE: vendor/google.golang.org/grpc/interop/server/server.go
================================================
/*
*
* Copyright 2014, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package main
import (
"flag"
"fmt"
"io"
"net"
"strconv"
"time"
"github.com/golang/protobuf/proto"
"golang.org/x/net/context"
"google.golang.org/grpc"
"google.golang.org/grpc/credentials"
"google.golang.org/grpc/grpclog"
testpb "google.golang.org/grpc/interop/grpc_testing"
)
var (
useTLS = flag.Bool("use_tls", false, "Connection uses TLS if true, else plain TCP")
certFile = flag.String("tls_cert_file", "testdata/server1.pem", "The TLS cert file")
keyFile = flag.String("tls_key_file", "testdata/server1.key", "The TLS key file")
port = flag.Int("port", 10000, "The server port")
)
type testServer struct {
}
func (s *testServer) EmptyCall(ctx context.Context, in *testpb.Empty) (*testpb.Empty, error) {
return new(testpb.Empty), nil
}
func newPayload(t testpb.PayloadType, size int32) (*testpb.Payload, error) {
if size < 0 {
return nil, fmt.Errorf("requested a response with invalid length %d", size)
}
body := make([]byte, size)
switch t {
case testpb.PayloadType_COMPRESSABLE:
case testpb.PayloadType_UNCOMPRESSABLE:
return nil, fmt.Errorf("payloadType UNCOMPRESSABLE is not supported")
default:
return nil, fmt.Errorf("unsupported payload type: %d", t)
}
return &testpb.Payload{
Type: t.Enum(),
Body: body,
}, nil
}
func (s *testServer) UnaryCall(ctx context.Context, in *testpb.SimpleRequest) (*testpb.SimpleResponse, error) {
pl, err := newPayload(in.GetResponseType(), in.GetResponseSize())
if err != nil {
return nil, err
}
return &testpb.SimpleResponse{
Payload: pl,
}, nil
}
func (s *testServer) StreamingOutputCall(args *testpb.StreamingOutputCallRequest, stream testpb.TestService_StreamingOutputCallServer) error {
cs := args.GetResponseParameters()
for _, c := range cs {
if us := c.GetIntervalUs(); us > 0 {
time.Sleep(time.Duration(us) * time.Microsecond)
}
pl, err := newPayload(args.GetResponseType(), c.GetSize())
if err != nil {
return err
}
if err := stream.Send(&testpb.StreamingOutputCallResponse{
Payload: pl,
}); err != nil {
return err
}
}
return nil
}
func (s *testServer) StreamingInputCall(stream testpb.TestService_StreamingInputCallServer) error {
var sum int
for {
in, err := stream.Recv()
if err == io.EOF {
return stream.SendAndClose(&testpb.StreamingInputCallResponse{
AggregatedPayloadSize: proto.Int32(int32(sum)),
})
}
if err != nil {
return err
}
p := in.GetPayload().GetBody()
sum += len(p)
}
}
func (s *testServer) FullDuplexCall(stream testpb.TestService_FullDuplexCallServer) error {
for {
in, err := stream.Recv()
if err == io.EOF {
// read done.
return nil
}
if err != nil {
return err
}
cs := in.GetResponseParameters()
for _, c := range cs {
if us := c.GetIntervalUs(); us > 0 {
time.Sleep(time.Duration(us) * time.Microsecond)
}
pl, err := newPayload(in.GetResponseType(), c.GetSize())
if err != nil {
return err
}
if err := stream.Send(&testpb.StreamingOutputCallResponse{
Payload: pl,
}); err != nil {
return err
}
}
}
}
func (s *testServer) HalfDuplexCall(stream testpb.TestService_HalfDuplexCallServer) error {
var msgBuf []*testpb.StreamingOutputCallRequest
for {
in, err := stream.Recv()
if err == io.EOF {
// read done.
break
}
if err != nil {
return err
}
msgBuf = append(msgBuf, in)
}
for _, m := range msgBuf {
cs := m.GetResponseParameters()
for _, c := range cs {
if us := c.GetIntervalUs(); us > 0 {
time.Sleep(time.Duration(us) * time.Microsecond)
}
pl, err := newPayload(m.GetResponseType(), c.GetSize())
if err != nil {
return err
}
if err := stream.Send(&testpb.StreamingOutputCallResponse{
Payload: pl,
}); err != nil {
return err
}
}
}
return nil
}
func main() {
flag.Parse()
p := strconv.Itoa(*port)
lis, err := net.Listen("tcp", ":"+p)
if err != nil {
grpclog.Fatalf("failed to listen: %v", err)
}
var opts []grpc.ServerOption
if *useTLS {
creds, err := credentials.NewServerTLSFromFile(*certFile, *keyFile)
if err != nil {
grpclog.Fatalf("Failed to generate credentials %v", err)
}
opts = []grpc.ServerOption{grpc.Creds(creds)}
}
server := grpc.NewServer(opts...)
testpb.RegisterTestServiceServer(server, &testServer{})
server.Serve(lis)
}
================================================
FILE: vendor/google.golang.org/grpc/metadata/metadata.go
================================================
/*
*
* Copyright 2014, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
// Package metadata define the structure of the metadata supported by gRPC library.
package metadata
import (
"encoding/base64"
"fmt"
"strings"
"golang.org/x/net/context"
)
const (
binHdrSuffix = "-bin"
)
// grpc-http2 requires ASCII header key and value (more detail can be found in
// "Requests" subsection in go/grpc-http2).
func isASCII(s string) bool {
for _, c := range s {
if c > 127 {
return false
}
}
return true
}
// encodeKeyValue encodes key and value qualified for transmission via gRPC.
// Transmitting binary headers violates HTTP/2 spec.
// TODO(zhaoq): Maybe check if k is ASCII also.
func encodeKeyValue(k, v string) (string, string) {
if isASCII(v) {
return k, v
}
key := k + binHdrSuffix
val := base64.StdEncoding.EncodeToString([]byte(v))
return key, string(val)
}
// DecodeKeyValue returns the original key and value corresponding to the
// encoded data in k, v.
func DecodeKeyValue(k, v string) (string, string, error) {
if !strings.HasSuffix(k, binHdrSuffix) {
return k, v, nil
}
key := k[:len(k)-len(binHdrSuffix)]
val, err := base64.StdEncoding.DecodeString(v)
if err != nil {
return "", "", err
}
return key, string(val), nil
}
// MD is a mapping from metadata keys to values. Users should use the following
// two convenience functions New and Pairs to generate MD.
type MD map[string]string
// New creates a MD from given key-value map.
func New(m map[string]string) MD {
md := MD{}
for k, v := range m {
key, val := encodeKeyValue(k, v)
md[key] = val
}
return md
}
// Pairs returns an MD formed by the mapping of key, value ...
// Pairs panics if len(kv) is odd.
func Pairs(kv ...string) MD {
if len(kv)%2 == 1 {
panic(fmt.Sprintf("metadata: Pairs got the odd number of input pairs for metadata: %d", len(kv)))
}
md := MD{}
var k string
for i, s := range kv {
if i%2 == 0 {
k = s
continue
}
key, val := encodeKeyValue(k, s)
md[key] = val
}
return md
}
// Len returns the number of items in md.
func (md MD) Len() int {
return len(md)
}
// Copy returns a copy of md.
func (md MD) Copy() MD {
out := MD{}
for k, v := range md {
out[k] = v
}
return out
}
type mdKey struct{}
// NewContext creates a new context with md attached.
func NewContext(ctx context.Context, md MD) context.Context {
return context.WithValue(ctx, mdKey{}, md)
}
// FromContext returns the MD in ctx if it exists.
func FromContext(ctx context.Context) (md MD, ok bool) {
md, ok = ctx.Value(mdKey{}).(MD)
return
}
================================================
FILE: vendor/google.golang.org/grpc/rpc_util.go
================================================
/*
*
* Copyright 2014, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package grpc
import (
"bytes"
"encoding/binary"
"fmt"
"io"
"math/rand"
"os"
"time"
"github.com/golang/protobuf/proto"
"golang.org/x/net/context"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/metadata"
"google.golang.org/grpc/transport"
)
// Codec defines the interface gRPC uses to encode and decode messages.
type Codec interface {
// Marshal returns the wire format of v.
Marshal(v interface{}) ([]byte, error)
// Unmarshal parses the wire format into v.
Unmarshal(data []byte, v interface{}) error
// String returns the name of the Codec implementation. The returned
// string will be used as part of content type in transmission.
String() string
}
// protoCodec is a Codec implemetation with protobuf. It is the default codec for gRPC.
type protoCodec struct{}
func (protoCodec) Marshal(v interface{}) ([]byte, error) {
return proto.Marshal(v.(proto.Message))
}
func (protoCodec) Unmarshal(data []byte, v interface{}) error {
return proto.Unmarshal(data, v.(proto.Message))
}
func (protoCodec) String() string {
return "proto"
}
// CallOption configures a Call before it starts or extracts information from
// a Call after it completes.
type CallOption interface {
// before is called before the call is sent to any server. If before
// returns a non-nil error, the RPC fails with that error.
before(*callInfo) error
// after is called after the call has completed. after cannot return an
// error, so any failures should be reported via output parameters.
after(*callInfo)
}
type beforeCall func(c *callInfo) error
func (o beforeCall) before(c *callInfo) error { return o(c) }
func (o beforeCall) after(c *callInfo) {}
type afterCall func(c *callInfo)
func (o afterCall) before(c *callInfo) error { return nil }
func (o afterCall) after(c *callInfo) { o(c) }
// Header returns a CallOptions that retrieves the header metadata
// for a unary RPC.
func Header(md *metadata.MD) CallOption {
return afterCall(func(c *callInfo) {
*md = c.headerMD
})
}
// Trailer returns a CallOptions that retrieves the trailer metadata
// for a unary RPC.
func Trailer(md *metadata.MD) CallOption {
return afterCall(func(c *callInfo) {
*md = c.trailerMD
})
}
// The format of the payload: compressed or not?
type payloadFormat uint8
const (
compressionNone payloadFormat = iota // no compression
compressionFlate
// More formats
)
// parser reads complelete gRPC messages from the underlying reader.
type parser struct {
s io.Reader
}
// msgFixedHeader defines the header of a gRPC message (go/grpc-wirefmt).
type msgFixedHeader struct {
T payloadFormat
Length uint32
}
// recvMsg is to read a complete gRPC message from the stream. It is blocking if
// the message has not been complete yet. It returns the message and its type,
// EOF is returned with nil msg and 0 pf if the entire stream is done. Other
// non-nil error is returned if something is wrong on reading.
func (p *parser) recvMsg() (pf payloadFormat, msg []byte, err error) {
var hdr msgFixedHeader
if err := binary.Read(p.s, binary.BigEndian, &hdr); err != nil {
return 0, nil, err
}
if hdr.Length == 0 {
return hdr.T, nil, nil
}
msg = make([]byte, int(hdr.Length))
if _, err := io.ReadFull(p.s, msg); err != nil {
if err == io.EOF {
err = io.ErrUnexpectedEOF
}
return 0, nil, err
}
return hdr.T, msg, nil
}
// encode serializes msg and prepends the message header. If msg is nil, it
// generates the message header of 0 message length.
func encode(c Codec, msg interface{}, pf payloadFormat) ([]byte, error) {
var buf bytes.Buffer
// Write message fixed header.
buf.WriteByte(uint8(pf))
var b []byte
var length uint32
if msg != nil {
var err error
// TODO(zhaoq): optimize to reduce memory alloc and copying.
b, err = c.Marshal(msg)
if err != nil {
return nil, err
}
length = uint32(len(b))
}
var szHdr [4]byte
binary.BigEndian.PutUint32(szHdr[:], length)
buf.Write(szHdr[:])
buf.Write(b)
return buf.Bytes(), nil
}
func recv(p *parser, c Codec, m interface{}) error {
pf, d, err := p.recvMsg()
if err != nil {
return err
}
switch pf {
case compressionNone:
if err := c.Unmarshal(d, m); err != nil {
return Errorf(codes.Internal, "grpc: %v", err)
}
default:
return Errorf(codes.Internal, "gprc: compression is not supported yet.")
}
return nil
}
// rpcError defines the status from an RPC.
type rpcError struct {
code codes.Code
desc string
}
func (e rpcError) Error() string {
return fmt.Sprintf("rpc error: code = %d desc = %q", e.code, e.desc)
}
// Code returns the error code for err if it was produced by the rpc system.
// Otherwise, it returns codes.Unknown.
func Code(err error) codes.Code {
if err == nil {
return codes.OK
}
if e, ok := err.(rpcError); ok {
return e.code
}
return codes.Unknown
}
// Errorf returns an error containing an error code and a description;
// Errorf returns nil if c is OK.
func Errorf(c codes.Code, format string, a ...interface{}) error {
if c == codes.OK {
return nil
}
return rpcError{
code: c,
desc: fmt.Sprintf(format, a...),
}
}
// toRPCErr converts an error into a rpcError.
func toRPCErr(err error) error {
switch e := err.(type) {
case transport.StreamError:
return rpcError{
code: e.Code,
desc: e.Desc,
}
case transport.ConnectionError:
return rpcError{
code: codes.Internal,
desc: e.Desc,
}
}
return Errorf(codes.Unknown, "%v", err)
}
// convertCode converts a standard Go error into its canonical code. Note that
// this is only used to translate the error returned by the server applications.
func convertCode(err error) codes.Code {
switch err {
case nil:
return codes.OK
case io.EOF:
return codes.OutOfRange
case io.ErrClosedPipe, io.ErrNoProgress, io.ErrShortBuffer, io.ErrShortWrite, io.ErrUnexpectedEOF:
return codes.FailedPrecondition
case os.ErrInvalid:
return codes.InvalidArgument
case context.Canceled:
return codes.Canceled
case context.DeadlineExceeded:
return codes.DeadlineExceeded
}
switch {
case os.IsExist(err):
return codes.AlreadyExists
case os.IsNotExist(err):
return codes.NotFound
case os.IsPermission(err):
return codes.PermissionDenied
}
return codes.Unknown
}
const (
// how long to wait after the first failure before retrying
baseDelay = 1.0 * time.Second
// upper bound on backoff delay
maxDelay = 120 * time.Second
backoffFactor = 2.0 // backoff increases by this factor on each retry
backoffRange = 0.4 // backoff is randomized downwards by this factor
)
// backoff returns a value in [0, maxDelay] that increases exponentially with
// retries, starting from baseDelay.
func backoff(retries int) time.Duration {
backoff, max := float64(baseDelay), float64(maxDelay)
for backoff < max && retries > 0 {
backoff = backoff * backoffFactor
retries--
}
if backoff > max {
backoff = max
}
// Randomize backoff delays so that if a cluster of requests start at
// the same time, they won't operate in lockstep. We just subtract up
// to 40% so that we obey maxDelay.
backoff -= backoff * backoffRange * rand.Float64()
if backoff < 0 {
return 0
}
return time.Duration(backoff)
}
================================================
FILE: vendor/google.golang.org/grpc/server.go
================================================
/*
*
* Copyright 2014, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package grpc
import (
"errors"
"fmt"
"io"
"net"
"reflect"
"strings"
"sync"
"golang.org/x/net/context"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/credentials"
"google.golang.org/grpc/grpclog"
"google.golang.org/grpc/metadata"
"google.golang.org/grpc/transport"
)
type methodHandler func(srv interface{}, ctx context.Context, codec Codec, buf []byte) (interface{}, error)
// MethodDesc represents an RPC service's method specification.
type MethodDesc struct {
MethodName string
Handler methodHandler
}
// ServiceDesc represents an RPC service's specification.
type ServiceDesc struct {
ServiceName string
// The pointer to the service interface. Used to check whether the user
// provided implementation satisfies the interface requirements.
HandlerType interface{}
Methods []MethodDesc
Streams []StreamDesc
}
// service consists of the information of the server serving this service and
// the methods in this service.
type service struct {
server interface{} // the server for service methods
md map[string]*MethodDesc
sd map[string]*StreamDesc
}
// Server is a gRPC server to serve RPC requests.
type Server struct {
opts options
mu sync.Mutex
lis map[net.Listener]bool
conns map[transport.ServerTransport]bool
m map[string]*service // service name -> service info
}
type options struct {
creds credentials.Credentials
codec Codec
maxConcurrentStreams uint32
}
// A ServerOption sets options.
type ServerOption func(*options)
// CustomCodec returns a ServerOption that sets a codec for message marshaling and unmarshaling.
func CustomCodec(codec Codec) ServerOption {
return func(o *options) {
o.codec = codec
}
}
// MaxConcurrentStreams returns a ServerOption that will apply a limit on the number
// of concurrent streams to each ServerTransport.
func MaxConcurrentStreams(n uint32) ServerOption {
return func(o *options) {
o.maxConcurrentStreams = n
}
}
// Creds returns a ServerOption that sets credentials for server connections.
func Creds(c credentials.Credentials) ServerOption {
return func(o *options) {
o.creds = c
}
}
// NewServer creates a gRPC server which has no service registered and has not
// started to accept requests yet.
func NewServer(opt ...ServerOption) *Server {
var opts options
for _, o := range opt {
o(&opts)
}
if opts.codec == nil {
// Set the default codec.
opts.codec = protoCodec{}
}
return &Server{
lis: make(map[net.Listener]bool),
opts: opts,
conns: make(map[transport.ServerTransport]bool),
m: make(map[string]*service),
}
}
// RegisterService register a service and its implementation to the gRPC
// server. Called from the IDL generated code. This must be called before
// invoking Serve.
func (s *Server) RegisterService(sd *ServiceDesc, ss interface{}) {
s.mu.Lock()
defer s.mu.Unlock()
// Does some sanity checks.
if _, ok := s.m[sd.ServiceName]; ok {
grpclog.Fatalf("grpc: Server.RegisterService found duplicate service registration for %q", sd.ServiceName)
}
ht := reflect.TypeOf(sd.HandlerType).Elem()
st := reflect.TypeOf(ss)
if !st.Implements(ht) {
grpclog.Fatalf("grpc: Server.RegisterService found the handler of type %v that does not satisfy %v", st, ht)
}
srv := &service{
server: ss,
md: make(map[string]*MethodDesc),
sd: make(map[string]*StreamDesc),
}
for i := range sd.Methods {
d := &sd.Methods[i]
srv.md[d.MethodName] = d
}
for i := range sd.Streams {
d := &sd.Streams[i]
srv.sd[d.StreamName] = d
}
s.m[sd.ServiceName] = srv
}
var (
// ErrServerStopped indicates that the operation is now illegal because of
// the server being stopped.
ErrServerStopped = errors.New("grpc: the server has been stopped")
)
// Serve accepts incoming connections on the listener lis, creating a new
// ServerTransport and service goroutine for each. The service goroutines
// read gRPC request and then call the registered handlers to reply to them.
// Service returns when lis.Accept fails.
func (s *Server) Serve(lis net.Listener) error {
s.mu.Lock()
if s.lis == nil {
s.mu.Unlock()
return ErrServerStopped
}
s.lis[lis] = true
s.mu.Unlock()
defer func() {
lis.Close()
s.mu.Lock()
delete(s.lis, lis)
s.mu.Unlock()
}()
for {
c, err := lis.Accept()
if err != nil {
return err
}
if creds, ok := s.opts.creds.(credentials.TransportAuthenticator); ok {
c, err = creds.ServerHandshake(c)
if err != nil {
grpclog.Println("grpc: Server.Serve failed to complete security handshake.")
continue
}
}
s.mu.Lock()
if s.conns == nil {
s.mu.Unlock()
c.Close()
return nil
}
st, err := transport.NewServerTransport("http2", c, s.opts.maxConcurrentStreams)
if err != nil {
s.mu.Unlock()
c.Close()
grpclog.Println("grpc: Server.Serve failed to create ServerTransport: ", err)
continue
}
s.conns[st] = true
s.mu.Unlock()
go func() {
st.HandleStreams(func(stream *transport.Stream) {
s.handleStream(st, stream)
})
s.mu.Lock()
delete(s.conns, st)
s.mu.Unlock()
}()
}
}
func (s *Server) sendResponse(t transport.ServerTransport, stream *transport.Stream, msg interface{}, pf payloadFormat, opts *transport.Options) error {
p, err := encode(s.opts.codec, msg, pf)
if err != nil {
// This typically indicates a fatal issue (e.g., memory
// corruption or hardware faults) the application program
// cannot handle.
//
// TODO(zhaoq): There exist other options also such as only closing the
// faulty stream locally and remotely (Other streams can keep going). Find
// the optimal option.
grpclog.Fatalf("grpc: Server failed to encode response %v", err)
}
return t.Write(stream, p, opts)
}
func (s *Server) processUnaryRPC(t transport.ServerTransport, stream *transport.Stream, srv *service, md *MethodDesc) {
p := &parser{s: stream}
for {
pf, req, err := p.recvMsg()
if err == io.EOF {
// The entire stream is done (for unary RPC only).
return
}
if err != nil {
switch err := err.(type) {
case transport.ConnectionError:
// Nothing to do here.
case transport.StreamError:
if err := t.WriteStatus(stream, err.Code, err.Desc); err != nil {
grpclog.Printf("grpc: Server.processUnaryRPC failed to write status: %v", err)
}
default:
panic(fmt.Sprintf("grpc: Unexpected error (%T) from recvMsg: %v", err, err))
}
return
}
switch pf {
case compressionNone:
statusCode := codes.OK
statusDesc := ""
reply, appErr := md.Handler(srv.server, stream.Context(), s.opts.codec, req)
if appErr != nil {
if err, ok := appErr.(rpcError); ok {
statusCode = err.code
statusDesc = err.desc
} else {
statusCode = convertCode(appErr)
statusDesc = appErr.Error()
}
if err := t.WriteStatus(stream, statusCode, statusDesc); err != nil {
grpclog.Printf("grpc: Server.processUnaryRPC failed to write status: %v", err)
}
return
}
opts := &transport.Options{
Last: true,
Delay: false,
}
if err := s.sendResponse(t, stream, reply, compressionNone, opts); err != nil {
if _, ok := err.(transport.ConnectionError); ok {
return
}
if e, ok := err.(transport.StreamError); ok {
statusCode = e.Code
statusDesc = e.Desc
} else {
statusCode = codes.Unknown
statusDesc = err.Error()
}
}
t.WriteStatus(stream, statusCode, statusDesc)
default:
panic(fmt.Sprintf("payload format to be supported: %d", pf))
}
}
}
func (s *Server) processStreamingRPC(t transport.ServerTransport, stream *transport.Stream, srv *service, sd *StreamDesc) {
ss := &serverStream{
t: t,
s: stream,
p: &parser{s: stream},
codec: s.opts.codec,
}
if appErr := sd.Handler(srv.server, ss); appErr != nil {
if err, ok := appErr.(rpcError); ok {
ss.statusCode = err.code
ss.statusDesc = err.desc
} else {
ss.statusCode = convertCode(appErr)
ss.statusDesc = appErr.Error()
}
}
t.WriteStatus(ss.s, ss.statusCode, ss.statusDesc)
}
func (s *Server) handleStream(t transport.ServerTransport, stream *transport.Stream) {
sm := stream.Method()
if sm != "" && sm[0] == '/' {
sm = sm[1:]
}
pos := strings.LastIndex(sm, "/")
if pos == -1 {
if err := t.WriteStatus(stream, codes.InvalidArgument, fmt.Sprintf("malformed method name: %q", stream.Method())); err != nil {
grpclog.Printf("grpc: Server.handleStream failed to write status: %v", err)
}
return
}
service := sm[:pos]
method := sm[pos+1:]
srv, ok := s.m[service]
if !ok {
if err := t.WriteStatus(stream, codes.Unimplemented, fmt.Sprintf("unknown service %v", service)); err != nil {
grpclog.Printf("grpc: Server.handleStream failed to write status: %v", err)
}
return
}
// Unary RPC or Streaming RPC?
if md, ok := srv.md[method]; ok {
s.processUnaryRPC(t, stream, srv, md)
return
}
if sd, ok := srv.sd[method]; ok {
s.processStreamingRPC(t, stream, srv, sd)
return
}
if err := t.WriteStatus(stream, codes.Unimplemented, fmt.Sprintf("unknown method %v", method)); err != nil {
grpclog.Printf("grpc: Server.handleStream failed to write status: %v", err)
}
}
// Stop stops the gRPC server. Once Stop returns, the server stops accepting
// connection requests and closes all the connected connections.
func (s *Server) Stop() {
s.mu.Lock()
listeners := s.lis
s.lis = nil
cs := s.conns
s.conns = nil
s.mu.Unlock()
for lis := range listeners {
lis.Close()
}
for c := range cs {
c.Close()
}
}
// TestingCloseConns closes all exiting transports but keeps s.lis accepting new
// connections. This is for test only now.
func (s *Server) TestingCloseConns() {
s.mu.Lock()
for c := range s.conns {
c.Close()
}
s.conns = make(map[transport.ServerTransport]bool)
s.mu.Unlock()
}
// SendHeader sends header metadata. It may be called at most once from a unary
// RPC handler. The ctx is the RPC handler's Context or one derived from it.
func SendHeader(ctx context.Context, md metadata.MD) error {
if md.Len() == 0 {
return nil
}
stream, ok := transport.StreamFromContext(ctx)
if !ok {
return fmt.Errorf("grpc: failed to fetch the stream from the context %v", ctx)
}
t := stream.ServerTransport()
if t == nil {
grpclog.Fatalf("grpc: SendHeader: %v has no ServerTransport to send header metadata.", stream)
}
return t.WriteHeader(stream, md)
}
// SetTrailer sets the trailer metadata that will be sent when an RPC returns.
// It may be called at most once from a unary RPC handler. The ctx is the RPC
// handler's Context or one derived from it.
func SetTrailer(ctx context.Context, md metadata.MD) error {
if md.Len() == 0 {
return nil
}
stream, ok := transport.StreamFromContext(ctx)
if !ok {
return fmt.Errorf("grpc: failed to fetch the stream from the context %v", ctx)
}
return stream.SetTrailer(md)
}
================================================
FILE: vendor/google.golang.org/grpc/stream.go
================================================
/*
*
* Copyright 2014, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package grpc
import (
"errors"
"io"
"golang.org/x/net/context"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/metadata"
"google.golang.org/grpc/transport"
)
type streamHandler func(srv interface{}, stream ServerStream) error
// StreamDesc represents a streaming RPC service's method specification.
type StreamDesc struct {
StreamName string
Handler streamHandler
// At least one of these is true.
ServerStreams bool
ClientStreams bool
}
// Stream defines the common interface a client or server stream has to satisfy.
type Stream interface {
// Context returns the context for this stream.
Context() context.Context
// SendMsg blocks until it sends m, the stream is done or the stream
// breaks.
// On error, it aborts the stream and returns an RPC status on client
// side. On server side, it simply returns the error to the caller.
// SendMsg is called by generated code.
SendMsg(m interface{}) error
// RecvMsg blocks until it receives a message or the stream is
// done. On client side, it returns io.EOF when the stream is done. On
// any other error, it aborts the streama nd returns an RPC status. On
// server side, it simply returns the error to the caller.
RecvMsg(m interface{}) error
}
// ClientStream defines the interface a client stream has to satify.
type ClientStream interface {
// Header returns the header metedata received from the server if there
// is any. It blocks if the metadata is not ready to read.
Header() (metadata.MD, error)
// Trailer returns the trailer metadata from the server. It must be called
// after stream.Recv() returns non-nil error (including io.EOF) for
// bi-directional streaming and server streaming or stream.CloseAndRecv()
// returns for client streaming in order to receive trailer metadata if
// present. Otherwise, it could returns an empty MD even though trailer
// is present.
Trailer() metadata.MD
// CloseSend closes the send direction of the stream. It closes the stream
// when non-nil error is met.
CloseSend() error
Stream
}
// NewClientStream creates a new Stream for the client side. This is called
// by generated code.
func NewClientStream(ctx context.Context, desc *StreamDesc, cc *ClientConn, method string, opts ...CallOption) (ClientStream, error) {
// TODO(zhaoq): CallOption is omitted. Add support when it is needed.
callHdr := &transport.CallHdr{
Host: cc.authority,
Method: method,
}
t, _, err := cc.wait(ctx, 0)
if err != nil {
return nil, toRPCErr(err)
}
s, err := t.NewStream(ctx, callHdr)
if err != nil {
return nil, toRPCErr(err)
}
return &clientStream{
t: t,
s: s,
p: &parser{s: s},
desc: desc,
codec: cc.dopts.codec,
}, nil
}
// clientStream implements a client side Stream.
type clientStream struct {
t transport.ClientTransport
s *transport.Stream
p *parser
desc *StreamDesc
codec Codec
}
func (cs *clientStream) Context() context.Context {
return cs.s.Context()
}
func (cs *clientStream) Header() (metadata.MD, error) {
m, err := cs.s.Header()
if err != nil {
if _, ok := err.(transport.ConnectionError); !ok {
cs.t.CloseStream(cs.s, err)
}
}
return m, err
}
func (cs *clientStream) Trailer() metadata.MD {
return cs.s.Trailer()
}
func (cs *clientStream) SendMsg(m interface{}) (err error) {
defer func() {
if err == nil || err == io.EOF {
return
}
if _, ok := err.(transport.ConnectionError); !ok {
cs.t.CloseStream(cs.s, err)
}
err = toRPCErr(err)
}()
out, err := encode(cs.codec, m, compressionNone)
if err != nil {
return transport.StreamErrorf(codes.Internal, "grpc: %v", err)
}
return cs.t.Write(cs.s, out, &transport.Options{Last: false})
}
func (cs *clientStream) RecvMsg(m interface{}) (err error) {
err = recv(cs.p, cs.codec, m)
if err == nil {
if !cs.desc.ClientStreams || cs.desc.ServerStreams {
return
}
// Special handling for client streaming rpc.
err = recv(cs.p, cs.codec, m)
cs.t.CloseStream(cs.s, err)
if err == nil {
return toRPCErr(errors.New("grpc: client streaming protocol violation: get , want "))
}
if err == io.EOF {
if cs.s.StatusCode() == codes.OK {
return nil
}
return Errorf(cs.s.StatusCode(), cs.s.StatusDesc())
}
return toRPCErr(err)
}
if _, ok := err.(transport.ConnectionError); !ok {
cs.t.CloseStream(cs.s, err)
}
if err == io.EOF {
if cs.s.StatusCode() == codes.OK {
// Returns io.EOF to indicate the end of the stream.
return
}
return Errorf(cs.s.StatusCode(), cs.s.StatusDesc())
}
return toRPCErr(err)
}
func (cs *clientStream) CloseSend() (err error) {
err = cs.t.Write(cs.s, nil, &transport.Options{Last: true})
if err == nil || err == io.EOF {
return
}
if _, ok := err.(transport.ConnectionError); !ok {
cs.t.CloseStream(cs.s, err)
}
err = toRPCErr(err)
return
}
// ServerStream defines the interface a server stream has to satisfy.
type ServerStream interface {
// SendHeader sends the header metadata. It should not be called
// after SendProto. It fails if called multiple times or if
// called after SendProto.
SendHeader(metadata.MD) error
// SetTrailer sets the trailer metadata which will be sent with the
// RPC status.
SetTrailer(metadata.MD)
Stream
}
// serverStream implements a server side Stream.
type serverStream struct {
t transport.ServerTransport
s *transport.Stream
p *parser
codec Codec
statusCode codes.Code
statusDesc string
}
func (ss *serverStream) Context() context.Context {
return ss.s.Context()
}
func (ss *serverStream) SendHeader(md metadata.MD) error {
return ss.t.WriteHeader(ss.s, md)
}
func (ss *serverStream) SetTrailer(md metadata.MD) {
if md.Len() == 0 {
return
}
ss.s.SetTrailer(md)
return
}
func (ss *serverStream) SendMsg(m interface{}) error {
out, err := encode(ss.codec, m, compressionNone)
if err != nil {
err = transport.StreamErrorf(codes.Internal, "grpc: %v", err)
return err
}
return ss.t.Write(ss.s, out, &transport.Options{Last: false})
}
func (ss *serverStream) RecvMsg(m interface{}) error {
return recv(ss.p, ss.codec, m)
}
================================================
FILE: vendor/google.golang.org/grpc/test/codec_perf/perf.pb.go
================================================
// Code generated by protoc-gen-go.
// source: perf.proto
// DO NOT EDIT!
/*
Package codec_perf is a generated protocol buffer package.
It is generated from these files:
perf.proto
It has these top-level messages:
Buffer
*/
package codec_perf
import proto "github.com/golang/protobuf/proto"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = math.Inf
// Buffer is a message that contains a body of bytes that is used to exercise
// encoding and decoding overheads.
type Buffer struct {
Body []byte `protobuf:"bytes,1,opt,name=body" json:"body,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Buffer) Reset() { *m = Buffer{} }
func (m *Buffer) String() string { return proto.CompactTextString(m) }
func (*Buffer) ProtoMessage() {}
func (m *Buffer) GetBody() []byte {
if m != nil {
return m.Body
}
return nil
}
func init() {
}
================================================
FILE: vendor/google.golang.org/grpc/test/codec_perf/perf.proto
================================================
// Messages used for performance tests that may not reference grpc directly for
// reasons of import cycles.
syntax = "proto2";
package codec.perf;
// Buffer is a message that contains a body of bytes that is used to exercise
// encoding and decoding overheads.
message Buffer {
optional bytes body = 1;
}
================================================
FILE: vendor/google.golang.org/grpc/test/grpc_testing/test.pb.go
================================================
// Code generated by protoc-gen-go.
// source: src/google.golang.org/grpc/test/grpc_testing/test.proto
// DO NOT EDIT!
/*
Package grpc_testing is a generated protocol buffer package.
It is generated from these files:
src/google.golang.org/grpc/test/grpc_testing/test.proto
It has these top-level messages:
Empty
Payload
SimpleRequest
SimpleResponse
StreamingInputCallRequest
StreamingInputCallResponse
ResponseParameters
StreamingOutputCallRequest
StreamingOutputCallResponse
*/
package grpc_testing
import proto "github.com/golang/protobuf/proto"
import math "math"
import (
context "golang.org/x/net/context"
grpc "google.golang.org/grpc"
)
// Reference imports to suppress errors if they are not otherwise used.
var _ context.Context
var _ grpc.ClientConn
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = math.Inf
// The type of payload that should be returned.
type PayloadType int32
const (
// Compressable text format.
PayloadType_COMPRESSABLE PayloadType = 0
// Uncompressable binary format.
PayloadType_UNCOMPRESSABLE PayloadType = 1
// Randomly chosen from all other formats defined in this enum.
PayloadType_RANDOM PayloadType = 2
)
var PayloadType_name = map[int32]string{
0: "COMPRESSABLE",
1: "UNCOMPRESSABLE",
2: "RANDOM",
}
var PayloadType_value = map[string]int32{
"COMPRESSABLE": 0,
"UNCOMPRESSABLE": 1,
"RANDOM": 2,
}
func (x PayloadType) Enum() *PayloadType {
p := new(PayloadType)
*p = x
return p
}
func (x PayloadType) String() string {
return proto.EnumName(PayloadType_name, int32(x))
}
func (x *PayloadType) UnmarshalJSON(data []byte) error {
value, err := proto.UnmarshalJSONEnum(PayloadType_value, data, "PayloadType")
if err != nil {
return err
}
*x = PayloadType(value)
return nil
}
type Empty struct {
XXX_unrecognized []byte `json:"-"`
}
func (m *Empty) Reset() { *m = Empty{} }
func (m *Empty) String() string { return proto.CompactTextString(m) }
func (*Empty) ProtoMessage() {}
// A block of data, to simply increase gRPC message size.
type Payload struct {
// The type of data in body.
Type *PayloadType `protobuf:"varint,1,opt,name=type,enum=grpc.testing.PayloadType" json:"type,omitempty"`
// Primary contents of payload.
Body []byte `protobuf:"bytes,2,opt,name=body" json:"body,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *Payload) Reset() { *m = Payload{} }
func (m *Payload) String() string { return proto.CompactTextString(m) }
func (*Payload) ProtoMessage() {}
func (m *Payload) GetType() PayloadType {
if m != nil && m.Type != nil {
return *m.Type
}
return PayloadType_COMPRESSABLE
}
func (m *Payload) GetBody() []byte {
if m != nil {
return m.Body
}
return nil
}
// Unary request.
type SimpleRequest struct {
// Desired payload type in the response from the server.
// If response_type is RANDOM, server randomly chooses one from other formats.
ResponseType *PayloadType `protobuf:"varint,1,opt,name=response_type,enum=grpc.testing.PayloadType" json:"response_type,omitempty"`
// Desired payload size in the response from the server.
// If response_type is COMPRESSABLE, this denotes the size before compression.
ResponseSize *int32 `protobuf:"varint,2,opt,name=response_size" json:"response_size,omitempty"`
// Optional input payload sent along with the request.
Payload *Payload `protobuf:"bytes,3,opt,name=payload" json:"payload,omitempty"`
// Whether SimpleResponse should include username.
FillUsername *bool `protobuf:"varint,4,opt,name=fill_username" json:"fill_username,omitempty"`
// Whether SimpleResponse should include OAuth scope.
FillOauthScope *bool `protobuf:"varint,5,opt,name=fill_oauth_scope" json:"fill_oauth_scope,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *SimpleRequest) Reset() { *m = SimpleRequest{} }
func (m *SimpleRequest) String() string { return proto.CompactTextString(m) }
func (*SimpleRequest) ProtoMessage() {}
func (m *SimpleRequest) GetResponseType() PayloadType {
if m != nil && m.ResponseType != nil {
return *m.ResponseType
}
return PayloadType_COMPRESSABLE
}
func (m *SimpleRequest) GetResponseSize() int32 {
if m != nil && m.ResponseSize != nil {
return *m.ResponseSize
}
return 0
}
func (m *SimpleRequest) GetPayload() *Payload {
if m != nil {
return m.Payload
}
return nil
}
func (m *SimpleRequest) GetFillUsername() bool {
if m != nil && m.FillUsername != nil {
return *m.FillUsername
}
return false
}
func (m *SimpleRequest) GetFillOauthScope() bool {
if m != nil && m.FillOauthScope != nil {
return *m.FillOauthScope
}
return false
}
// Unary response, as configured by the request.
type SimpleResponse struct {
// Payload to increase message size.
Payload *Payload `protobuf:"bytes,1,opt,name=payload" json:"payload,omitempty"`
// The user the request came from, for verifying authentication was
// successful when the client expected it.
Username *string `protobuf:"bytes,2,opt,name=username" json:"username,omitempty"`
// OAuth scope.
OauthScope *string `protobuf:"bytes,3,opt,name=oauth_scope" json:"oauth_scope,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *SimpleResponse) Reset() { *m = SimpleResponse{} }
func (m *SimpleResponse) String() string { return proto.CompactTextString(m) }
func (*SimpleResponse) ProtoMessage() {}
func (m *SimpleResponse) GetPayload() *Payload {
if m != nil {
return m.Payload
}
return nil
}
func (m *SimpleResponse) GetUsername() string {
if m != nil && m.Username != nil {
return *m.Username
}
return ""
}
func (m *SimpleResponse) GetOauthScope() string {
if m != nil && m.OauthScope != nil {
return *m.OauthScope
}
return ""
}
// Client-streaming request.
type StreamingInputCallRequest struct {
// Optional input payload sent along with the request.
Payload *Payload `protobuf:"bytes,1,opt,name=payload" json:"payload,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *StreamingInputCallRequest) Reset() { *m = StreamingInputCallRequest{} }
func (m *StreamingInputCallRequest) String() string { return proto.CompactTextString(m) }
func (*StreamingInputCallRequest) ProtoMessage() {}
func (m *StreamingInputCallRequest) GetPayload() *Payload {
if m != nil {
return m.Payload
}
return nil
}
// Client-streaming response.
type StreamingInputCallResponse struct {
// Aggregated size of payloads received from the client.
AggregatedPayloadSize *int32 `protobuf:"varint,1,opt,name=aggregated_payload_size" json:"aggregated_payload_size,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *StreamingInputCallResponse) Reset() { *m = StreamingInputCallResponse{} }
func (m *StreamingInputCallResponse) String() string { return proto.CompactTextString(m) }
func (*StreamingInputCallResponse) ProtoMessage() {}
func (m *StreamingInputCallResponse) GetAggregatedPayloadSize() int32 {
if m != nil && m.AggregatedPayloadSize != nil {
return *m.AggregatedPayloadSize
}
return 0
}
// Configuration for a particular response.
type ResponseParameters struct {
// Desired payload sizes in responses from the server.
// If response_type is COMPRESSABLE, this denotes the size before compression.
Size *int32 `protobuf:"varint,1,opt,name=size" json:"size,omitempty"`
// Desired interval between consecutive responses in the response stream in
// microseconds.
IntervalUs *int32 `protobuf:"varint,2,opt,name=interval_us" json:"interval_us,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *ResponseParameters) Reset() { *m = ResponseParameters{} }
func (m *ResponseParameters) String() string { return proto.CompactTextString(m) }
func (*ResponseParameters) ProtoMessage() {}
func (m *ResponseParameters) GetSize() int32 {
if m != nil && m.Size != nil {
return *m.Size
}
return 0
}
func (m *ResponseParameters) GetIntervalUs() int32 {
if m != nil && m.IntervalUs != nil {
return *m.IntervalUs
}
return 0
}
// Server-streaming request.
type StreamingOutputCallRequest struct {
// Desired payload type in the response from the server.
// If response_type is RANDOM, the payload from each response in the stream
// might be of different types. This is to simulate a mixed type of payload
// stream.
ResponseType *PayloadType `protobuf:"varint,1,opt,name=response_type,enum=grpc.testing.PayloadType" json:"response_type,omitempty"`
// Configuration for each expected response message.
ResponseParameters []*ResponseParameters `protobuf:"bytes,2,rep,name=response_parameters" json:"response_parameters,omitempty"`
// Optional input payload sent along with the request.
Payload *Payload `protobuf:"bytes,3,opt,name=payload" json:"payload,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *StreamingOutputCallRequest) Reset() { *m = StreamingOutputCallRequest{} }
func (m *StreamingOutputCallRequest) String() string { return proto.CompactTextString(m) }
func (*StreamingOutputCallRequest) ProtoMessage() {}
func (m *StreamingOutputCallRequest) GetResponseType() PayloadType {
if m != nil && m.ResponseType != nil {
return *m.ResponseType
}
return PayloadType_COMPRESSABLE
}
func (m *StreamingOutputCallRequest) GetResponseParameters() []*ResponseParameters {
if m != nil {
return m.ResponseParameters
}
return nil
}
func (m *StreamingOutputCallRequest) GetPayload() *Payload {
if m != nil {
return m.Payload
}
return nil
}
// Server-streaming response, as configured by the request and parameters.
type StreamingOutputCallResponse struct {
// Payload to increase response size.
Payload *Payload `protobuf:"bytes,1,opt,name=payload" json:"payload,omitempty"`
XXX_unrecognized []byte `json:"-"`
}
func (m *StreamingOutputCallResponse) Reset() { *m = StreamingOutputCallResponse{} }
func (m *StreamingOutputCallResponse) String() string { return proto.CompactTextString(m) }
func (*StreamingOutputCallResponse) ProtoMessage() {}
func (m *StreamingOutputCallResponse) GetPayload() *Payload {
if m != nil {
return m.Payload
}
return nil
}
func init() {
proto.RegisterEnum("grpc.testing.PayloadType", PayloadType_name, PayloadType_value)
}
// Client API for TestService service
type TestServiceClient interface {
// One empty request followed by one empty response.
EmptyCall(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error)
// One request followed by one response.
// The server returns the client payload as-is.
UnaryCall(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error)
// One request followed by a sequence of responses (streamed download).
// The server returns the payload with client desired type and sizes.
StreamingOutputCall(ctx context.Context, in *StreamingOutputCallRequest, opts ...grpc.CallOption) (TestService_StreamingOutputCallClient, error)
// A sequence of requests followed by one response (streamed upload).
// The server returns the aggregated size of client payload as the result.
StreamingInputCall(ctx context.Context, opts ...grpc.CallOption) (TestService_StreamingInputCallClient, error)
// A sequence of requests with each request served by the server immediately.
// As one request could lead to multiple responses, this interface
// demonstrates the idea of full duplexing.
FullDuplexCall(ctx context.Context, opts ...grpc.CallOption) (TestService_FullDuplexCallClient, error)
// A sequence of requests followed by a sequence of responses.
// The server buffers all the client requests and then serves them in order. A
// stream of responses are returned to the client when the server starts with
// first request.
HalfDuplexCall(ctx context.Context, opts ...grpc.CallOption) (TestService_HalfDuplexCallClient, error)
}
type testServiceClient struct {
cc *grpc.ClientConn
}
func NewTestServiceClient(cc *grpc.ClientConn) TestServiceClient {
return &testServiceClient{cc}
}
func (c *testServiceClient) EmptyCall(ctx context.Context, in *Empty, opts ...grpc.CallOption) (*Empty, error) {
out := new(Empty)
err := grpc.Invoke(ctx, "/grpc.testing.TestService/EmptyCall", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *testServiceClient) UnaryCall(ctx context.Context, in *SimpleRequest, opts ...grpc.CallOption) (*SimpleResponse, error) {
out := new(SimpleResponse)
err := grpc.Invoke(ctx, "/grpc.testing.TestService/UnaryCall", in, out, c.cc, opts...)
if err != nil {
return nil, err
}
return out, nil
}
func (c *testServiceClient) StreamingOutputCall(ctx context.Context, in *StreamingOutputCallRequest, opts ...grpc.CallOption) (TestService_StreamingOutputCallClient, error) {
stream, err := grpc.NewClientStream(ctx, &_TestService_serviceDesc.Streams[0], c.cc, "/grpc.testing.TestService/StreamingOutputCall", opts...)
if err != nil {
return nil, err
}
x := &testServiceStreamingOutputCallClient{stream}
if err := x.ClientStream.SendMsg(in); err != nil {
return nil, err
}
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
return x, nil
}
type TestService_StreamingOutputCallClient interface {
Recv() (*StreamingOutputCallResponse, error)
grpc.ClientStream
}
type testServiceStreamingOutputCallClient struct {
grpc.ClientStream
}
func (x *testServiceStreamingOutputCallClient) Recv() (*StreamingOutputCallResponse, error) {
m := new(StreamingOutputCallResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *testServiceClient) StreamingInputCall(ctx context.Context, opts ...grpc.CallOption) (TestService_StreamingInputCallClient, error) {
stream, err := grpc.NewClientStream(ctx, &_TestService_serviceDesc.Streams[1], c.cc, "/grpc.testing.TestService/StreamingInputCall", opts...)
if err != nil {
return nil, err
}
x := &testServiceStreamingInputCallClient{stream}
return x, nil
}
type TestService_StreamingInputCallClient interface {
Send(*StreamingInputCallRequest) error
CloseAndRecv() (*StreamingInputCallResponse, error)
grpc.ClientStream
}
type testServiceStreamingInputCallClient struct {
grpc.ClientStream
}
func (x *testServiceStreamingInputCallClient) Send(m *StreamingInputCallRequest) error {
return x.ClientStream.SendMsg(m)
}
func (x *testServiceStreamingInputCallClient) CloseAndRecv() (*StreamingInputCallResponse, error) {
if err := x.ClientStream.CloseSend(); err != nil {
return nil, err
}
m := new(StreamingInputCallResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *testServiceClient) FullDuplexCall(ctx context.Context, opts ...grpc.CallOption) (TestService_FullDuplexCallClient, error) {
stream, err := grpc.NewClientStream(ctx, &_TestService_serviceDesc.Streams[2], c.cc, "/grpc.testing.TestService/FullDuplexCall", opts...)
if err != nil {
return nil, err
}
x := &testServiceFullDuplexCallClient{stream}
return x, nil
}
type TestService_FullDuplexCallClient interface {
Send(*StreamingOutputCallRequest) error
Recv() (*StreamingOutputCallResponse, error)
grpc.ClientStream
}
type testServiceFullDuplexCallClient struct {
grpc.ClientStream
}
func (x *testServiceFullDuplexCallClient) Send(m *StreamingOutputCallRequest) error {
return x.ClientStream.SendMsg(m)
}
func (x *testServiceFullDuplexCallClient) Recv() (*StreamingOutputCallResponse, error) {
m := new(StreamingOutputCallResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func (c *testServiceClient) HalfDuplexCall(ctx context.Context, opts ...grpc.CallOption) (TestService_HalfDuplexCallClient, error) {
stream, err := grpc.NewClientStream(ctx, &_TestService_serviceDesc.Streams[3], c.cc, "/grpc.testing.TestService/HalfDuplexCall", opts...)
if err != nil {
return nil, err
}
x := &testServiceHalfDuplexCallClient{stream}
return x, nil
}
type TestService_HalfDuplexCallClient interface {
Send(*StreamingOutputCallRequest) error
Recv() (*StreamingOutputCallResponse, error)
grpc.ClientStream
}
type testServiceHalfDuplexCallClient struct {
grpc.ClientStream
}
func (x *testServiceHalfDuplexCallClient) Send(m *StreamingOutputCallRequest) error {
return x.ClientStream.SendMsg(m)
}
func (x *testServiceHalfDuplexCallClient) Recv() (*StreamingOutputCallResponse, error) {
m := new(StreamingOutputCallResponse)
if err := x.ClientStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
// Server API for TestService service
type TestServiceServer interface {
// One empty request followed by one empty response.
EmptyCall(context.Context, *Empty) (*Empty, error)
// One request followed by one response.
// The server returns the client payload as-is.
UnaryCall(context.Context, *SimpleRequest) (*SimpleResponse, error)
// One request followed by a sequence of responses (streamed download).
// The server returns the payload with client desired type and sizes.
StreamingOutputCall(*StreamingOutputCallRequest, TestService_StreamingOutputCallServer) error
// A sequence of requests followed by one response (streamed upload).
// The server returns the aggregated size of client payload as the result.
StreamingInputCall(TestService_StreamingInputCallServer) error
// A sequence of requests with each request served by the server immediately.
// As one request could lead to multiple responses, this interface
// demonstrates the idea of full duplexing.
FullDuplexCall(TestService_FullDuplexCallServer) error
// A sequence of requests followed by a sequence of responses.
// The server buffers all the client requests and then serves them in order. A
// stream of responses are returned to the client when the server starts with
// first request.
HalfDuplexCall(TestService_HalfDuplexCallServer) error
}
func RegisterTestServiceServer(s *grpc.Server, srv TestServiceServer) {
s.RegisterService(&_TestService_serviceDesc, srv)
}
func _TestService_EmptyCall_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
in := new(Empty)
if err := codec.Unmarshal(buf, in); err != nil {
return nil, err
}
out, err := srv.(TestServiceServer).EmptyCall(ctx, in)
if err != nil {
return nil, err
}
return out, nil
}
func _TestService_UnaryCall_Handler(srv interface{}, ctx context.Context, codec grpc.Codec, buf []byte) (interface{}, error) {
in := new(SimpleRequest)
if err := codec.Unmarshal(buf, in); err != nil {
return nil, err
}
out, err := srv.(TestServiceServer).UnaryCall(ctx, in)
if err != nil {
return nil, err
}
return out, nil
}
func _TestService_StreamingOutputCall_Handler(srv interface{}, stream grpc.ServerStream) error {
m := new(StreamingOutputCallRequest)
if err := stream.RecvMsg(m); err != nil {
return err
}
return srv.(TestServiceServer).StreamingOutputCall(m, &testServiceStreamingOutputCallServer{stream})
}
type TestService_StreamingOutputCallServer interface {
Send(*StreamingOutputCallResponse) error
grpc.ServerStream
}
type testServiceStreamingOutputCallServer struct {
grpc.ServerStream
}
func (x *testServiceStreamingOutputCallServer) Send(m *StreamingOutputCallResponse) error {
return x.ServerStream.SendMsg(m)
}
func _TestService_StreamingInputCall_Handler(srv interface{}, stream grpc.ServerStream) error {
return srv.(TestServiceServer).StreamingInputCall(&testServiceStreamingInputCallServer{stream})
}
type TestService_StreamingInputCallServer interface {
SendAndClose(*StreamingInputCallResponse) error
Recv() (*StreamingInputCallRequest, error)
grpc.ServerStream
}
type testServiceStreamingInputCallServer struct {
grpc.ServerStream
}
func (x *testServiceStreamingInputCallServer) SendAndClose(m *StreamingInputCallResponse) error {
return x.ServerStream.SendMsg(m)
}
func (x *testServiceStreamingInputCallServer) Recv() (*StreamingInputCallRequest, error) {
m := new(StreamingInputCallRequest)
if err := x.ServerStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func _TestService_FullDuplexCall_Handler(srv interface{}, stream grpc.ServerStream) error {
return srv.(TestServiceServer).FullDuplexCall(&testServiceFullDuplexCallServer{stream})
}
type TestService_FullDuplexCallServer interface {
Send(*StreamingOutputCallResponse) error
Recv() (*StreamingOutputCallRequest, error)
grpc.ServerStream
}
type testServiceFullDuplexCallServer struct {
grpc.ServerStream
}
func (x *testServiceFullDuplexCallServer) Send(m *StreamingOutputCallResponse) error {
return x.ServerStream.SendMsg(m)
}
func (x *testServiceFullDuplexCallServer) Recv() (*StreamingOutputCallRequest, error) {
m := new(StreamingOutputCallRequest)
if err := x.ServerStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
func _TestService_HalfDuplexCall_Handler(srv interface{}, stream grpc.ServerStream) error {
return srv.(TestServiceServer).HalfDuplexCall(&testServiceHalfDuplexCallServer{stream})
}
type TestService_HalfDuplexCallServer interface {
Send(*StreamingOutputCallResponse) error
Recv() (*StreamingOutputCallRequest, error)
grpc.ServerStream
}
type testServiceHalfDuplexCallServer struct {
grpc.ServerStream
}
func (x *testServiceHalfDuplexCallServer) Send(m *StreamingOutputCallResponse) error {
return x.ServerStream.SendMsg(m)
}
func (x *testServiceHalfDuplexCallServer) Recv() (*StreamingOutputCallRequest, error) {
m := new(StreamingOutputCallRequest)
if err := x.ServerStream.RecvMsg(m); err != nil {
return nil, err
}
return m, nil
}
var _TestService_serviceDesc = grpc.ServiceDesc{
ServiceName: "grpc.testing.TestService",
HandlerType: (*TestServiceServer)(nil),
Methods: []grpc.MethodDesc{
{
MethodName: "EmptyCall",
Handler: _TestService_EmptyCall_Handler,
},
{
MethodName: "UnaryCall",
Handler: _TestService_UnaryCall_Handler,
},
},
Streams: []grpc.StreamDesc{
{
StreamName: "StreamingOutputCall",
Handler: _TestService_StreamingOutputCall_Handler,
ServerStreams: true,
},
{
StreamName: "StreamingInputCall",
Handler: _TestService_StreamingInputCall_Handler,
ClientStreams: true,
},
{
StreamName: "FullDuplexCall",
Handler: _TestService_FullDuplexCall_Handler,
ServerStreams: true,
ClientStreams: true,
},
{
StreamName: "HalfDuplexCall",
Handler: _TestService_HalfDuplexCall_Handler,
ServerStreams: true,
ClientStreams: true,
},
},
}
================================================
FILE: vendor/google.golang.org/grpc/test/grpc_testing/test.proto
================================================
// An integration test service that covers all the method signature permutations
// of unary/streaming requests/responses.
syntax = "proto2";
package grpc.testing;
message Empty {}
// The type of payload that should be returned.
enum PayloadType {
// Compressable text format.
COMPRESSABLE = 0;
// Uncompressable binary format.
UNCOMPRESSABLE = 1;
// Randomly chosen from all other formats defined in this enum.
RANDOM = 2;
}
// A block of data, to simply increase gRPC message size.
message Payload {
// The type of data in body.
optional PayloadType type = 1;
// Primary contents of payload.
optional bytes body = 2;
}
// Unary request.
message SimpleRequest {
// Desired payload type in the response from the server.
// If response_type is RANDOM, server randomly chooses one from other formats.
optional PayloadType response_type = 1;
// Desired payload size in the response from the server.
// If response_type is COMPRESSABLE, this denotes the size before compression.
optional int32 response_size = 2;
// Optional input payload sent along with the request.
optional Payload payload = 3;
// Whether SimpleResponse should include username.
optional bool fill_username = 4;
// Whether SimpleResponse should include OAuth scope.
optional bool fill_oauth_scope = 5;
}
// Unary response, as configured by the request.
message SimpleResponse {
// Payload to increase message size.
optional Payload payload = 1;
// The user the request came from, for verifying authentication was
// successful when the client expected it.
optional string username = 2;
// OAuth scope.
optional string oauth_scope = 3;
}
// Client-streaming request.
message StreamingInputCallRequest {
// Optional input payload sent along with the request.
optional Payload payload = 1;
// Not expecting any payload from the response.
}
// Client-streaming response.
message StreamingInputCallResponse {
// Aggregated size of payloads received from the client.
optional int32 aggregated_payload_size = 1;
}
// Configuration for a particular response.
message ResponseParameters {
// Desired payload sizes in responses from the server.
// If response_type is COMPRESSABLE, this denotes the size before compression.
optional int32 size = 1;
// Desired interval between consecutive responses in the response stream in
// microseconds.
optional int32 interval_us = 2;
}
// Server-streaming request.
message StreamingOutputCallRequest {
// Desired payload type in the response from the server.
// If response_type is RANDOM, the payload from each response in the stream
// might be of different types. This is to simulate a mixed type of payload
// stream.
optional PayloadType response_type = 1;
// Configuration for each expected response message.
repeated ResponseParameters response_parameters = 2;
// Optional input payload sent along with the request.
optional Payload payload = 3;
}
// Server-streaming response, as configured by the request and parameters.
message StreamingOutputCallResponse {
// Payload to increase response size.
optional Payload payload = 1;
}
// A simple service to test the various types of RPCs and experiment with
// performance with various types of payload.
service TestService {
// One empty request followed by one empty response.
rpc EmptyCall(Empty) returns (Empty);
// One request followed by one response.
// The server returns the client payload as-is.
rpc UnaryCall(SimpleRequest) returns (SimpleResponse);
// One request followed by a sequence of responses (streamed download).
// The server returns the payload with client desired type and sizes.
rpc StreamingOutputCall(StreamingOutputCallRequest)
returns (stream StreamingOutputCallResponse);
// A sequence of requests followed by one response (streamed upload).
// The server returns the aggregated size of client payload as the result.
rpc StreamingInputCall(stream StreamingInputCallRequest)
returns (StreamingInputCallResponse);
// A sequence of requests with each request served by the server immediately.
// As one request could lead to multiple responses, this interface
// demonstrates the idea of full duplexing.
rpc FullDuplexCall(stream StreamingOutputCallRequest)
returns (stream StreamingOutputCallResponse);
// A sequence of requests followed by a sequence of responses.
// The server buffers all the client requests and then serves them in order. A
// stream of responses are returned to the client when the server starts with
// first request.
rpc HalfDuplexCall(stream StreamingOutputCallRequest)
returns (stream StreamingOutputCallResponse);
}
================================================
FILE: vendor/google.golang.org/grpc/transport/control.go
================================================
/*
*
* Copyright 2014, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package transport
import (
"fmt"
"sync"
"github.com/bradfitz/http2"
)
const (
// The default value of flow control window size in HTTP2 spec.
defaultWindowSize = 65535
// The initial window size for flow control.
initialWindowSize = defaultWindowSize // for an RPC
initialConnWindowSize = defaultWindowSize * 16 // for a connection
)
// The following defines various control items which could flow through
// the control buffer of transport. They represent different aspects of
// control tasks, e.g., flow control, settings, streaming resetting, etc.
type windowUpdate struct {
streamID uint32
increment uint32
}
func (windowUpdate) isItem() bool {
return true
}
type settings struct {
ack bool
setting []http2.Setting
}
func (settings) isItem() bool {
return true
}
type resetStream struct {
streamID uint32
code http2.ErrCode
}
func (resetStream) isItem() bool {
return true
}
type flushIO struct {
}
func (flushIO) isItem() bool {
return true
}
type ping struct {
ack bool
}
func (ping) isItem() bool {
return true
}
// quotaPool is a pool which accumulates the quota and sends it to acquire()
// when it is available.
type quotaPool struct {
c chan int
mu sync.Mutex
quota int
}
// newQuotaPool creates a quotaPool which has quota q available to consume.
func newQuotaPool(q int) *quotaPool {
qb := "aPool{c: make(chan int, 1)}
qb.c <- q
return qb
}
// add adds n to the available quota and tries to send it on acquire.
func (qb *quotaPool) add(n int) {
qb.mu.Lock()
defer qb.mu.Unlock()
qb.quota += n
if qb.quota <= 0 {
return
}
select {
case qb.c <- qb.quota:
qb.quota = 0
default:
}
}
// cancel cancels the pending quota sent on acquire, if any.
func (qb *quotaPool) cancel() {
qb.mu.Lock()
defer qb.mu.Unlock()
select {
case n := <-qb.c:
qb.quota += n
default:
}
}
// reset cancels the pending quota sent on acquired, incremented by v and sends
// it back on acquire.
func (qb *quotaPool) reset(v int) {
qb.mu.Lock()
defer qb.mu.Unlock()
select {
case n := <-qb.c:
qb.quota += n
default:
}
qb.quota += v
if qb.quota <= 0 {
return
}
select {
case qb.c <- qb.quota:
qb.quota = 0
default:
}
}
// acquire returns the channel on which available quota amounts are sent.
func (qb *quotaPool) acquire() <-chan int {
return qb.c
}
// inFlow deals with inbound flow control
type inFlow struct {
// The inbound flow control limit for pending data.
limit uint32
// conn points to the shared connection-level inFlow that is shared
// by all streams on that conn. It is nil for the inFlow on the conn
// directly.
conn *inFlow
mu sync.Mutex
// pendingData is the overall data which have been received but not been
// consumed by applications.
pendingData uint32
// The amount of data the application has consumed but grpc has not sent
// window update for them. Used to reduce window update frequency.
pendingUpdate uint32
}
// onData is invoked when some data frame is received. It increments not only its
// own pendingData but also that of the associated connection-level flow.
func (f *inFlow) onData(n uint32) error {
if n == 0 {
return nil
}
f.mu.Lock()
defer f.mu.Unlock()
if f.pendingData+f.pendingUpdate+n > f.limit {
return fmt.Errorf("recieved %d-bytes data exceeding the limit %d bytes", f.pendingData+f.pendingUpdate+n, f.limit)
}
if f.conn != nil {
if err := f.conn.onData(n); err != nil {
return ConnectionErrorf("%v", err)
}
}
f.pendingData += n
return nil
}
// connOnRead updates the connection level states when the application consumes data.
func (f *inFlow) connOnRead(n uint32) uint32 {
if n == 0 || f.conn != nil {
return 0
}
f.mu.Lock()
defer f.mu.Unlock()
f.pendingData -= n
f.pendingUpdate += n
if f.pendingUpdate >= f.limit/4 {
ret := f.pendingUpdate
f.pendingUpdate = 0
return ret
}
return 0
}
// onRead is invoked when the application reads the data. It returns the window updates
// for both stream and connection level.
func (f *inFlow) onRead(n uint32) (swu, cwu uint32) {
if n == 0 {
return
}
f.mu.Lock()
defer f.mu.Unlock()
if f.pendingData == 0 {
// pendingData has been adjusted by restoreConn.
return
}
f.pendingData -= n
f.pendingUpdate += n
if f.pendingUpdate >= f.limit/4 {
swu = f.pendingUpdate
f.pendingUpdate = 0
}
cwu = f.conn.connOnRead(n)
return
}
// restoreConn is invoked when a stream is terminated. It removes its stake in
// the connection-level flow and resets its own state.
func (f *inFlow) restoreConn() uint32 {
if f.conn == nil {
return 0
}
f.mu.Lock()
defer f.mu.Unlock()
n := f.pendingData
f.pendingData = 0
f.pendingUpdate = 0
return f.conn.connOnRead(n)
}
================================================
FILE: vendor/google.golang.org/grpc/transport/http2_client.go
================================================
/*
*
* Copyright 2014, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package transport
import (
"bytes"
"errors"
"io"
"math"
"net"
"sync"
"time"
"github.com/bradfitz/http2"
"github.com/bradfitz/http2/hpack"
"golang.org/x/net/context"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/credentials"
"google.golang.org/grpc/grpclog"
"google.golang.org/grpc/metadata"
)
// http2Client implements the ClientTransport interface with HTTP2.
type http2Client struct {
target string // server name/addr
conn net.Conn // underlying communication channel
nextID uint32 // the next stream ID to be used
// writableChan synchronizes write access to the transport.
// A writer acquires the write lock by sending a value on writableChan
// and releases it by receiving from writableChan.
writableChan chan int
// shutdownChan is closed when Close is called.
// Blocking operations should select on shutdownChan to avoid
// blocking forever after Close.
// TODO(zhaoq): Maybe have a channel context?
shutdownChan chan struct{}
// errorChan is closed to notify the I/O error to the caller.
errorChan chan struct{}
framer *framer
hBuf *bytes.Buffer // the buffer for HPACK encoding
hEnc *hpack.Encoder // HPACK encoder
// controlBuf delivers all the control related tasks (e.g., window
// updates, reset streams, and various settings) to the controller.
controlBuf *recvBuffer
fc *inFlow
// sendQuotaPool provides flow control to outbound message.
sendQuotaPool *quotaPool
// streamsQuota limits the max number of concurrent streams.
streamsQuota *quotaPool
// The scheme used: https if TLS is on, http otherwise.
scheme string
authCreds []credentials.Credentials
mu sync.Mutex // guard the following variables
state transportState // the state of underlying connection
activeStreams map[uint32]*Stream
// The max number of concurrent streams
maxStreams int
// the per-stream outbound flow control window size set by the peer.
streamSendQuota uint32
}
// newHTTP2Client constructs a connected ClientTransport to addr based on HTTP2
// and starts to receive messages on it. Non-nil error returns if construction
// fails.
func newHTTP2Client(addr string, opts *ConnectOptions) (_ ClientTransport, err error) {
if opts.Dialer == nil {
// Set the default Dialer.
opts.Dialer = func(addr string, timeout time.Duration) (net.Conn, error) {
return net.DialTimeout("tcp", addr, timeout)
}
}
scheme := "http"
startT := time.Now()
timeout := opts.Timeout
conn, connErr := opts.Dialer(addr, timeout)
if connErr != nil {
return nil, ConnectionErrorf("transport: %v", connErr)
}
for _, c := range opts.AuthOptions {
if ccreds, ok := c.(credentials.TransportAuthenticator); ok {
scheme = "https"
// TODO(zhaoq): Now the first TransportAuthenticator is used if there are
// multiple ones provided. Revisit this if it is not appropriate. Probably
// place the ClientTransport construction into a separate function to make
// things clear.
if timeout > 0 {
timeout -= time.Since(startT)
}
conn, connErr = ccreds.ClientHandshake(addr, conn, timeout)
break
}
}
if connErr != nil {
return nil, ConnectionErrorf("transport: %v", connErr)
}
defer func() {
if err != nil {
conn.Close()
}
}()
// Send connection preface to server.
n, err := conn.Write(clientPreface)
if err != nil {
return nil, ConnectionErrorf("transport: %v", err)
}
if n != len(clientPreface) {
return nil, ConnectionErrorf("transport: preface mismatch, wrote %d bytes; want %d", n, len(clientPreface))
}
framer := newFramer(conn)
if initialWindowSize != defaultWindowSize {
err = framer.writeSettings(true, http2.Setting{http2.SettingInitialWindowSize, uint32(initialWindowSize)})
} else {
err = framer.writeSettings(true)
}
if err != nil {
return nil, ConnectionErrorf("transport: %v", err)
}
// Adjust the connection flow control window if needed.
if delta := uint32(initialConnWindowSize - defaultWindowSize); delta > 0 {
if err := framer.writeWindowUpdate(true, 0, delta); err != nil {
return nil, ConnectionErrorf("transport: %v", err)
}
}
var buf bytes.Buffer
t := &http2Client{
target: addr,
conn: conn,
// The client initiated stream id is odd starting from 1.
nextID: 1,
writableChan: make(chan int, 1),
shutdownChan: make(chan struct{}),
errorChan: make(chan struct{}),
framer: framer,
hBuf: &buf,
hEnc: hpack.NewEncoder(&buf),
controlBuf: newRecvBuffer(),
fc: &inFlow{limit: initialConnWindowSize},
sendQuotaPool: newQuotaPool(defaultWindowSize),
scheme: scheme,
state: reachable,
activeStreams: make(map[uint32]*Stream),
authCreds: opts.AuthOptions,
maxStreams: math.MaxInt32,
streamSendQuota: defaultWindowSize,
}
go t.controller()
t.writableChan <- 0
// Start the reader goroutine for incoming message. The threading model
// on receiving is that each transport has a dedicated goroutine which
// reads HTTP2 frame from network. Then it dispatches the frame to the
// corresponding stream entity.
go t.reader()
return t, nil
}
func (t *http2Client) newStream(ctx context.Context, callHdr *CallHdr, sq bool) *Stream {
fc := &inFlow{
limit: initialWindowSize,
conn: t.fc,
}
// TODO(zhaoq): Handle uint32 overflow of Stream.id.
s := &Stream{
id: t.nextID,
method: callHdr.Method,
buf: newRecvBuffer(),
updateStreams: sq,
fc: fc,
sendQuotaPool: newQuotaPool(int(t.streamSendQuota)),
headerChan: make(chan struct{}),
}
t.nextID += 2
s.windowHandler = func(n int) {
t.updateWindow(s, uint32(n))
}
// Make a stream be able to cancel the pending operations by itself.
s.ctx, s.cancel = context.WithCancel(ctx)
s.dec = &recvBufferReader{
ctx: s.ctx,
recv: s.buf,
}
return s
}
// NewStream creates a stream and register it into the transport as "active"
// streams.
func (t *http2Client) NewStream(ctx context.Context, callHdr *CallHdr) (_ *Stream, err error) {
// Record the timeout value on the context.
var timeout time.Duration
if dl, ok := ctx.Deadline(); ok {
timeout = dl.Sub(time.Now())
if timeout <= 0 {
return nil, ContextErr(context.DeadlineExceeded)
}
}
authData := make(map[string]string)
for _, c := range t.authCreds {
data, err := c.GetRequestMetadata(ctx)
if err != nil {
return nil, StreamErrorf(codes.InvalidArgument, "transport: %v", err)
}
for k, v := range data {
authData[k] = v
}
}
t.mu.Lock()
if t.state != reachable {
t.mu.Unlock()
return nil, ErrConnClosing
}
checkStreamsQuota := t.streamsQuota != nil
t.mu.Unlock()
if checkStreamsQuota {
sq, err := wait(ctx, t.shutdownChan, t.streamsQuota.acquire())
if err != nil {
return nil, err
}
// Returns the quota balance back.
if sq > 1 {
t.streamsQuota.add(sq - 1)
}
}
if _, err := wait(ctx, t.shutdownChan, t.writableChan); err != nil {
// t.streamsQuota will be updated when t.CloseStream is invoked.
return nil, err
}
t.mu.Lock()
s := t.newStream(ctx, callHdr, checkStreamsQuota)
t.activeStreams[s.id] = s
t.mu.Unlock()
// HPACK encodes various headers. Note that once WriteField(...) is
// called, the corresponding headers/continuation frame has to be sent
// because hpack.Encoder is stateful.
t.hBuf.Reset()
t.hEnc.WriteField(hpack.HeaderField{Name: ":method", Value: "POST"})
t.hEnc.WriteField(hpack.HeaderField{Name: ":scheme", Value: t.scheme})
t.hEnc.WriteField(hpack.HeaderField{Name: ":path", Value: callHdr.Method})
t.hEnc.WriteField(hpack.HeaderField{Name: ":authority", Value: callHdr.Host})
t.hEnc.WriteField(hpack.HeaderField{Name: "content-type", Value: "application/grpc"})
t.hEnc.WriteField(hpack.HeaderField{Name: "te", Value: "trailers"})
if timeout > 0 {
t.hEnc.WriteField(hpack.HeaderField{Name: "grpc-timeout", Value: timeoutEncode(timeout)})
}
for k, v := range authData {
t.hEnc.WriteField(hpack.HeaderField{Name: k, Value: v})
}
var (
hasMD bool
endHeaders bool
)
if md, ok := metadata.FromContext(ctx); ok {
hasMD = true
for k, v := range md {
t.hEnc.WriteField(hpack.HeaderField{Name: k, Value: v})
}
}
first := true
// Sends the headers in a single batch even when they span multiple frames.
for !endHeaders {
size := t.hBuf.Len()
if size > http2MaxFrameLen {
size = http2MaxFrameLen
} else {
endHeaders = true
}
if first {
// Sends a HeadersFrame to server to start a new stream.
p := http2.HeadersFrameParam{
StreamID: s.id,
BlockFragment: t.hBuf.Next(size),
EndStream: false,
EndHeaders: endHeaders,
}
// Do a force flush for the buffered frames iff it is the last headers frame
// and there is header metadata to be sent. Otherwise, there is flushing until
// the corresponding data frame is written.
err = t.framer.writeHeaders(hasMD && endHeaders, p)
first = false
} else {
// Sends Continuation frames for the leftover headers.
err = t.framer.writeContinuation(hasMD && endHeaders, s.id, endHeaders, t.hBuf.Next(size))
}
if err != nil {
t.notifyError(err)
return nil, ConnectionErrorf("transport: %v", err)
}
}
t.writableChan <- 0
return s, nil
}
// CloseStream clears the footprint of a stream when the stream is not needed any more.
// This must not be executed in reader's goroutine.
func (t *http2Client) CloseStream(s *Stream, err error) {
t.mu.Lock()
delete(t.activeStreams, s.id)
t.mu.Unlock()
if s.updateStreams {
t.streamsQuota.add(1)
}
s.mu.Lock()
if q := s.fc.restoreConn(); q > 0 {
t.controlBuf.put(&windowUpdate{0, q})
}
if s.state == streamDone {
s.mu.Unlock()
return
}
if !s.headerDone {
close(s.headerChan)
s.headerDone = true
}
s.state = streamDone
s.mu.Unlock()
// In case stream sending and receiving are invoked in separate
// goroutines (e.g., bi-directional streaming), the caller needs
// to call cancel on the stream to interrupt the blocking on
// other goroutines.
s.cancel()
if _, ok := err.(StreamError); ok {
t.controlBuf.put(&resetStream{s.id, http2.ErrCodeCancel})
}
}
// Close kicks off the shutdown process of the transport. This should be called
// only once on a transport. Once it is called, the transport should not be
// accessed any more.
func (t *http2Client) Close() (err error) {
t.mu.Lock()
if t.state == closing {
t.mu.Unlock()
return errors.New("transport: Close() was already called")
}
t.state = closing
t.mu.Unlock()
close(t.shutdownChan)
err = t.conn.Close()
t.mu.Lock()
streams := t.activeStreams
t.activeStreams = nil
t.mu.Unlock()
// Notify all active streams.
for _, s := range streams {
s.mu.Lock()
if !s.headerDone {
close(s.headerChan)
s.headerDone = true
}
s.mu.Unlock()
s.write(recvMsg{err: ErrConnClosing})
}
return
}
// Write formats the data into HTTP2 data frame(s) and sends it out. The caller
// should proceed only if Write returns nil.
// TODO(zhaoq): opts.Delay is ignored in this implementation. Support it later
// if it improves the performance.
func (t *http2Client) Write(s *Stream, data []byte, opts *Options) error {
r := bytes.NewBuffer(data)
for {
var p []byte
if r.Len() > 0 {
size := http2MaxFrameLen
s.sendQuotaPool.add(0)
// Wait until the stream has some quota to send the data.
sq, err := wait(s.ctx, t.shutdownChan, s.sendQuotaPool.acquire())
if err != nil {
return err
}
t.sendQuotaPool.add(0)
// Wait until the transport has some quota to send the data.
tq, err := wait(s.ctx, t.shutdownChan, t.sendQuotaPool.acquire())
if err != nil {
if _, ok := err.(StreamError); ok {
t.sendQuotaPool.cancel()
}
return err
}
if sq < size {
size = sq
}
if tq < size {
size = tq
}
p = r.Next(size)
ps := len(p)
if ps < sq {
// Overbooked stream quota. Return it back.
s.sendQuotaPool.add(sq - ps)
}
if ps < tq {
// Overbooked transport quota. Return it back.
t.sendQuotaPool.add(tq - ps)
}
}
var (
endStream bool
forceFlush bool
)
if opts.Last && r.Len() == 0 {
endStream = true
}
// Indicate there is a writer who is about to write a data frame.
t.framer.adjustNumWriters(1)
// Got some quota. Try to acquire writing privilege on the transport.
if _, err := wait(s.ctx, t.shutdownChan, t.writableChan); err != nil {
if t.framer.adjustNumWriters(-1) == 0 {
// This writer is the last one in this batch and has the
// responsibility to flush the buffered frames. It queues
// a flush request to controlBuf instead of flushing directly
// in order to avoid the race with other writing or flushing.
t.controlBuf.put(&flushIO{})
}
return err
}
if r.Len() == 0 && t.framer.adjustNumWriters(0) == 1 {
// Do a force flush iff this is last frame for the entire gRPC message
// and the caller is the only writer at this moment.
forceFlush = true
}
// If WriteData fails, all the pending streams will be handled
// by http2Client.Close(). No explicit CloseStream() needs to be
// invoked.
if err := t.framer.writeData(forceFlush, s.id, endStream, p); err != nil {
t.notifyError(err)
return ConnectionErrorf("transport: %v", err)
}
if t.framer.adjustNumWriters(-1) == 0 {
t.framer.flushWrite()
}
t.writableChan <- 0
if r.Len() == 0 {
break
}
}
if !opts.Last {
return nil
}
s.mu.Lock()
if s.state != streamDone {
if s.state == streamReadDone {
s.state = streamDone
} else {
s.state = streamWriteDone
}
}
s.mu.Unlock()
return nil
}
func (t *http2Client) getStream(f http2.Frame) (*Stream, bool) {
t.mu.Lock()
defer t.mu.Unlock()
if t.activeStreams == nil {
// The transport is closing.
return nil, false
}
if s, ok := t.activeStreams[f.Header().StreamID]; ok {
return s, true
}
return nil, false
}
// updateWindow adjusts the inbound quota for the stream and the transport.
// Window updates will deliver to the controller for sending when
// the cumulative quota exceeds the corresponding threshold.
func (t *http2Client) updateWindow(s *Stream, n uint32) {
swu, cwu := s.fc.onRead(n)
if swu > 0 {
t.controlBuf.put(&windowUpdate{s.id, swu})
}
if cwu > 0 {
t.controlBuf.put(&windowUpdate{0, cwu})
}
}
func (t *http2Client) handleData(f *http2.DataFrame) {
// Select the right stream to dispatch.
s, ok := t.getStream(f)
if !ok {
return
}
size := len(f.Data())
if err := s.fc.onData(uint32(size)); err != nil {
if _, ok := err.(ConnectionError); ok {
t.notifyError(err)
return
}
s.mu.Lock()
if s.state == streamDone {
s.mu.Unlock()
return
}
s.state = streamDone
s.statusCode = codes.Internal
s.statusDesc = err.Error()
s.mu.Unlock()
s.write(recvMsg{err: io.EOF})
t.controlBuf.put(&resetStream{s.id, http2.ErrCodeFlowControl})
return
}
// TODO(bradfitz, zhaoq): A copy is required here because there is no
// guarantee f.Data() is consumed before the arrival of next frame.
// Can this copy be eliminated?
data := make([]byte, size)
copy(data, f.Data())
s.write(recvMsg{data: data})
}
func (t *http2Client) handleRSTStream(f *http2.RSTStreamFrame) {
s, ok := t.getStream(f)
if !ok {
return
}
s.mu.Lock()
if s.state == streamDone {
s.mu.Unlock()
return
}
s.state = streamDone
s.statusCode, ok = http2RSTErrConvTab[http2.ErrCode(f.ErrCode)]
if !ok {
grpclog.Println("transport: http2Client.handleRSTStream found no mapped gRPC status for the received http2 error ", f.ErrCode)
}
s.mu.Unlock()
s.write(recvMsg{err: io.EOF})
}
func (t *http2Client) handleSettings(f *http2.SettingsFrame) {
if f.IsAck() {
return
}
f.ForeachSetting(func(s http2.Setting) error {
if v, ok := f.Value(s.ID); ok {
switch s.ID {
case http2.SettingMaxConcurrentStreams:
// TODO(zhaoq): This is a hack to avoid significant refactoring of the
// code to deal with the unrealistic int32 overflow. Probably will try
// to find a better way to handle this later.
if v > math.MaxInt32 {
v = math.MaxInt32
}
t.mu.Lock()
reset := t.streamsQuota != nil
if !reset {
t.streamsQuota = newQuotaPool(int(v))
}
ms := t.maxStreams
t.maxStreams = int(v)
t.mu.Unlock()
if reset {
t.streamsQuota.reset(int(v) - ms)
}
case http2.SettingInitialWindowSize:
t.mu.Lock()
for _, s := range t.activeStreams {
// Adjust the sending quota for each s.
s.sendQuotaPool.reset(int(v - t.streamSendQuota))
}
t.streamSendQuota = v
t.mu.Unlock()
}
}
return nil
})
t.controlBuf.put(&settings{ack: true})
}
func (t *http2Client) handlePing(f *http2.PingFrame) {
t.controlBuf.put(&ping{true})
}
func (t *http2Client) handleGoAway(f *http2.GoAwayFrame) {
// TODO(zhaoq): GoAwayFrame handler to be implemented"
}
func (t *http2Client) handleWindowUpdate(f *http2.WindowUpdateFrame) {
id := f.Header().StreamID
incr := f.Increment
if id == 0 {
t.sendQuotaPool.add(int(incr))
return
}
if s, ok := t.getStream(f); ok {
s.sendQuotaPool.add(int(incr))
}
}
// operateHeader takes action on the decoded headers. It returns the current
// stream if there are remaining headers on the wire (in the following
// Continuation frame).
func (t *http2Client) operateHeaders(hDec *hpackDecoder, s *Stream, frame headerFrame, endStream bool) (pendingStream *Stream) {
defer func() {
if pendingStream == nil {
hDec.state = decodeState{}
}
}()
endHeaders, err := hDec.decodeClientHTTP2Headers(frame)
if s == nil {
// s has been closed.
return nil
}
if err != nil {
s.write(recvMsg{err: err})
// Something wrong. Stops reading even when there is remaining.
return nil
}
if !endHeaders {
return s
}
s.mu.Lock()
if !s.headerDone {
if !endStream && len(hDec.state.mdata) > 0 {
s.header = hDec.state.mdata
}
close(s.headerChan)
s.headerDone = true
}
if !endStream || s.state == streamDone {
s.mu.Unlock()
return nil
}
if len(hDec.state.mdata) > 0 {
s.trailer = hDec.state.mdata
}
s.state = streamDone
s.statusCode = hDec.state.statusCode
s.statusDesc = hDec.state.statusDesc
s.mu.Unlock()
s.write(recvMsg{err: io.EOF})
return nil
}
// reader runs as a separate goroutine in charge of reading data from network
// connection.
//
// TODO(zhaoq): currently one reader per transport. Investigate whether this is
// optimal.
// TODO(zhaoq): Check the validity of the incoming frame sequence.
func (t *http2Client) reader() {
// Check the validity of server preface.
frame, err := t.framer.readFrame()
if err != nil {
t.notifyError(err)
return
}
sf, ok := frame.(*http2.SettingsFrame)
if !ok {
t.notifyError(err)
return
}
t.handleSettings(sf)
hDec := newHPACKDecoder()
var curStream *Stream
// loop to keep reading incoming messages on this transport.
for {
frame, err := t.framer.readFrame()
if err != nil {
t.notifyError(err)
return
}
switch frame := frame.(type) {
case *http2.HeadersFrame:
// operateHeaders has to be invoked regardless the value of curStream
// because the HPACK decoder needs to be updated using the received
// headers.
curStream, _ = t.getStream(frame)
endStream := frame.Header().Flags.Has(http2.FlagHeadersEndStream)
curStream = t.operateHeaders(hDec, curStream, frame, endStream)
case *http2.ContinuationFrame:
curStream = t.operateHeaders(hDec, curStream, frame, false)
case *http2.DataFrame:
t.handleData(frame)
case *http2.RSTStreamFrame:
t.handleRSTStream(frame)
case *http2.SettingsFrame:
t.handleSettings(frame)
case *http2.PingFrame:
t.handlePing(frame)
case *http2.GoAwayFrame:
t.handleGoAway(frame)
case *http2.WindowUpdateFrame:
t.handleWindowUpdate(frame)
default:
grpclog.Printf("transport: http2Client.reader got unhandled frame type %v.", frame)
}
}
}
// controller running in a separate goroutine takes charge of sending control
// frames (e.g., window update, reset stream, setting, etc.) to the server.
func (t *http2Client) controller() {
for {
select {
case i := <-t.controlBuf.get():
t.controlBuf.load()
select {
case <-t.writableChan:
switch i := i.(type) {
case *windowUpdate:
t.framer.writeWindowUpdate(true, i.streamID, i.increment)
case *settings:
if i.ack {
t.framer.writeSettingsAck(true)
} else {
t.framer.writeSettings(true, i.setting...)
}
case *resetStream:
t.framer.writeRSTStream(true, i.streamID, i.code)
case *flushIO:
t.framer.flushWrite()
case *ping:
// TODO(zhaoq): Ack with all-0 data now. will change to some
// meaningful content when this is actually in use.
t.framer.writePing(true, i.ack, [8]byte{})
default:
grpclog.Printf("transport: http2Client.controller got unexpected item type %v\n", i)
}
t.writableChan <- 0
continue
case <-t.shutdownChan:
return
}
case <-t.shutdownChan:
return
}
}
}
func (t *http2Client) Error() <-chan struct{} {
return t.errorChan
}
func (t *http2Client) notifyError(err error) {
t.mu.Lock()
defer t.mu.Unlock()
// make sure t.errorChan is closed only once.
if t.state == reachable {
t.state = unreachable
close(t.errorChan)
grpclog.Printf("transport: http2Client.notifyError got notified that the client transport was broken %v.", err)
}
}
================================================
FILE: vendor/google.golang.org/grpc/transport/http2_server.go
================================================
/*
*
* Copyright 2014, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package transport
import (
"bytes"
"errors"
"io"
"math"
"net"
"strconv"
"sync"
"github.com/bradfitz/http2"
"github.com/bradfitz/http2/hpack"
"golang.org/x/net/context"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/grpclog"
"google.golang.org/grpc/metadata"
)
// ErrIllegalHeaderWrite indicates that setting header is illegal because of
// the stream's state.
var ErrIllegalHeaderWrite = errors.New("transport: the stream is done or WriteHeader was already called")
// http2Server implements the ServerTransport interface with HTTP2.
type http2Server struct {
conn net.Conn
maxStreamID uint32 // max stream ID ever seen
// writableChan synchronizes write access to the transport.
// A writer acquires the write lock by sending a value on writableChan
// and releases it by receiving from writableChan.
writableChan chan int
// shutdownChan is closed when Close is called.
// Blocking operations should select on shutdownChan to avoid
// blocking forever after Close.
shutdownChan chan struct{}
framer *framer
hBuf *bytes.Buffer // the buffer for HPACK encoding
hEnc *hpack.Encoder // HPACK encoder
// The max number of concurrent streams.
maxStreams uint32
// controlBuf delivers all the control related tasks (e.g., window
// updates, reset streams, and various settings) to the controller.
controlBuf *recvBuffer
fc *inFlow
// sendQuotaPool provides flow control to outbound message.
sendQuotaPool *quotaPool
mu sync.Mutex // guard the following
state transportState
activeStreams map[uint32]*Stream
// the per-stream outbound flow control window size set by the peer.
streamSendQuota uint32
}
// newHTTP2Server constructs a ServerTransport based on HTTP2. ConnectionError is
// returned if something goes wrong.
func newHTTP2Server(conn net.Conn, maxStreams uint32) (_ ServerTransport, err error) {
framer := newFramer(conn)
// Send initial settings as connection preface to client.
// TODO(zhaoq): Have a better way to signal "no limit" because 0 is
// permitted in the HTTP2 spec.
var settings []http2.Setting
// TODO(zhaoq): Have a better way to signal "no limit" because 0 is
// permitted in the HTTP2 spec.
if maxStreams == 0 {
maxStreams = math.MaxUint32
} else {
settings = append(settings, http2.Setting{http2.SettingMaxConcurrentStreams, maxStreams})
}
if initialWindowSize != defaultWindowSize {
settings = append(settings, http2.Setting{http2.SettingInitialWindowSize, uint32(initialWindowSize)})
}
if err := framer.writeSettings(true, settings...); err != nil {
return nil, ConnectionErrorf("transport: %v", err)
}
// Adjust the connection flow control window if needed.
if delta := uint32(initialConnWindowSize - defaultWindowSize); delta > 0 {
if err := framer.writeWindowUpdate(true, 0, delta); err != nil {
return nil, ConnectionErrorf("transport: %v", err)
}
}
var buf bytes.Buffer
t := &http2Server{
conn: conn,
framer: framer,
hBuf: &buf,
hEnc: hpack.NewEncoder(&buf),
maxStreams: maxStreams,
controlBuf: newRecvBuffer(),
fc: &inFlow{limit: initialConnWindowSize},
sendQuotaPool: newQuotaPool(defaultWindowSize),
state: reachable,
writableChan: make(chan int, 1),
shutdownChan: make(chan struct{}),
activeStreams: make(map[uint32]*Stream),
streamSendQuota: defaultWindowSize,
}
go t.controller()
t.writableChan <- 0
return t, nil
}
// operateHeader takes action on the decoded headers. It returns the current
// stream if there are remaining headers on the wire (in the following
// Continuation frame).
func (t *http2Server) operateHeaders(hDec *hpackDecoder, s *Stream, frame headerFrame, endStream bool, handle func(*Stream), wg *sync.WaitGroup) (pendingStream *Stream) {
defer func() {
if pendingStream == nil {
hDec.state = decodeState{}
}
}()
endHeaders, err := hDec.decodeServerHTTP2Headers(frame)
if s == nil {
// s has been closed.
return nil
}
if err != nil {
grpclog.Printf("transport: http2Server.operateHeader found %v", err)
if se, ok := err.(StreamError); ok {
t.controlBuf.put(&resetStream{s.id, statusCodeConvTab[se.Code]})
}
return nil
}
if endStream {
// s is just created by the caller. No lock needed.
s.state = streamReadDone
}
if !endHeaders {
return s
}
t.mu.Lock()
if t.state != reachable {
t.mu.Unlock()
return nil
}
if uint32(len(t.activeStreams)) >= t.maxStreams {
t.mu.Unlock()
t.controlBuf.put(&resetStream{s.id, http2.ErrCodeRefusedStream})
return nil
}
s.sendQuotaPool = newQuotaPool(int(t.streamSendQuota))
t.activeStreams[s.id] = s
t.mu.Unlock()
s.windowHandler = func(n int) {
t.updateWindow(s, uint32(n))
}
if hDec.state.timeoutSet {
s.ctx, s.cancel = context.WithTimeout(context.TODO(), hDec.state.timeout)
} else {
s.ctx, s.cancel = context.WithCancel(context.TODO())
}
// Cache the current stream to the context so that the server application
// can find out. Required when the server wants to send some metadata
// back to the client (unary call only).
s.ctx = newContextWithStream(s.ctx, s)
// Attach the received metadata to the context.
if len(hDec.state.mdata) > 0 {
s.ctx = metadata.NewContext(s.ctx, hDec.state.mdata)
}
s.dec = &recvBufferReader{
ctx: s.ctx,
recv: s.buf,
}
s.method = hDec.state.method
wg.Add(1)
go func() {
handle(s)
wg.Done()
}()
return nil
}
// HandleStreams receives incoming streams using the given handler. This is
// typically run in a separate goroutine.
func (t *http2Server) HandleStreams(handle func(*Stream)) {
// Check the validity of client preface.
preface := make([]byte, len(clientPreface))
if _, err := io.ReadFull(t.conn, preface); err != nil {
grpclog.Printf("transport: http2Server.HandleStreams failed to receive the preface from client: %v", err)
t.Close()
return
}
if !bytes.Equal(preface, clientPreface) {
grpclog.Printf("transport: http2Server.HandleStreams received bogus greeting from client: %q", preface)
t.Close()
return
}
frame, err := t.framer.readFrame()
if err != nil {
grpclog.Printf("transport: http2Server.HandleStreams failed to read frame: %v", err)
t.Close()
return
}
sf, ok := frame.(*http2.SettingsFrame)
if !ok {
grpclog.Printf("transport: http2Server.HandleStreams saw invalid preface type %T from client", frame)
t.Close()
return
}
t.handleSettings(sf)
hDec := newHPACKDecoder()
var curStream *Stream
var wg sync.WaitGroup
defer wg.Wait()
for {
frame, err := t.framer.readFrame()
if err != nil {
t.Close()
return
}
switch frame := frame.(type) {
case *http2.HeadersFrame:
id := frame.Header().StreamID
if id%2 != 1 || id <= t.maxStreamID {
// illegal gRPC stream id.
grpclog.Println("transport: http2Server.HandleStreams received an illegal stream id: ", id)
t.Close()
break
}
t.maxStreamID = id
buf := newRecvBuffer()
fc := &inFlow{
limit: initialWindowSize,
conn: t.fc,
}
curStream = &Stream{
id: frame.Header().StreamID,
st: t,
buf: buf,
fc: fc,
}
endStream := frame.Header().Flags.Has(http2.FlagHeadersEndStream)
curStream = t.operateHeaders(hDec, curStream, frame, endStream, handle, &wg)
case *http2.ContinuationFrame:
curStream = t.operateHeaders(hDec, curStream, frame, false, handle, &wg)
case *http2.DataFrame:
t.handleData(frame)
case *http2.RSTStreamFrame:
t.handleRSTStream(frame)
case *http2.SettingsFrame:
t.handleSettings(frame)
case *http2.PingFrame:
t.handlePing(frame)
case *http2.WindowUpdateFrame:
t.handleWindowUpdate(frame)
case *http2.GoAwayFrame:
break
default:
grpclog.Printf("transport: http2Server.HandleStreams found unhandled frame type %v.", frame)
}
}
}
func (t *http2Server) getStream(f http2.Frame) (*Stream, bool) {
t.mu.Lock()
defer t.mu.Unlock()
if t.activeStreams == nil {
// The transport is closing.
return nil, false
}
s, ok := t.activeStreams[f.Header().StreamID]
if !ok {
// The stream is already done.
return nil, false
}
return s, true
}
// updateWindow adjusts the inbound quota for the stream and the transport.
// Window updates will deliver to the controller for sending when
// the cumulative quota exceeds the corresponding threshold.
func (t *http2Server) updateWindow(s *Stream, n uint32) {
swu, cwu := s.fc.onRead(n)
if swu > 0 {
t.controlBuf.put(&windowUpdate{s.id, swu})
}
if cwu > 0 {
t.controlBuf.put(&windowUpdate{0, cwu})
}
}
func (t *http2Server) handleData(f *http2.DataFrame) {
// Select the right stream to dispatch.
s, ok := t.getStream(f)
if !ok {
return
}
size := len(f.Data())
if err := s.fc.onData(uint32(size)); err != nil {
if _, ok := err.(ConnectionError); ok {
grpclog.Printf("transport: http2Server %v", err)
t.Close()
return
}
t.closeStream(s)
t.controlBuf.put(&resetStream{s.id, http2.ErrCodeFlowControl})
return
}
// TODO(bradfitz, zhaoq): A copy is required here because there is no
// guarantee f.Data() is consumed before the arrival of next frame.
// Can this copy be eliminated?
data := make([]byte, size)
copy(data, f.Data())
s.write(recvMsg{data: data})
if f.Header().Flags.Has(http2.FlagDataEndStream) {
// Received the end of stream from the client.
s.mu.Lock()
if s.state != streamDone {
if s.state == streamWriteDone {
s.state = streamDone
} else {
s.state = streamReadDone
}
}
s.mu.Unlock()
s.write(recvMsg{err: io.EOF})
}
}
func (t *http2Server) handleRSTStream(f *http2.RSTStreamFrame) {
s, ok := t.getStream(f)
if !ok {
return
}
t.closeStream(s)
}
func (t *http2Server) handleSettings(f *http2.SettingsFrame) {
if f.IsAck() {
return
}
f.ForeachSetting(func(s http2.Setting) error {
if v, ok := f.Value(http2.SettingInitialWindowSize); ok {
t.mu.Lock()
defer t.mu.Unlock()
for _, s := range t.activeStreams {
s.sendQuotaPool.reset(int(v - t.streamSendQuota))
}
t.streamSendQuota = v
}
return nil
})
t.controlBuf.put(&settings{ack: true})
}
func (t *http2Server) handlePing(f *http2.PingFrame) {
t.controlBuf.put(&ping{true})
}
func (t *http2Server) handleWindowUpdate(f *http2.WindowUpdateFrame) {
id := f.Header().StreamID
incr := f.Increment
if id == 0 {
t.sendQuotaPool.add(int(incr))
return
}
if s, ok := t.getStream(f); ok {
s.sendQuotaPool.add(int(incr))
}
}
func (t *http2Server) writeHeaders(s *Stream, b *bytes.Buffer, endStream bool) error {
first := true
endHeaders := false
var err error
// Sends the headers in a single batch.
for !endHeaders {
size := t.hBuf.Len()
if size > http2MaxFrameLen {
size = http2MaxFrameLen
} else {
endHeaders = true
}
if first {
p := http2.HeadersFrameParam{
StreamID: s.id,
BlockFragment: b.Next(size),
EndStream: endStream,
EndHeaders: endHeaders,
}
err = t.framer.writeHeaders(endHeaders, p)
first = false
} else {
err = t.framer.writeContinuation(endHeaders, s.id, endHeaders, b.Next(size))
}
if err != nil {
t.Close()
return ConnectionErrorf("transport: %v", err)
}
}
return nil
}
// WriteHeader sends the header metedata md back to the client.
func (t *http2Server) WriteHeader(s *Stream, md metadata.MD) error {
s.mu.Lock()
if s.headerOk || s.state == streamDone {
s.mu.Unlock()
return ErrIllegalHeaderWrite
}
s.headerOk = true
s.mu.Unlock()
if _, err := wait(s.ctx, t.shutdownChan, t.writableChan); err != nil {
return err
}
t.hBuf.Reset()
t.hEnc.WriteField(hpack.HeaderField{Name: ":status", Value: "200"})
t.hEnc.WriteField(hpack.HeaderField{Name: "content-type", Value: "application/grpc"})
for k, v := range md {
t.hEnc.WriteField(hpack.HeaderField{Name: k, Value: v})
}
if err := t.writeHeaders(s, t.hBuf, false); err != nil {
return err
}
t.writableChan <- 0
return nil
}
// WriteStatus sends stream status to the client and terminates the stream.
// There is no further I/O operations being able to perform on this stream.
// TODO(zhaoq): Now it indicates the end of entire stream. Revisit if early
// OK is adopted.
func (t *http2Server) WriteStatus(s *Stream, statusCode codes.Code, statusDesc string) error {
s.mu.RLock()
if s.state == streamDone {
s.mu.RUnlock()
return nil
}
s.mu.RUnlock()
if _, err := wait(s.ctx, t.shutdownChan, t.writableChan); err != nil {
return err
}
t.hBuf.Reset()
t.hEnc.WriteField(hpack.HeaderField{Name: ":status", Value: "200"})
t.hEnc.WriteField(
hpack.HeaderField{
Name: "grpc-status",
Value: strconv.Itoa(int(statusCode)),
})
t.hEnc.WriteField(hpack.HeaderField{Name: "grpc-message", Value: statusDesc})
// Attach the trailer metadata.
for k, v := range s.trailer {
t.hEnc.WriteField(hpack.HeaderField{Name: k, Value: v})
}
if err := t.writeHeaders(s, t.hBuf, true); err != nil {
t.Close()
return err
}
t.closeStream(s)
t.writableChan <- 0
return nil
}
// Write converts the data into HTTP2 data frame and sends it out. Non-nil error
// is returns if it fails (e.g., framing error, transport error).
func (t *http2Server) Write(s *Stream, data []byte, opts *Options) error {
// TODO(zhaoq): Support multi-writers for a single stream.
var writeHeaderFrame bool
s.mu.Lock()
if !s.headerOk {
writeHeaderFrame = true
s.headerOk = true
}
s.mu.Unlock()
if writeHeaderFrame {
if _, err := wait(s.ctx, t.shutdownChan, t.writableChan); err != nil {
return err
}
t.hBuf.Reset()
t.hEnc.WriteField(hpack.HeaderField{Name: ":status", Value: "200"})
t.hEnc.WriteField(hpack.HeaderField{Name: "content-type", Value: "application/grpc"})
p := http2.HeadersFrameParam{
StreamID: s.id,
BlockFragment: t.hBuf.Bytes(),
EndHeaders: true,
}
if err := t.framer.writeHeaders(false, p); err != nil {
t.Close()
return ConnectionErrorf("transport: %v", err)
}
t.writableChan <- 0
}
r := bytes.NewBuffer(data)
for {
if r.Len() == 0 {
return nil
}
size := http2MaxFrameLen
s.sendQuotaPool.add(0)
// Wait until the stream has some quota to send the data.
sq, err := wait(s.ctx, t.shutdownChan, s.sendQuotaPool.acquire())
if err != nil {
return err
}
t.sendQuotaPool.add(0)
// Wait until the transport has some quota to send the data.
tq, err := wait(s.ctx, t.shutdownChan, t.sendQuotaPool.acquire())
if err != nil {
if _, ok := err.(StreamError); ok {
t.sendQuotaPool.cancel()
}
return err
}
if sq < size {
size = sq
}
if tq < size {
size = tq
}
p := r.Next(size)
ps := len(p)
if ps < sq {
// Overbooked stream quota. Return it back.
s.sendQuotaPool.add(sq - ps)
}
if ps < tq {
// Overbooked transport quota. Return it back.
t.sendQuotaPool.add(tq - ps)
}
t.framer.adjustNumWriters(1)
// Got some quota. Try to acquire writing privilege on the
// transport.
if _, err := wait(s.ctx, t.shutdownChan, t.writableChan); err != nil {
if t.framer.adjustNumWriters(-1) == 0 {
// This writer is the last one in this batch and has the
// responsibility to flush the buffered frames. It queues
// a flush request to controlBuf instead of flushing directly
// in order to avoid the race with other writing or flushing.
t.controlBuf.put(&flushIO{})
}
return err
}
var forceFlush bool
if r.Len() == 0 && t.framer.adjustNumWriters(0) == 1 && !opts.Last {
forceFlush = true
}
if err := t.framer.writeData(forceFlush, s.id, false, p); err != nil {
t.Close()
return ConnectionErrorf("transport: %v", err)
}
if t.framer.adjustNumWriters(-1) == 0 {
t.framer.flushWrite()
}
t.writableChan <- 0
}
}
// controller running in a separate goroutine takes charge of sending control
// frames (e.g., window update, reset stream, setting, etc.) to the server.
func (t *http2Server) controller() {
for {
select {
case i := <-t.controlBuf.get():
t.controlBuf.load()
select {
case <-t.writableChan:
switch i := i.(type) {
case *windowUpdate:
t.framer.writeWindowUpdate(true, i.streamID, i.increment)
case *settings:
if i.ack {
t.framer.writeSettingsAck(true)
} else {
t.framer.writeSettings(true, i.setting...)
}
case *resetStream:
t.framer.writeRSTStream(true, i.streamID, i.code)
case *flushIO:
t.framer.flushWrite()
case *ping:
// TODO(zhaoq): Ack with all-0 data now. will change to some
// meaningful content when this is actually in use.
t.framer.writePing(true, i.ack, [8]byte{})
default:
grpclog.Printf("transport: http2Server.controller got unexpected item type %v\n", i)
}
t.writableChan <- 0
continue
case <-t.shutdownChan:
return
}
case <-t.shutdownChan:
return
}
}
}
// Close starts shutting down the http2Server transport.
// TODO(zhaoq): Now the destruction is not blocked on any pending streams. This
// could cause some resource issue. Revisit this later.
func (t *http2Server) Close() (err error) {
t.mu.Lock()
if t.state == closing {
t.mu.Unlock()
return errors.New("transport: Close() was already called")
}
t.state = closing
streams := t.activeStreams
t.activeStreams = nil
t.mu.Unlock()
close(t.shutdownChan)
err = t.conn.Close()
// Notify all active streams.
for _, s := range streams {
s.write(recvMsg{err: ErrConnClosing})
}
return
}
// closeStream clears the footprint of a stream when the stream is not needed
// any more.
func (t *http2Server) closeStream(s *Stream) {
t.mu.Lock()
delete(t.activeStreams, s.id)
t.mu.Unlock()
if q := s.fc.restoreConn(); q > 0 {
t.controlBuf.put(&windowUpdate{0, q})
}
s.mu.Lock()
if s.state == streamDone {
s.mu.Unlock()
return
}
s.state = streamDone
s.mu.Unlock()
// In case stream sending and receiving are invoked in separate
// goroutines (e.g., bi-directional streaming), the caller needs
// to call cancel on the stream to interrupt the blocking on
// other goroutines.
s.cancel()
}
================================================
FILE: vendor/google.golang.org/grpc/transport/http_util.go
================================================
/*
*
* Copyright 2014, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
package transport
import (
"bufio"
"fmt"
"io"
"net"
"strconv"
"sync/atomic"
"time"
"github.com/bradfitz/http2"
"github.com/bradfitz/http2/hpack"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/grpclog"
"google.golang.org/grpc/metadata"
)
const (
// http2MaxFrameLen specifies the max length of a HTTP2 frame.
http2MaxFrameLen = 16384 // 16KB frame
// http://http2.github.io/http2-spec/#SettingValues
http2InitHeaderTableSize = 4096
// http2IOBufSize specifies the buffer size for sending frames.
http2IOBufSize = 32 * 1024
)
var (
clientPreface = []byte(http2.ClientPreface)
)
var http2RSTErrConvTab = map[http2.ErrCode]codes.Code{
http2.ErrCodeNo: codes.Internal,
http2.ErrCodeProtocol: codes.Internal,
http2.ErrCodeInternal: codes.Internal,
http2.ErrCodeFlowControl: codes.Internal,
http2.ErrCodeSettingsTimeout: codes.Internal,
http2.ErrCodeFrameSize: codes.Internal,
http2.ErrCodeRefusedStream: codes.Unavailable,
http2.ErrCodeCancel: codes.Canceled,
http2.ErrCodeCompression: codes.Internal,
http2.ErrCodeConnect: codes.Internal,
http2.ErrCodeEnhanceYourCalm: codes.ResourceExhausted,
http2.ErrCodeInadequateSecurity: codes.PermissionDenied,
}
var statusCodeConvTab = map[codes.Code]http2.ErrCode{
codes.Internal: http2.ErrCodeInternal, // pick an arbitrary one which is matched.
codes.Canceled: http2.ErrCodeCancel,
codes.Unavailable: http2.ErrCodeRefusedStream,
codes.ResourceExhausted: http2.ErrCodeEnhanceYourCalm,
codes.PermissionDenied: http2.ErrCodeInadequateSecurity,
}
// Records the states during HPACK decoding. Must be reset once the
// decoding of the entire headers are finished.
type decodeState struct {
// statusCode caches the stream status received from the trailer
// the server sent. Client side only.
statusCode codes.Code
statusDesc string
// Server side only fields.
timeoutSet bool
timeout time.Duration
method string
// key-value metadata map from the peer.
mdata map[string]string
}
// An hpackDecoder decodes HTTP2 headers which may span multiple frames.
type hpackDecoder struct {
h *hpack.Decoder
state decodeState
err error // The err when decoding
}
// A headerFrame is either a http2.HeaderFrame or http2.ContinuationFrame.
type headerFrame interface {
Header() http2.FrameHeader
HeaderBlockFragment() []byte
HeadersEnded() bool
}
// isReservedHeader checks whether hdr belongs to HTTP2 headers
// reserved by gRPC protocol. Any other headers are classified as the
// user-specified metadata.
func isReservedHeader(hdr string) bool {
if hdr[0] == ':' {
return true
}
switch hdr {
case "content-type",
"grpc-message-type",
"grpc-encoding",
"grpc-message",
"grpc-status",
"grpc-timeout",
"te",
"user-agent":
return true
default:
return false
}
}
func newHPACKDecoder() *hpackDecoder {
d := &hpackDecoder{}
d.h = hpack.NewDecoder(http2InitHeaderTableSize, func(f hpack.HeaderField) {
switch f.Name {
case "grpc-status":
code, err := strconv.Atoi(f.Value)
if err != nil {
d.err = StreamErrorf(codes.Internal, "transport: malformed grpc-status: %v", err)
return
}
d.state.statusCode = codes.Code(code)
case "grpc-message":
d.state.statusDesc = f.Value
case "grpc-timeout":
d.state.timeoutSet = true
var err error
d.state.timeout, err = timeoutDecode(f.Value)
if err != nil {
d.err = StreamErrorf(codes.Internal, "transport: malformed time-out: %v", err)
return
}
case ":path":
d.state.method = f.Value
default:
if !isReservedHeader(f.Name) {
if d.state.mdata == nil {
d.state.mdata = make(map[string]string)
}
k, v, err := metadata.DecodeKeyValue(f.Name, f.Value)
if err != nil {
grpclog.Printf("Failed to decode (%q, %q): %v", f.Name, f.Value, err)
return
}
d.state.mdata[k] = v
}
}
})
return d
}
func (d *hpackDecoder) decodeClientHTTP2Headers(frame headerFrame) (endHeaders bool, err error) {
d.err = nil
_, err = d.h.Write(frame.HeaderBlockFragment())
if err != nil {
err = StreamErrorf(codes.Internal, "transport: HPACK header decode error: %v", err)
}
if frame.HeadersEnded() {
if closeErr := d.h.Close(); closeErr != nil && err == nil {
err = StreamErrorf(codes.Internal, "transport: HPACK decoder close error: %v", closeErr)
}
endHeaders = true
}
if err == nil && d.err != nil {
err = d.err
}
return
}
func (d *hpackDecoder) decodeServerHTTP2Headers(frame headerFrame) (endHeaders bool, err error) {
d.err = nil
_, err = d.h.Write(frame.HeaderBlockFragment())
if err != nil {
err = StreamErrorf(codes.Internal, "transport: HPACK header decode error: %v", err)
}
if frame.HeadersEnded() {
if closeErr := d.h.Close(); closeErr != nil && err == nil {
err = StreamErrorf(codes.Internal, "transport: HPACK decoder close error: %v", closeErr)
}
endHeaders = true
}
if err == nil && d.err != nil {
err = d.err
}
return
}
type timeoutUnit uint8
const (
hour timeoutUnit = 'H'
minute timeoutUnit = 'M'
second timeoutUnit = 'S'
millisecond timeoutUnit = 'm'
microsecond timeoutUnit = 'u'
nanosecond timeoutUnit = 'n'
)
func timeoutUnitToDuration(u timeoutUnit) (d time.Duration, ok bool) {
switch u {
case hour:
return time.Hour, true
case minute:
return time.Minute, true
case second:
return time.Second, true
case millisecond:
return time.Millisecond, true
case microsecond:
return time.Microsecond, true
case nanosecond:
return time.Nanosecond, true
default:
}
return
}
const maxTimeoutValue int64 = 100000000 - 1
// div does integer division and round-up the result. Note that this is
// equivalent to (d+r-1)/r but has less chance to overflow.
func div(d, r time.Duration) int64 {
if m := d % r; m > 0 {
return int64(d/r + 1)
}
return int64(d / r)
}
// TODO(zhaoq): It is the simplistic and not bandwidth efficient. Improve it.
func timeoutEncode(t time.Duration) string {
if d := div(t, time.Nanosecond); d <= maxTimeoutValue {
return strconv.FormatInt(d, 10) + "n"
}
if d := div(t, time.Microsecond); d <= maxTimeoutValue {
return strconv.FormatInt(d, 10) + "u"
}
if d := div(t, time.Millisecond); d <= maxTimeoutValue {
return strconv.FormatInt(d, 10) + "m"
}
if d := div(t, time.Second); d <= maxTimeoutValue {
return strconv.FormatInt(d, 10) + "S"
}
if d := div(t, time.Minute); d <= maxTimeoutValue {
return strconv.FormatInt(d, 10) + "M"
}
// Note that maxTimeoutValue * time.Hour > MaxInt64.
return strconv.FormatInt(div(t, time.Hour), 10) + "H"
}
func timeoutDecode(s string) (time.Duration, error) {
size := len(s)
if size < 2 {
return 0, fmt.Errorf("transport: timeout string is too short: %q", s)
}
unit := timeoutUnit(s[size-1])
d, ok := timeoutUnitToDuration(unit)
if !ok {
return 0, fmt.Errorf("transport: timeout unit is not recognized: %q", s)
}
t, err := strconv.ParseInt(s[:size-1], 10, 64)
if err != nil {
return 0, err
}
return d * time.Duration(t), nil
}
type framer struct {
numWriters int32
reader io.Reader
writer *bufio.Writer
fr *http2.Framer
}
func newFramer(conn net.Conn) *framer {
f := &framer{
reader: conn,
writer: bufio.NewWriterSize(conn, http2IOBufSize),
}
f.fr = http2.NewFramer(f.writer, f.reader)
return f
}
func (f *framer) adjustNumWriters(i int32) int32 {
return atomic.AddInt32(&f.numWriters, i)
}
// The following writeXXX functions can only be called when the caller gets
// unblocked from writableChan channel (i.e., owns the privilege to write).
func (f *framer) writeContinuation(forceFlush bool, streamID uint32, endHeaders bool, headerBlockFragment []byte) error {
if err := f.fr.WriteContinuation(streamID, endHeaders, headerBlockFragment); err != nil {
return err
}
if forceFlush {
return f.writer.Flush()
}
return nil
}
func (f *framer) writeData(forceFlush bool, streamID uint32, endStream bool, data []byte) error {
if err := f.fr.WriteData(streamID, endStream, data); err != nil {
return err
}
if forceFlush {
return f.writer.Flush()
}
return nil
}
func (f *framer) writeGoAway(forceFlush bool, maxStreamID uint32, code http2.ErrCode, debugData []byte) error {
if err := f.fr.WriteGoAway(maxStreamID, code, debugData); err != nil {
return err
}
if forceFlush {
return f.writer.Flush()
}
return nil
}
func (f *framer) writeHeaders(forceFlush bool, p http2.HeadersFrameParam) error {
if err := f.fr.WriteHeaders(p); err != nil {
return err
}
if forceFlush {
return f.writer.Flush()
}
return nil
}
func (f *framer) writePing(forceFlush, ack bool, data [8]byte) error {
if err := f.fr.WritePing(ack, data); err != nil {
return err
}
if forceFlush {
return f.writer.Flush()
}
return nil
}
func (f *framer) writePriority(forceFlush bool, streamID uint32, p http2.PriorityParam) error {
if err := f.fr.WritePriority(streamID, p); err != nil {
return err
}
if forceFlush {
return f.writer.Flush()
}
return nil
}
func (f *framer) writePushPromise(forceFlush bool, p http2.PushPromiseParam) error {
if err := f.fr.WritePushPromise(p); err != nil {
return err
}
if forceFlush {
return f.writer.Flush()
}
return nil
}
func (f *framer) writeRSTStream(forceFlush bool, streamID uint32, code http2.ErrCode) error {
if err := f.fr.WriteRSTStream(streamID, code); err != nil {
return err
}
if forceFlush {
return f.writer.Flush()
}
return nil
}
func (f *framer) writeSettings(forceFlush bool, settings ...http2.Setting) error {
if err := f.fr.WriteSettings(settings...); err != nil {
return err
}
if forceFlush {
return f.writer.Flush()
}
return nil
}
func (f *framer) writeSettingsAck(forceFlush bool) error {
if err := f.fr.WriteSettingsAck(); err != nil {
return err
}
if forceFlush {
return f.writer.Flush()
}
return nil
}
func (f *framer) writeWindowUpdate(forceFlush bool, streamID, incr uint32) error {
if err := f.fr.WriteWindowUpdate(streamID, incr); err != nil {
return err
}
if forceFlush {
return f.writer.Flush()
}
return nil
}
func (f *framer) flushWrite() error {
return f.writer.Flush()
}
func (f *framer) readFrame() (http2.Frame, error) {
return f.fr.ReadFrame()
}
================================================
FILE: vendor/google.golang.org/grpc/transport/transport.go
================================================
/*
*
* Copyright 2014, Google Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following disclaimer
* in the documentation and/or other materials provided with the
* distribution.
* * Neither the name of Google Inc. nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
* OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
*/
/*
Package transport defines and implements message oriented communication channel
to complete various transactions (e.g., an RPC).
*/
package transport
import (
"bytes"
"errors"
"fmt"
"io"
"net"
"sync"
"time"
"golang.org/x/net/context"
"google.golang.org/grpc/codes"
"google.golang.org/grpc/credentials"
"google.golang.org/grpc/metadata"
)
// recvMsg represents the received msg from the transport. All transport
// protocol specific info has been removed.
type recvMsg struct {
data []byte
// nil: received some data
// io.EOF: stream is completed. data is nil.
// other non-nil error: transport failure. data is nil.
err error
}
func (recvMsg) isItem() bool {
return true
}
// All items in an out of a recvBuffer should be the same type.
type item interface {
isItem() bool
}
// recvBuffer is an unbounded channel of item.
type recvBuffer struct {
c chan item
mu sync.Mutex
backlog []item
}
func newRecvBuffer() *recvBuffer {
b := &recvBuffer{
c: make(chan item, 1),
}
return b
}
func (b *recvBuffer) put(r item) {
b.mu.Lock()
defer b.mu.Unlock()
b.backlog = append(b.backlog, r)
select {
case b.c <- b.backlog[0]:
b.backlog = b.backlog[1:]
default:
}
}
func (b *recvBuffer) load() {
b.mu.Lock()
defer b.mu.Unlock()
if len(b.backlog) > 0 {
select {
case b.c <- b.backlog[0]:
b.backlog = b.backlog[1:]
default:
}
}
}
// get returns the channel that receives an item in the buffer.
//
// Upon receipt of an item, the caller should call load to send another
// item onto the channel if there is any.
func (b *recvBuffer) get() <-chan item {
return b.c
}
// recvBufferReader implements io.Reader interface to read the data from
// recvBuffer.
type recvBufferReader struct {
ctx context.Context
recv *recvBuffer
last *bytes.Reader // Stores the remaining data in the previous calls.
err error
}
// Read reads the next len(p) bytes from last. If last is drained, it tries to
// read additional data from recv. It blocks if there no additional data available
// in recv. If Read returns any non-nil error, it will continue to return that error.
func (r *recvBufferReader) Read(p []byte) (n int, err error) {
if r.err != nil {
return 0, r.err
}
defer func() { r.err = err }()
if r.last != nil && r.last.Len() > 0 {
// Read remaining data left in last call.
return r.last.Read(p)
}
select {
case <-r.ctx.Done():
return 0, ContextErr(r.ctx.Err())
case i := <-r.recv.get():
r.recv.load()
m := i.(*recvMsg)
if m.err != nil {
return 0, m.err
}
r.last = bytes.NewReader(m.data)
return r.last.Read(p)
}
}
type streamState uint8
const (
streamActive streamState = iota
streamWriteDone // EndStream sent
streamReadDone // EndStream received
streamDone // sendDone and recvDone or RSTStreamFrame is sent or received.
)
// Stream represents an RPC in the transport layer.
type Stream struct {
id uint32
// nil for client side Stream.
st ServerTransport
// ctx is the associated context of the stream.
ctx context.Context
cancel context.CancelFunc
// method records the associated RPC method of the stream.
method string
buf *recvBuffer
dec io.Reader
// updateStreams indicates whether the transport's streamsQuota needed
// to be updated when this stream is closed. It is false when the transport
// sticks to the initial infinite value of the number of concurrent streams.
// Ture otherwise.
updateStreams bool
fc *inFlow
recvQuota uint32
// The accumulated inbound quota pending for window update.
updateQuota uint32
// The handler to control the window update procedure for both this
// particular stream and the associated transport.
windowHandler func(int)
sendQuotaPool *quotaPool
// Close headerChan to indicate the end of reception of header metadata.
headerChan chan struct{}
// header caches the received header metadata.
header metadata.MD
// The key-value map of trailer metadata.
trailer metadata.MD
mu sync.RWMutex // guard the following
// headerOK becomes true from the first header is about to send.
headerOk bool
state streamState
// true iff headerChan is closed. Used to avoid closing headerChan
// multiple times.
headerDone bool
// the status received from the server.
statusCode codes.Code
statusDesc string
}
// Header acquires the key-value pairs of header metadata once it
// is available. It blocks until i) the metadata is ready or ii) there is no
// header metadata or iii) the stream is cancelled/expired.
func (s *Stream) Header() (metadata.MD, error) {
select {
case <-s.ctx.Done():
return nil, ContextErr(s.ctx.Err())
case <-s.headerChan:
return s.header.Copy(), nil
}
}
// Trailer returns the cached trailer metedata. Note that if it is not called
// after the entire stream is done, it could return an empty MD. Client
// side only.
func (s *Stream) Trailer() metadata.MD {
s.mu.RLock()
defer s.mu.RUnlock()
return s.trailer.Copy()
}
// ServerTransport returns the underlying ServerTransport for the stream.
// The client side stream always returns nil.
func (s *Stream) ServerTransport() ServerTransport {
return s.st
}
// Context returns the context of the stream.
func (s *Stream) Context() context.Context {
return s.ctx
}
// Method returns the method for the stream.
func (s *Stream) Method() string {
return s.method
}
// StatusCode returns statusCode received from the server.
func (s *Stream) StatusCode() codes.Code {
return s.statusCode
}
// StatusDesc returns statusDesc received from the server.
func (s *Stream) StatusDesc() string {
return s.statusDesc
}
// ErrIllegalTrailerSet indicates that the trailer has already been set or it
// is too late to do so.
var ErrIllegalTrailerSet = errors.New("transport: trailer has been set")
// SetTrailer sets the trailer metadata which will be sent with the RPC status
// by the server. This can only be called at most once. Server side only.
func (s *Stream) SetTrailer(md metadata.MD) error {
s.mu.Lock()
defer s.mu.Unlock()
if s.trailer != nil {
return ErrIllegalTrailerSet
}
s.trailer = md.Copy()
return nil
}
func (s *Stream) write(m recvMsg) {
s.buf.put(&m)
}
// Read reads all the data available for this Stream from the transport and
// passes them into the decoder, which converts them into a gRPC message stream.
// The error is io.EOF when the stream is done or another non-nil error if
// the stream broke.
func (s *Stream) Read(p []byte) (n int, err error) {
n, err = s.dec.Read(p)
if err != nil {
return
}
s.windowHandler(n)
return
}
type key int
// The key to save transport.Stream in the context.
const streamKey = key(0)
// newContextWithStream creates a new context from ctx and attaches stream
// to it.
func newContextWithStream(ctx context.Context, stream *Stream) context.Context {
return context.WithValue(ctx, streamKey, stream)
}
// StreamFromContext returns the stream saved in ctx.
func StreamFromContext(ctx context.Context) (s *Stream, ok bool) {
s, ok = ctx.Value(streamKey).(*Stream)
return
}
// state of transport
type transportState int
const (
reachable transportState = iota
unreachable
closing
)
// NewServerTransport creates a ServerTransport with conn or non-nil error
// if it fails.
func NewServerTransport(protocol string, conn net.Conn, maxStreams uint32) (ServerTransport, error) {
return newHTTP2Server(conn, maxStreams)
}
// ConnectOptions covers all relevant options for dialing a server.
type ConnectOptions struct {
Dialer func(string, time.Duration) (net.Conn, error)
AuthOptions []credentials.Credentials
Timeout time.Duration
}
// NewClientTransport establishes the transport with the required ConnectOptions
// and returns it to the caller.
func NewClientTransport(target string, opts *ConnectOptions) (ClientTransport, error) {
return newHTTP2Client(target, opts)
}
// Options provides additional hints and information for message
// transmission.
type Options struct {
// Indicate whether it is the last piece for this stream.
Last bool
// The hint to transport impl whether the data could be buffered for
// batching write. Transport impl can feel free to ignore it.
Delay bool
}
// CallHdr carries the information of a particular RPC.
type CallHdr struct {
Host string // peer host
Method string // the operation to perform on the specified host
}
// ClientTransport is the common interface for all gRPC client side transport
// implementations.
type ClientTransport interface {
// Close tears down this transport. Once it returns, the transport
// should not be accessed any more. The caller must make sure this
// is called only once.
Close() error
// Write sends the data for the given stream. A nil stream indicates
// the write is to be performed on the transport as a whole.
Write(s *Stream, data []byte, opts *Options) error
// NewStream creates a Stream for an RPC.
NewStream(ctx context.Context, callHdr *CallHdr) (*Stream, error)
// CloseStream clears the footprint of a stream when the stream is
// not needed any more. The err indicates the error incurred when
// CloseStream is called. Must be called when a stream is finished
// unless the associated transport is closing.
CloseStream(stream *Stream, err error)
// Error returns a channel that is closed when some I/O error
// happens. Typically the caller should have a goroutine to monitor
// this in order to take action (e.g., close the current transport
// and create a new one) in error case. It should not return nil
// once the transport is initiated.
Error() <-chan struct{}
}
// ServerTransport is the common interface for all gRPC server side transport
// implementations.
type ServerTransport interface {
// WriteStatus sends the status of a stream to the client.
WriteStatus(s *Stream, statusCode codes.Code, statusDesc string) error
// Write sends the data for the given stream.
Write(s *Stream, data []byte, opts *Options) error
// WriteHeader sends the header metedata for the given stream.
WriteHeader(s *Stream, md metadata.MD) error
// HandleStreams receives incoming streams using the given handler.
HandleStreams(func(*Stream))
// Close tears down the transport. Once it is called, the transport
// should not be accessed any more. All the pending streams and their
// handlers will be terminated asynchronously.
Close() error
}
// StreamErrorf creates an StreamError with the specified error code and description.
func StreamErrorf(c codes.Code, format string, a ...interface{}) StreamError {
return StreamError{
Code: c,
Desc: fmt.Sprintf(format, a...),
}
}
// ConnectionErrorf creates an ConnectionError with the specified error description.
func ConnectionErrorf(format string, a ...interface{}) ConnectionError {
return ConnectionError{
Desc: fmt.Sprintf(format, a...),
}
}
// ConnectionError is an error that results in the termination of the
// entire connection and the retry of all the active streams.
type ConnectionError struct {
Desc string
}
func (e ConnectionError) Error() string {
return fmt.Sprintf("connection error: desc = %q", e.Desc)
}
// Define some common ConnectionErrors.
var ErrConnClosing = ConnectionError{Desc: "transport is closing"}
// StreamError is an error that only affects one stream within a connection.
type StreamError struct {
Code codes.Code
Desc string
}
func (e StreamError) Error() string {
return fmt.Sprintf("stream error: code = %d desc = %q", e.Code, e.Desc)
}
// ContextErr converts the error from context package into a StreamError.
func ContextErr(err error) StreamError {
switch err {
case context.DeadlineExceeded:
return StreamErrorf(codes.DeadlineExceeded, "%v", err)
case context.Canceled:
return StreamErrorf(codes.Canceled, "%v", err)
}
panic(fmt.Sprintf("Unexpected error from context packet: %v", err))
}
// wait blocks until it can receive from ctx.Done, closing, or proceed.
// If it receives from ctx.Done, it returns 0, the StreamError for ctx.Err.
// If it receives from closing, it returns 0, ErrConnClosing.
// If it receives from proceed, it returns the received integer, nil.
func wait(ctx context.Context, closing <-chan struct{}, proceed <-chan int) (int, error) {
select {
case <-ctx.Done():
return 0, ContextErr(ctx.Err())
case <-closing:
return 0, ErrConnClosing
case i := <-proceed:
return i, nil
}
}
![](\"http://i.imgur.com/YbfUjs5.png?2\")
")
fmt.Fprint(w, "")
}
requestMiddleware := func(handler http.HandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
s.stats.Request(r.URL.Path)
if os.Getenv("MANDIBLE_DEBUG") == "true" {
r.ParseForm()
log.Printf("Request url: %s with get params: %v and Headers: %v", r.URL.Path, r.Form, r.Header)
}
start := time.Now()
handler(w, r)
elapsed := time.Since(start)
s.stats.ResponseTime(elapsed, r.URL.Path)
}
}
router := mux.NewRouter()
router.HandleFunc("/file", requestMiddleware(uploadHandler(extractorFile, nil)))
router.HandleFunc("/url", requestMiddleware(uploadHandler(extractorUrl, nil)))
router.HandleFunc("/base64", requestMiddleware(uploadHandler(extractorBase64, nil)))
router.HandleFunc("/user/{user_id}/file", requestMiddleware(authenticatedEndpoint(uploadHandler, extractorBase64)))
router.HandleFunc("/user/{user_id}/url", requestMiddleware(authenticatedEndpoint(uploadHandler, extractorUrl)))
router.HandleFunc("/user/{user_id}/base64", requestMiddleware(authenticatedEndpoint(uploadHandler, extractorBase64)))
router.HandleFunc("/thumbnail", requestMiddleware(thumbnailHandler))
router.HandleFunc("/ocr", requestMiddleware(ocrHandler))
router.HandleFunc("/", requestMiddleware(rootHandler))
muxer.Handle("/", router)
}
func (s *Server) buildThumbResponse(upload *uploadedfile.UploadedFile) (map[string]interface{}, error) {
factory := imagestore.NewFactory(s.Config)
thumbsResp := map[string]interface{}{}
for _, t := range upload.GetThumbs() {
thumbName := fmt.Sprintf("%s/%s", upload.GetHash(), t.Name)
tObj := factory.NewStoreObject(thumbName, upload.GetMime(), "thumbnail")
err := tObj.Store(t, s.ImageStore)
if err != nil {
return nil, err
}
s.stats.Thumbnail(t.Name)
thumbsResp[t.Name] = tObj.Url
}
return thumbsResp, nil
}
func (s *Server) download(url string) (io.ReadCloser, error) {
req, err := http.NewRequest("GET", url, nil)
if err != nil {
return nil, err
}
req.Header.Add("User-Agent", s.Config.UserAgent)
resp, err := s.HTTPClient.Do(req)
if err != nil {
// "HTTP protocol error" - maybe the server sent an invalid response or timed out
return nil, err
}
if 200 != resp.StatusCode {
return nil, errors.New("Non-200 status code received")
}
contentLength := resp.ContentLength
if contentLength == 0 {
return nil, errors.New("Empty file received")
}
return resp.Body, nil
}
func parseThumbs(r *http.Request) ([]*uploadedfile.ThumbFile, error) {
thumbString := r.FormValue("thumbs")
if thumbString == "" {
return []*uploadedfile.ThumbFile{}, nil
}
type ThumbRequest struct {
Width int `json:"width"`
MaxWidth int `json:"max_width"`
Height int `json:"height"`
MaxHeight int `json:"max_height"`
Shape string `json:"shape"`
CropGravity string `json:"crop_gravity"`
CropHeight int `json:"crop_height"`
CropWidth int `json:"crop_width"`
Quality int `json:"quality"`
CropRatio string `json:"crop_ratio"`
DesiredFormat string `json:"format"`
NoStore bool `json:"nostore"`
}
var thumbRequests map[string]ThumbRequest
err := json.Unmarshal([]byte(thumbString), &thumbRequests)
if err != nil {
fmt.Println(err.Error())
return nil, errors.New("Error parsing thumbnail JSON!")
}
var thumbs []*uploadedfile.ThumbFile
for name, thumbRequest := range thumbRequests {
thumb := uploadedfile.NewThumbFile(
thumbRequest.Width,
thumbRequest.MaxWidth,
thumbRequest.Height,
thumbRequest.MaxHeight,
name,
thumbRequest.Shape,
"", // shape
thumbRequest.CropGravity,
thumbRequest.CropWidth,
thumbRequest.CropHeight,
thumbRequest.CropRatio,
thumbRequest.Quality,
thumbRequest.DesiredFormat,
thumbRequest.NoStore,
)
thumbs = append(thumbs, thumb)
}
return thumbs, nil
}
func saveToTmp(upload io.Reader) (string, error) {
tmpFile, err := ioutil.TempFile(os.TempDir(), "image")
if err != nil {
fmt.Println(err)
return "", err
}
defer tmpFile.Close()
_, err = io.Copy(tmpFile, upload)
if err != nil {
fmt.Println(err)
return "", err
}
return tmpFile.Name(), nil
}
================================================
FILE: server/server_test.go
================================================
package server
import (
"bytes"
"crypto/hmac"
"crypto/sha256"
"encoding/base64"
"encoding/json"
"io/ioutil"
"net/http"
"net/http/httptest"
"net/url"
"strings"
"testing"
"time"
"github.com/Imgur/mandible/config"
"github.com/Imgur/mandible/imageprocessor"
"github.com/Imgur/mandible/imagestore"
)
func TestRequestingTheFrontPageGetsSomeHTML(t *testing.T) {
cfg := &config.Configuration{
MaxFileSize: 99999999999,
HashLength: 7,
UserAgent: "Foobar",
Stores: make([]map[string]string, 0),
Port: 8888,
}
memcfg := make(map[string]string)
memcfg["Type"] = "memory"
cfg.Stores = append(cfg.Stores, memcfg)
stats := &DiscardStats{}
server := NewServer(cfg, imageprocessor.PassthroughStrategy, stats)
muxer := http.NewServeMux()
server.Configure(muxer)
ts := httptest.NewServer(muxer)
defer ts.Close()
res, err := http.Get(ts.URL)
if err != nil {
t.Fatalf("Error when retrieving %s: %s", ts.URL, err.Error())
}
body, err := ioutil.ReadAll(res.Body)
if err != nil {
t.Fatalf("Failed to read response body of %s: %s", ts.URL, err.Error())
}
t.Logf("Response to %s/ was: %s", ts.URL, body)
if res.StatusCode != 200 {
t.Fatalf("Unexpected status code %d", res.StatusCode)
}
sbody := string(body)
if !strings.Contains(sbody, "") {
t.Fatalf("Did I get HTML back? Didn't find ...")
}
}
func TestPostingBase64FilePutsTheFileInStorageAndReturnsJSON(t *testing.T) {
cfg := &config.Configuration{
MaxFileSize: 99999999999,
HashLength: 7,
UserAgent: "Foobar",
Stores: make([]map[string]string, 0),
Port: 8888,
}
memcfg := make(map[string]string)
memcfg["Type"] = "memory"
cfg.Stores = append(cfg.Stores, memcfg)
stats := &DiscardStats{}
server := NewServer(cfg, imageprocessor.PassthroughStrategy, stats)
muxer := http.NewServeMux()
server.Configure(muxer)
ts := httptest.NewServer(muxer)
defer ts.Close()
// a 1x1 base64 encoded transparent GIF
b64bytes, _ := base64.StdEncoding.DecodeString(b64gif)
values := make(url.Values)
values.Add("image", b64gif)
res, err := http.PostForm(ts.URL+"/base64", values)
if err != nil {
t.Fatalf("Error when uploading base64 GIF: %s", err.Error())
}
body, err := ioutil.ReadAll(res.Body)
if err != nil {
t.Fatalf("Failed to read response body: %s", err.Error())
}
t.Logf("Response to /base64 was: %s", body)
if res.StatusCode != 200 {
t.Fatalf("Unexpected status code %d", res.StatusCode)
}
var serverResp ServerResponse
var imageResp ImageResponse
err = json.Unmarshal(body, &serverResp)
if err != nil {
t.Fatalf("Unexpected error parsing response: %s", err.Error())
}
if !*serverResp.Success {
t.Fatalf("Uploading GIF was unsuccessful")
}
imageRespBytes, _ := json.Marshal(serverResp.Data)
err = json.Unmarshal(imageRespBytes, &imageResp)
if imageResp.Height != 1 {
t.Fatalf("Expected height to be 1, instead %d", imageResp.Height)
}
if imageResp.Width != 1 {
t.Fatalf("Expected width to be 1, instead %d", imageResp.Width)
}
if imageResp.Size != 42 {
t.Fatalf("Expected size to be 42, instead %d", imageResp.Size)
}
if imageResp.Mime != "image/gif" {
t.Fatalf("Expected image MIME type to be image/gif, instead %s", imageResp.Mime)
}
immStore := server.ImageStore
exists, err := immStore.Exists(&imagestore.StoreObject{Id: imageResp.Hash})
if err != nil {
t.Fatalf("Unexpected error checking if %s exists in in-memory image store: %s", imageResp.Hash, err.Error())
}
if !exists {
t.Fatalf("Expected to find %s in the in-memory storage, instead absent. Dump: %+v", imageResp.Hash, immStore)
}
storedBodyReader, err := immStore.Get(&imagestore.StoreObject{Id: imageResp.Hash})
if err != nil {
t.Fatalf("Unexpected error fetching %s from in-memory image store: %s", imageResp.Hash, err.Error())
}
storedBodyBytes, _ := ioutil.ReadAll(storedBodyReader)
if !bytes.Equal(storedBodyBytes, []byte(b64bytes)) {
t.Fatalf("Stored bytes %s != %s", storedBodyBytes, []byte(b64bytes))
}
}
func TestAuthentication(t *testing.T) {
cfg := &config.Configuration{
MaxFileSize: 99999999999,
HashLength: 7,
UserAgent: "Foobar",
Stores: make([]map[string]string, 0),
Port: 8888,
}
memcfg := make(map[string]string)
memcfg["Type"] = "memory"
cfg.Stores = append(cfg.Stores, memcfg)
authenticator := NewHMACAuthenticatorSHA256([]byte("foobar"))
stats := &DiscardStats{}
server := NewAuthenticatedServer(cfg, imageprocessor.PassthroughStrategy, authenticator, stats)
muxer := http.NewServeMux()
server.Configure(muxer)
ts := httptest.NewServer(muxer)
defer ts.Close()
values := make(url.Values)
values.Add("image", b64gif)
req, err := http.NewRequest("POST", ts.URL+"/user/123/base64", strings.NewReader(values.Encode()))
if err != nil {
t.Fatalf("Error when forming authenticated base64 GIF upload request: %s", err.Error())
}
message := AuthenticatedUser{
UserID: "123",
GrantTime: time.Now(),
GrantDurationSeconds: 365 * 24 * 3600,
}
messageBytes, _ := json.Marshal(&message)
messageMacWriter := hmac.New(sha256.New, []byte("foobar"))
messageMacWriter.Write(messageBytes)
messageMac := base64.StdEncoding.EncodeToString(messageMacWriter.Sum(nil))
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
req.Header.Set("Authorization", string(messageBytes))
req.Header.Set("X-Authorization-HMAC", string(messageMac))
httpclient := http.Client{}
res, err := httpclient.Do(req)
if err != nil {
t.Fatalf("Error when uploading authenticated base64 GIF: %s", err.Error())
}
body, err := ioutil.ReadAll(res.Body)
if err != nil {
t.Fatalf("Failed to read response body: %s", err.Error())
}
t.Logf("Response to /base64 was: %s", body)
if res.StatusCode != 200 {
t.Fatalf("Unexpected status code %d", res.StatusCode)
}
var serverResp ServerResponse
var imageResp ImageResponse
err = json.Unmarshal(body, &serverResp)
if err != nil {
t.Fatalf("Unexpected error parsing response: %s", err.Error())
}
if !*serverResp.Success {
t.Fatalf("Uploading GIF was unsuccessful")
}
imageRespBytes, _ := json.Marshal(serverResp.Data)
err = json.Unmarshal(imageRespBytes, &imageResp)
if imageResp.Mime != "image/gif" {
t.Fatalf("Expected image MIME type to be image/gif, instead %s", imageResp.Mime)
}
if imageResp.UserID != "123" {
t.Fatalf("Expected user ID to be \"123\", instead \"%s\"", imageResp.UserID)
}
}
func TestGetFullWebpThumb(t *testing.T) {
cfg := &config.Configuration{
MaxFileSize: 99999999999,
HashLength: 7,
UserAgent: "Foobar",
Stores: make([]map[string]string, 0),
Port: 8888,
}
memcfg := make(map[string]string)
memcfg["Type"] = "memory"
cfg.Stores = append(cfg.Stores, memcfg)
stats := &DiscardStats{}
server := NewServer(cfg, imageprocessor.ThumbnailStrategy, stats)
muxer := http.NewServeMux()
server.Configure(muxer)
ts := httptest.NewServer(muxer)
defer ts.Close()
thumbsJson, _ := json.Marshal(map[string]interface{}{
"webp": map[string]interface{}{
"format": "webp",
},
})
values := make(url.Values)
values.Add("image", b64dan)
values.Add("thumbs", string(thumbsJson))
res, err := http.PostForm(ts.URL+"/base64", values)
if err != nil {
t.Fatalf("Error when uploading base64 image: %s", err.Error())
}
body, err := ioutil.ReadAll(res.Body)
if err != nil {
t.Fatalf("Failed to read response body: %s", err.Error())
}
t.Logf("Response to /base64 was: %s", body)
if res.StatusCode != 200 {
t.Fatalf("Unexpected status code %d", res.StatusCode)
}
var serverResp ServerResponse
var imageResp ImageResponse
err = json.Unmarshal(body, &serverResp)
if err != nil {
t.Fatalf("Unexpected error parsing response: %s", err.Error())
}
if !*serverResp.Success {
t.Fatalf("Uploading image was unsuccessful")
}
imageRespBytes, _ := json.Marshal(serverResp.Data)
err = json.Unmarshal(imageRespBytes, &imageResp)
if len(imageResp.Thumbs) == 0 {
t.Fatalf("Expected thumbs to contain data, instead blank")
}
if _, ok := imageResp.Thumbs["webp"]; !ok {
t.Fatalf("Expected webp thumb, not given")
}
immStore := server.ImageStore
storeId := imageResp.Hash + "/webp"
exists, err := immStore.Exists(&imagestore.StoreObject{Id: storeId})
if err != nil {
t.Fatalf("Unexpected error checking if %s exists in in-memory image store: %s", storeId, err.Error())
}
if !exists {
t.Fatalf("Expected to find %s in the in-memory storage, instead absent. Dump: %+v", storeId, immStore)
}
storedBodyReader, err := immStore.Get(&imagestore.StoreObject{Id: storeId})
if err != nil {
t.Fatalf("Unexpected error fetching %s from in-memory image store: %s", storeId, err.Error())
}
storedBodyBytes, _ := ioutil.ReadAll(storedBodyReader)
if len(storedBodyBytes) == 0 {
t.Fatalf("Expected webp thumbnail to be larger than 0 bytes")
}
if int64(len(storedBodyBytes)) >= imageResp.Size {
t.Fatalf("Expected thumbnail to be smaller than original image, %v vs %v", int64(len(storedBodyBytes)), imageResp.Size)
}
}
func TestGetSizedWebpThumb(t *testing.T) {
cfg := &config.Configuration{
MaxFileSize: 99999999999,
HashLength: 7,
UserAgent: "Foobar",
Stores: make([]map[string]string, 0),
Port: 8888,
}
memcfg := make(map[string]string)
memcfg["Type"] = "memory"
cfg.Stores = append(cfg.Stores, memcfg)
stats := &DiscardStats{}
server := NewServer(cfg, imageprocessor.ThumbnailStrategy, stats)
muxer := http.NewServeMux()
server.Configure(muxer)
ts := httptest.NewServer(muxer)
defer ts.Close()
thumbsJson, _ := json.Marshal(map[string]interface{}{
"webp": map[string]interface{}{
"format": "webp",
},
"webpthumb": map[string]interface{}{
"format": "webp",
"shape": "custom",
"width": 10,
"height": 10,
},
})
values := make(url.Values)
values.Add("image", b64dan)
values.Add("thumbs", string(thumbsJson))
res, err := http.PostForm(ts.URL+"/base64", values)
if err != nil {
t.Fatalf("Error when uploading base64 iamge: %s", err.Error())
}
body, err := ioutil.ReadAll(res.Body)
if err != nil {
t.Fatalf("Failed to read response body: %s", err.Error())
}
t.Logf("Response to /base64 was: %s", body)
if res.StatusCode != 200 {
t.Fatalf("Unexpected status code %d", res.StatusCode)
}
var serverResp ServerResponse
var imageResp ImageResponse
err = json.Unmarshal(body, &serverResp)
if err != nil {
t.Fatalf("Unexpected error parsing response: %s", err.Error())
}
if !*serverResp.Success {
t.Fatalf("Uploading image was unsuccessful")
}
imageRespBytes, _ := json.Marshal(serverResp.Data)
err = json.Unmarshal(imageRespBytes, &imageResp)
if len(imageResp.Thumbs) == 0 {
t.Fatalf("Expected thumbs to contain data, instead blank")
}
if _, ok := imageResp.Thumbs["webp"]; !ok {
t.Fatalf("Expected webp thumb, not given")
}
immStore := server.ImageStore
storeId := imageResp.Hash + "/webp"
storeIdSmall := imageResp.Hash + "/webpthumb"
exists, err := immStore.Exists(&imagestore.StoreObject{Id: storeIdSmall})
if err != nil {
t.Fatalf("Unexpected error checking if %s exists in in-memory image store: %s", storeIdSmall, err.Error())
}
if !exists {
t.Fatalf("Expected to find %s in the in-memory storage, instead absent. Dump: %+v", storeIdSmall, immStore)
}
storedBodyReader, err := immStore.Get(&imagestore.StoreObject{Id: storeId})
if err != nil {
t.Fatalf("Unexpected error fetching %s from in-memory image store: %s", storeId, err.Error())
}
storedBodyReaderSmall, err := immStore.Get(&imagestore.StoreObject{Id: storeIdSmall})
if err != nil {
t.Fatalf("Unexpected error fetching %s from in-memory image store: %s", storeIdSmall, err.Error())
}
storedBodyBytes, _ := ioutil.ReadAll(storedBodyReader)
storedBodyBytesSmall, _ := ioutil.ReadAll(storedBodyReaderSmall)
if len(storedBodyBytesSmall) == 0 {
t.Fatalf("Expected webp thumbnail to be larger than 0 bytes")
}
if len(storedBodyBytesSmall) >= len(storedBodyBytes) {
t.Fatalf("Expected thumbnail to be smaller than original image, %v vs %v", len(storedBodyBytesSmall), len(storedBodyBytes))
}
}
func TestTooLarge(t *testing.T) {
cfg := &config.Configuration{
MaxFileSize: 99999999999,
HashLength: 7,
UserAgent: "Foobar",
Stores: make([]map[string]string, 0),
Port: 8888,
}
memcfg := make(map[string]string)
memcfg["Type"] = "memory"
cfg.Stores = append(cfg.Stores, memcfg)
stats := &DiscardStats{}
server := NewServer(cfg, imageprocessor.ThumbnailStrategy, stats)
muxer := http.NewServeMux()
server.Configure(muxer)
ts := httptest.NewServer(muxer)
defer ts.Close()
thumbsJson, _ := json.Marshal(map[string]interface{}{
"webp": map[string]interface{}{
"format": "webp",
"shape": "custom",
"width": 20000,
"height": 20000,
},
})
values := make(url.Values)
values.Add("image", b64dan)
values.Add("thumbs", string(thumbsJson))
res, err := http.PostForm(ts.URL+"/base64", values)
if err != nil {
t.Fatalf("Error when uploading base64 iamge: %s", err.Error())
}
body, err := ioutil.ReadAll(res.Body)
if err != nil {
t.Fatalf("Failed to read response body: %s", err.Error())
}
t.Logf("Response to /base64 was: %s", body)
if res.StatusCode != 500 {
t.Fatalf("Unexpected status code %d", res.StatusCode)
}
var serverResp ServerResponse
err = json.Unmarshal(body, &serverResp)
if err != nil {
t.Fatalf("Unexpected error parsing response: %s", err.Error())
}
if *serverResp.Success {
t.Fatalf("Uploading large image was successful")
}
}
func TestTooSmall(t *testing.T) {
cfg := &config.Configuration{
MaxFileSize: 99999999999,
HashLength: 7,
UserAgent: "Foobar",
Stores: make([]map[string]string, 0),
Port: 8888,
}
memcfg := make(map[string]string)
memcfg["Type"] = "memory"
cfg.Stores = append(cfg.Stores, memcfg)
stats := &DiscardStats{}
server := NewServer(cfg, imageprocessor.ThumbnailStrategy, stats)
muxer := http.NewServeMux()
server.Configure(muxer)
ts := httptest.NewServer(muxer)
defer ts.Close()
thumbsJson, _ := json.Marshal(map[string]interface{}{
"webp": map[string]interface{}{
"format": "webp",
"shape": "custom",
"width": 0,
"height": 0,
},
})
values := make(url.Values)
values.Add("image", b64dan)
values.Add("thumbs", string(thumbsJson))
res, err := http.PostForm(ts.URL+"/base64", values)
if err != nil {
t.Fatalf("Error when uploading base64 image: %s", err.Error())
}
body, err := ioutil.ReadAll(res.Body)
if err != nil {
t.Fatalf("Failed to read response body: %s", err.Error())
}
t.Logf("Response to /base64 was: %s", body)
if res.StatusCode != 500 {
t.Fatalf("Unexpected status code %d", res.StatusCode)
}
var serverResp ServerResponse
err = json.Unmarshal(body, &serverResp)
if err != nil {
t.Fatalf("Unexpected error parsing response: %s", err.Error())
}
if *serverResp.Success {
t.Fatalf("Uploading small image was successful")
}
}
func TestGetTallThumb(t *testing.T) {
cfg := &config.Configuration{
MaxFileSize: 99999999999,
HashLength: 7,
UserAgent: "Foobar",
Stores: make([]map[string]string, 0),
Port: 8888,
}
memcfg := make(map[string]string)
memcfg["Type"] = "memory"
cfg.Stores = append(cfg.Stores, memcfg)
stats := &DiscardStats{}
server := NewServer(cfg, imageprocessor.ThumbnailStrategy, stats)
muxer := http.NewServeMux()
server.Configure(muxer)
ts := httptest.NewServer(muxer)
defer ts.Close()
thumbsJson, _ := json.Marshal(map[string]interface{}{
"tallthumb": map[string]interface{}{
"shape": "custom",
"crop_gravity": "north",
"crop_ratio": "1:2.25",
"max_width": 10,
},
})
values := make(url.Values)
values.Add("image", b64dan)
values.Add("thumbs", string(thumbsJson))
res, err := http.PostForm(ts.URL+"/base64", values)
if err != nil {
t.Fatalf("Error when uploading base64 iamge: %s", err.Error())
}
body, err := ioutil.ReadAll(res.Body)
if err != nil {
t.Fatalf("Failed to read response body: %s", err.Error())
}
t.Logf("Response to /base64 was: %s", body)
if res.StatusCode != 200 {
t.Fatalf("Unexpected status code %d", res.StatusCode)
}
var serverResp ServerResponse
var imageResp ImageResponse
err = json.Unmarshal(body, &serverResp)
if err != nil {
t.Fatalf("Unexpected error parsing response: %s", err.Error())
}
if !*serverResp.Success {
t.Fatalf("Uploading image was unsuccessful")
}
imageRespBytes, _ := json.Marshal(serverResp.Data)
err = json.Unmarshal(imageRespBytes, &imageResp)
if len(imageResp.Thumbs) == 0 {
t.Fatalf("Expected thumbs to contain data, instead blank")
}
if _, ok := imageResp.Thumbs["tallthumb"]; !ok {
t.Fatalf("Expected cropped thumb, not given")
}
immStore := server.ImageStore
storeId := imageResp.Hash
storeIdSmall := imageResp.Hash + "/tallthumb"
exists, err := immStore.Exists(&imagestore.StoreObject{Id: storeIdSmall})
if err != nil {
t.Fatalf("Unexpected error checking if %s exists in in-memory image store: %s", storeIdSmall, err.Error())
}
if !exists {
t.Fatalf("Expected to find %s in the in-memory storage, instead absent. Dump: %+v", storeIdSmall, immStore)
}
storedBodyReader, err := immStore.Get(&imagestore.StoreObject{Id: storeId})
if err != nil {
t.Fatalf("Unexpected error fetching %s from in-memory image store: %s", storeId, err.Error())
}
storedBodyReaderSmall, err := immStore.Get(&imagestore.StoreObject{Id: storeIdSmall})
if err != nil {
t.Fatalf("Unexpected error fetching %s from in-memory image store: %s", storeIdSmall, err.Error())
}
storedBodyBytes, _ := ioutil.ReadAll(storedBodyReader)
storedBodyBytesSmall, _ := ioutil.ReadAll(storedBodyReaderSmall)
if len(storedBodyBytesSmall) == 0 {
t.Fatalf("Expected webp thumbnail to be larger than 0 bytes")
}
if len(storedBodyBytesSmall) >= len(storedBodyBytes) {
t.Fatalf("Expected thumbnail to be smaller than original image, %v vs %v", len(storedBodyBytesSmall), len(storedBodyBytes))
}
}
var (
b64gif = "R0lGODlhAQABAIAAAAAAAP" + "/" + "/" + "/yH5BAEAAAAALAAAAAABAAEAAAIBRAA7"
b64dan = "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"
)
================================================
FILE: server/stats.go
================================================
package server
import (
"fmt"
"net"
"time"
"github.com/PagerDuty/godspeed"
)
type RuntimeStats interface {
LogStartup()
Request(url string)
ResponseTime(elapsed time.Duration, url string)
Thumbnail(name string)
Upload(source string)
Error(code int)
}
type DiscardStats struct{}
func (d *DiscardStats) LogStartup() {}
func (d *DiscardStats) Request(url string) {}
func (d *DiscardStats) ResponseTime(elapsed time.Duration, url string) {}
func (d *DiscardStats) Thumbnail(name string) {}
func (d *DiscardStats) Upload(source string) {}
func (d *DiscardStats) Error(code int) {}
type DatadogStats struct {
dog *godspeed.Godspeed
}
func NewDatadogStats(datadogHost string) (*DatadogStats, error) {
var ip net.IP = nil
var err error = nil
// Assume datadogHost is an IP and try to parse it
ip = net.ParseIP(datadogHost)
// Parsing failed
if ip == nil {
ips, _ := net.LookupIP(datadogHost)
if len(ips) > 0 {
ip = ips[0]
}
}
if ip != nil {
gdsp, err := godspeed.New(ip.String(), godspeed.DefaultPort, false)
if err == nil {
return &DatadogStats{gdsp}, nil
}
}
return nil, err
}
func (d *DatadogStats) LogStartup() {
d.dog.Incr("mandible.startup", nil)
}
func (d *DatadogStats) Request(url string) {
tag := fmt.Sprintf("url:%s", url)
d.dog.Incr("mandible.request", []string{tag})
}
func (d *DatadogStats) ResponseTime(elapsed time.Duration, url string) {
time := elapsed.Seconds()
tag := fmt.Sprintf("url:%s", url)
d.dog.Timing("mandible.responseTime", time, []string{tag})
}
func (d *DatadogStats) Thumbnail(name string) {
tag := fmt.Sprintf("size:%s", name)
d.dog.Incr("mandible.thumbnail", []string{tag})
}
func (d *DatadogStats) Upload(source string) {
tag := fmt.Sprintf("source:%s", source)
d.dog.Incr("mandible.upload", []string{tag})
}
func (d *DatadogStats) Error(code int) {
tag := fmt.Sprintf("code:%d", code)
d.dog.Incr("mandible.error", []string{tag})
}
================================================
FILE: uploadedfile/thumbfile.go
================================================
package uploadedfile
import (
"errors"
"fmt"
"math"
"os"
"regexp"
"strconv"
"github.com/Imgur/mandible/imageprocessor/processorcommand"
"github.com/Imgur/mandible/imageprocessor/thumbType"
)
var (
defaultQuality = 83
maxImageSideSize = 10000
)
type ThumbFile struct {
localPath string
Name string
Width int
MaxWidth int
Height int
MaxHeight int
Shape string
CropGravity string
CropWidth int
CropHeight int
CropRatio string
Quality int
Format string
StoreURI string
DesiredFormat string
NoStore bool
}
func NewThumbFile(width, maxWidth, height, maxHeight int, name, shape, path, cropGravity string, cropWidth, cropHeight int, cropRatio string, quality int, desiredFormat string, noStore bool) *ThumbFile {
if quality == 0 {
quality = defaultQuality
}
return &ThumbFile{
localPath: path,
Name: name,
Width: width,
MaxWidth: maxWidth,
Height: height,
MaxHeight: maxHeight,
Shape: shape,
CropGravity: cropGravity,
CropWidth: cropWidth,
CropHeight: cropHeight,
CropRatio: cropRatio,
Quality: quality,
Format: "",
StoreURI: "",
DesiredFormat: desiredFormat,
NoStore: noStore,
}
}
func (this *ThumbFile) GetNoStore() bool {
return this.NoStore
}
func (this *ThumbFile) SetPath(path string) error {
if _, err := os.Stat(path); os.IsNotExist(err) {
return errors.New(fmt.Sprintf("Error when creating thumbnail %s", this.Name))
}
this.localPath = path
return nil
}
func (this *ThumbFile) GetPath() string {
return this.localPath
}
func (this *ThumbFile) GetOutputFormat(original *UploadedFile) thumbType.ThumbType {
if this.DesiredFormat != "" {
return thumbType.FromString(this.DesiredFormat)
}
return thumbType.FromMime(original.GetMime())
}
func (this *ThumbFile) ComputeWidth(original *UploadedFile) int {
width := this.Width
oWidth, _, err := original.Dimensions()
if err != nil {
return 0
}
if this.MaxWidth > 0 {
width = int(math.Min(float64(oWidth), float64(this.MaxWidth)))
}
return width
}
func (this *ThumbFile) ComputeHeight(original *UploadedFile) int {
height := this.Height
_, oHeight, err := original.Dimensions()
if err != nil {
return 0
}
if this.MaxHeight > 0 {
height = int(math.Min(float64(oHeight), float64(this.MaxHeight)))
}
return height
}
func (this *ThumbFile) ComputeCrop(original *UploadedFile) (int, int, error) {
re := regexp.MustCompile("(.*):(.*)")
matches := re.FindStringSubmatch(this.CropRatio)
if len(matches) != 3 {
return 0, 0, errors.New("Invalid crop_ratio")
}
wRatio, werr := strconv.ParseFloat(matches[1], 64)
hRatio, herr := strconv.ParseFloat(matches[2], 64)
if werr != nil || herr != nil {
return 0, 0, errors.New("Invalid crop_ratio")
}
var cropWidth, cropHeight float64
if wRatio >= hRatio {
wRatio = wRatio / hRatio
hRatio = 1
cropWidth = math.Ceil(float64(this.ComputeHeight(original)) * wRatio)
cropHeight = math.Ceil(float64(this.ComputeHeight(original)) * hRatio)
} else {
hRatio = hRatio / wRatio
wRatio = 1
cropWidth = math.Ceil(float64(this.ComputeWidth(original)) * wRatio)
cropHeight = math.Ceil(float64(this.ComputeWidth(original)) * hRatio)
}
return int(cropWidth), int(cropHeight), nil
}
func (this *ThumbFile) Process(original *UploadedFile) error {
switch this.Shape {
case "circle":
return this.processCircle(original)
case "thumb":
return this.processThumb(original)
case "square":
return this.processSquare(original)
case "custom":
return this.processCustom(original)
default:
return this.processFull(original)
}
}
func (this *ThumbFile) String() string {
return fmt.Sprintf("Thumbnail of <%s>", this.Name)
}
func (this *ThumbFile) processSquare(original *UploadedFile) error {
if this.Width == 0 {
return errors.New("Width cannot be 0")
}
if this.Width > maxImageSideSize {
return errors.New("Width too large")
}
filename, err := processorcommand.SquareThumb(original.GetPath(), this.Name, this.Width, this.Quality, this.GetOutputFormat(original))
if err != nil {
return err
}
if err := this.SetPath(filename); err != nil {
return err
}
return nil
}
func (this *ThumbFile) processCircle(original *UploadedFile) error {
if this.Width == 0 {
return errors.New("Width cannot be 0")
}
if this.Width > maxImageSideSize {
return errors.New("Width too large")
}
//Circle thumbs should always be PNGs
outputFormat := thumbType.FromString("png")
filename, err := processorcommand.CircleThumb(original.GetPath(), this.Name, this.Width, this.Quality, outputFormat)
if err != nil {
return err
}
if err := this.SetPath(filename); err != nil {
return err
}
return nil
}
func (this *ThumbFile) processThumb(original *UploadedFile) error {
if this.Width == 0 {
return errors.New("Width cannot be 0")
}
if this.Width > maxImageSideSize {
return errors.New("Width too large")
}
if this.Height == 0 {
return errors.New("Height cannot be 0")
}
if this.Height > maxImageSideSize {
return errors.New("Height too large")
}
filename, err := processorcommand.Thumb(original.GetPath(), this.Name, this.Width, this.Height, this.Quality, this.GetOutputFormat(original))
if err != nil {
return err
}
if err := this.SetPath(filename); err != nil {
return err
}
return nil
}
func (this *ThumbFile) processCustom(original *UploadedFile) error {
cropWidth := this.CropWidth
cropHeight := this.CropHeight
var err error
if this.CropRatio != "" {
cropWidth, cropHeight, err = this.ComputeCrop(original)
if err != nil {
return err
}
}
width := this.ComputeWidth(original)
height := this.ComputeHeight(original)
validWidth := width > 0 && width <= maxImageSideSize
validHeight := height > 0 && height <= maxImageSideSize
if !validWidth && !validHeight {
if !validWidth {
return errors.New("Invalid width")
}
return errors.New("Invalid height")
}
filename, err := processorcommand.CustomThumb(original.GetPath(), this.Name, width, height, this.CropGravity, cropWidth, cropHeight, this.Quality, this.GetOutputFormat(original))
if err != nil {
return err
}
if err := this.SetPath(filename); err != nil {
return err
}
return nil
}
func (this *ThumbFile) processFull(original *UploadedFile) error {
filename, err := processorcommand.Full(original.GetPath(), this.Name, this.Quality, this.GetOutputFormat(original))
if err != nil {
return err
}
if err := this.SetPath(filename); err != nil {
return err
}
return nil
}
================================================
FILE: uploadedfile/uploadedfile.go
================================================
package uploadedfile
import (
"errors"
"image"
"image/gif"
"image/jpeg"
"image/png"
"net/http"
"os"
)
type UploadedFile struct {
filename string
path string
mime string
hash string
ocrText string
thumbs []*ThumbFile
}
var supportedTypes = map[string]bool{
"image/jpeg": true,
"image/jpg": true,
"image/gif": true,
"image/png": true,
}
func NewUploadedFile(filename, path string, thumbs []*ThumbFile) (*UploadedFile, error) {
file, err := os.Open(path)
if err != nil {
return nil, err
}
buff := make([]byte, 512) // http://golang.org/pkg/net/http/#DetectContentType
_, err = file.Read(buff)
if err != nil {
return nil, err
}
filetype := http.DetectContentType(buff)
if _, ok := supportedTypes[filetype]; !ok {
return nil, errors.New("Unsupported file type!")
}
return &UploadedFile{
filename,
path,
filetype,
"",
"",
thumbs,
}, nil
}
func (this *UploadedFile) GetFilename() string {
return this.filename
}
func (this *UploadedFile) SetFilename(filename string) {
this.filename = filename
}
func (this *UploadedFile) GetHash() string {
return this.hash
}
func (this *UploadedFile) SetHash(hash string) {
this.hash = hash
}
func (this *UploadedFile) GetOCRText() string {
return this.ocrText
}
func (this *UploadedFile) SetOCRText(text string) {
this.ocrText = text
}
func (this *UploadedFile) SetPath(path string) {
// TODO: find a better location for this
os.Remove(this.path)
this.path = path
}
func (this *UploadedFile) GetPath() string {
return this.path
}
func (this *UploadedFile) GetMime() string {
return this.mime
}
func (this *UploadedFile) SetMime(mime string) {
this.mime = mime
}
func (this *UploadedFile) SetThumbs(thumbs []*ThumbFile) {
this.thumbs = thumbs
}
func (this *UploadedFile) GetThumbs() []*ThumbFile {
return this.thumbs
}
func (this *UploadedFile) FileSize() (int64, error) {
f, err := os.Open(this.path)
if err != nil {
return 0, err
}
stats, err := f.Stat()
if err != nil {
return 0, err
}
size := stats.Size()
return size, nil
}
func (this *UploadedFile) Clean() {
os.Remove(this.path)
for _, thumb := range this.thumbs {
os.Remove(thumb.GetPath())
}
}
func (this *UploadedFile) Dimensions() (int, int, error) {
f, err := os.Open(this.path)
if err != nil {
return 0, 0, err
}
var cfg image.Config
switch true {
case this.IsGif():
cfg, err = gif.DecodeConfig(f)
case this.IsPng():
cfg, err = png.DecodeConfig(f)
case this.IsJpeg():
cfg, err = jpeg.DecodeConfig(f)
default:
return 0, 0, errors.New("Invalid mime type!")
}
if err != nil {
return 0, 0, err
}
return cfg.Width, cfg.Height, nil
}
func (this *UploadedFile) IsJpeg() bool {
return (this.GetMime() == "image/jpeg" || this.GetMime() == "image/jpg")
}
func (this *UploadedFile) IsPng() bool {
return this.GetMime() == "image/png"
}
func (this *UploadedFile) IsGif() bool {
return this.GetMime() == "image/gif"
}
================================================
FILE: vendor/github.com/PagerDuty/godspeed/.gitignore
================================================
# Misc
*.swp
# Compiled Object files, Static and Dynamic libs (Shared Objects)
*.o
*.a
*.so
# Folders
_obj
_test
# Architecture specific extensions/prefixes
*.[568vq]
[568vq].out
*.cgo1.go
*.cgo2.c
_cgo_defun.c
_cgo_gotypes.go
_cgo_export.*
_testmain.go
*.exe
*.test
*.prof
================================================
FILE: vendor/github.com/PagerDuty/godspeed/.travis.yml
================================================
language: go
go:
- 1.5.3
branches:
only:
- master
script: go test -v ./... -check.vv
sudo: false
================================================
FILE: vendor/github.com/PagerDuty/godspeed/LICENSE
================================================
Copyright (c) 2014-2015, PagerDuty Inc.
All rights reserved.
Redistribution and use in source and binary forms, with or without modification,
are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice, this
list of conditions and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright notice,
this list of conditions and the following disclaimer in the documentation
and/or other materials provided with the distribution.
3. Neither the name of PagerDuty nor the names of its contributors may be used
to endorse or promote products derived from this software without specific
prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL PagerDuty OR CONTRIBUTORS BE LIABLE FOR ANY
DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
================================================
FILE: vendor/github.com/PagerDuty/godspeed/README.md
================================================
# Godspeed
[](https://travis-ci.org/PagerDuty/godspeed)
[](https://godoc.org/github.com/PagerDuty/godspeed)
[](https://github.com/PagerDuty/godspeed/blob/master/LICENSE)
Godspeed is a statsd client for the Datadog extension of statsd (DogStatsD).
The name `godspeed` is a bit of a rhyming slang twist on DogStatsD. It's also a
poke at the fact that the statsd protocol's transport mechanism is UDP...
Check out [GoDoc](https://godoc.org/github.com/PagerDuty/godspeed) for the docs
as well as some examples.
DogStatsD is a copyright of `Datadog