diff options
author | Nathan Dench <ndenc2@gmail.com> | 2019-05-24 15:16:44 +1000 |
---|---|---|
committer | Nathan Dench <ndenc2@gmail.com> | 2019-05-24 15:16:44 +1000 |
commit | 107c1cdb09c575aa2f61d97f48d8587eb6bada4c (patch) | |
tree | ca7d008643efc555c388baeaf1d986e0b6b3e28c /vendor/google.golang.org/appengine/internal | |
parent | 844b5a68d8af4791755b8f0ad293cc99f5959183 (diff) | |
download | terraform-provider-statuscake-107c1cdb09c575aa2f61d97f48d8587eb6bada4c.tar.gz terraform-provider-statuscake-107c1cdb09c575aa2f61d97f48d8587eb6bada4c.tar.zst terraform-provider-statuscake-107c1cdb09c575aa2f61d97f48d8587eb6bada4c.zip |
Upgrade to 0.12
Diffstat (limited to 'vendor/google.golang.org/appengine/internal')
30 files changed, 10984 insertions, 0 deletions
diff --git a/vendor/google.golang.org/appengine/internal/api.go b/vendor/google.golang.org/appengine/internal/api.go new file mode 100644 index 0000000..bbc1cb9 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/api.go | |||
@@ -0,0 +1,671 @@ | |||
1 | // Copyright 2011 Google Inc. All rights reserved. | ||
2 | // Use of this source code is governed by the Apache 2.0 | ||
3 | // license that can be found in the LICENSE file. | ||
4 | |||
5 | // +build !appengine | ||
6 | |||
7 | package internal | ||
8 | |||
9 | import ( | ||
10 | "bytes" | ||
11 | "errors" | ||
12 | "fmt" | ||
13 | "io/ioutil" | ||
14 | "log" | ||
15 | "net" | ||
16 | "net/http" | ||
17 | "net/url" | ||
18 | "os" | ||
19 | "runtime" | ||
20 | "strconv" | ||
21 | "strings" | ||
22 | "sync" | ||
23 | "sync/atomic" | ||
24 | "time" | ||
25 | |||
26 | "github.com/golang/protobuf/proto" | ||
27 | netcontext "golang.org/x/net/context" | ||
28 | |||
29 | basepb "google.golang.org/appengine/internal/base" | ||
30 | logpb "google.golang.org/appengine/internal/log" | ||
31 | remotepb "google.golang.org/appengine/internal/remote_api" | ||
32 | ) | ||
33 | |||
34 | const ( | ||
35 | apiPath = "/rpc_http" | ||
36 | defaultTicketSuffix = "/default.20150612t184001.0" | ||
37 | ) | ||
38 | |||
39 | var ( | ||
40 | // Incoming headers. | ||
41 | ticketHeader = http.CanonicalHeaderKey("X-AppEngine-API-Ticket") | ||
42 | dapperHeader = http.CanonicalHeaderKey("X-Google-DapperTraceInfo") | ||
43 | traceHeader = http.CanonicalHeaderKey("X-Cloud-Trace-Context") | ||
44 | curNamespaceHeader = http.CanonicalHeaderKey("X-AppEngine-Current-Namespace") | ||
45 | userIPHeader = http.CanonicalHeaderKey("X-AppEngine-User-IP") | ||
46 | remoteAddrHeader = http.CanonicalHeaderKey("X-AppEngine-Remote-Addr") | ||
47 | |||
48 | // Outgoing headers. | ||
49 | apiEndpointHeader = http.CanonicalHeaderKey("X-Google-RPC-Service-Endpoint") | ||
50 | apiEndpointHeaderValue = []string{"app-engine-apis"} | ||
51 | apiMethodHeader = http.CanonicalHeaderKey("X-Google-RPC-Service-Method") | ||
52 | apiMethodHeaderValue = []string{"/VMRemoteAPI.CallRemoteAPI"} | ||
53 | apiDeadlineHeader = http.CanonicalHeaderKey("X-Google-RPC-Service-Deadline") | ||
54 | apiContentType = http.CanonicalHeaderKey("Content-Type") | ||
55 | apiContentTypeValue = []string{"application/octet-stream"} | ||
56 | logFlushHeader = http.CanonicalHeaderKey("X-AppEngine-Log-Flush-Count") | ||
57 | |||
58 | apiHTTPClient = &http.Client{ | ||
59 | Transport: &http.Transport{ | ||
60 | Proxy: http.ProxyFromEnvironment, | ||
61 | Dial: limitDial, | ||
62 | }, | ||
63 | } | ||
64 | |||
65 | defaultTicketOnce sync.Once | ||
66 | defaultTicket string | ||
67 | backgroundContextOnce sync.Once | ||
68 | backgroundContext netcontext.Context | ||
69 | ) | ||
70 | |||
71 | func apiURL() *url.URL { | ||
72 | host, port := "appengine.googleapis.internal", "10001" | ||
73 | if h := os.Getenv("API_HOST"); h != "" { | ||
74 | host = h | ||
75 | } | ||
76 | if p := os.Getenv("API_PORT"); p != "" { | ||
77 | port = p | ||
78 | } | ||
79 | return &url.URL{ | ||
80 | Scheme: "http", | ||
81 | Host: host + ":" + port, | ||
82 | Path: apiPath, | ||
83 | } | ||
84 | } | ||
85 | |||
86 | func handleHTTP(w http.ResponseWriter, r *http.Request) { | ||
87 | c := &context{ | ||
88 | req: r, | ||
89 | outHeader: w.Header(), | ||
90 | apiURL: apiURL(), | ||
91 | } | ||
92 | r = r.WithContext(withContext(r.Context(), c)) | ||
93 | c.req = r | ||
94 | |||
95 | stopFlushing := make(chan int) | ||
96 | |||
97 | // Patch up RemoteAddr so it looks reasonable. | ||
98 | if addr := r.Header.Get(userIPHeader); addr != "" { | ||
99 | r.RemoteAddr = addr | ||
100 | } else if addr = r.Header.Get(remoteAddrHeader); addr != "" { | ||
101 | r.RemoteAddr = addr | ||
102 | } else { | ||
103 | // Should not normally reach here, but pick a sensible default anyway. | ||
104 | r.RemoteAddr = "127.0.0.1" | ||
105 | } | ||
106 | // The address in the headers will most likely be of these forms: | ||
107 | // 123.123.123.123 | ||
108 | // 2001:db8::1 | ||
109 | // net/http.Request.RemoteAddr is specified to be in "IP:port" form. | ||
110 | if _, _, err := net.SplitHostPort(r.RemoteAddr); err != nil { | ||
111 | // Assume the remote address is only a host; add a default port. | ||
112 | r.RemoteAddr = net.JoinHostPort(r.RemoteAddr, "80") | ||
113 | } | ||
114 | |||
115 | // Start goroutine responsible for flushing app logs. | ||
116 | // This is done after adding c to ctx.m (and stopped before removing it) | ||
117 | // because flushing logs requires making an API call. | ||
118 | go c.logFlusher(stopFlushing) | ||
119 | |||
120 | executeRequestSafely(c, r) | ||
121 | c.outHeader = nil // make sure header changes aren't respected any more | ||
122 | |||
123 | stopFlushing <- 1 // any logging beyond this point will be dropped | ||
124 | |||
125 | // Flush any pending logs asynchronously. | ||
126 | c.pendingLogs.Lock() | ||
127 | flushes := c.pendingLogs.flushes | ||
128 | if len(c.pendingLogs.lines) > 0 { | ||
129 | flushes++ | ||
130 | } | ||
131 | c.pendingLogs.Unlock() | ||
132 | flushed := make(chan struct{}) | ||
133 | go func() { | ||
134 | defer close(flushed) | ||
135 | // Force a log flush, because with very short requests we | ||
136 | // may not ever flush logs. | ||
137 | c.flushLog(true) | ||
138 | }() | ||
139 | w.Header().Set(logFlushHeader, strconv.Itoa(flushes)) | ||
140 | |||
141 | // Avoid nil Write call if c.Write is never called. | ||
142 | if c.outCode != 0 { | ||
143 | w.WriteHeader(c.outCode) | ||
144 | } | ||
145 | if c.outBody != nil { | ||
146 | w.Write(c.outBody) | ||
147 | } | ||
148 | // Wait for the last flush to complete before returning, | ||
149 | // otherwise the security ticket will not be valid. | ||
150 | <-flushed | ||
151 | } | ||
152 | |||
153 | func executeRequestSafely(c *context, r *http.Request) { | ||
154 | defer func() { | ||
155 | if x := recover(); x != nil { | ||
156 | logf(c, 4, "%s", renderPanic(x)) // 4 == critical | ||
157 | c.outCode = 500 | ||
158 | } | ||
159 | }() | ||
160 | |||
161 | http.DefaultServeMux.ServeHTTP(c, r) | ||
162 | } | ||
163 | |||
164 | func renderPanic(x interface{}) string { | ||
165 | buf := make([]byte, 16<<10) // 16 KB should be plenty | ||
166 | buf = buf[:runtime.Stack(buf, false)] | ||
167 | |||
168 | // Remove the first few stack frames: | ||
169 | // this func | ||
170 | // the recover closure in the caller | ||
171 | // That will root the stack trace at the site of the panic. | ||
172 | const ( | ||
173 | skipStart = "internal.renderPanic" | ||
174 | skipFrames = 2 | ||
175 | ) | ||
176 | start := bytes.Index(buf, []byte(skipStart)) | ||
177 | p := start | ||
178 | for i := 0; i < skipFrames*2 && p+1 < len(buf); i++ { | ||
179 | p = bytes.IndexByte(buf[p+1:], '\n') + p + 1 | ||
180 | if p < 0 { | ||
181 | break | ||
182 | } | ||
183 | } | ||
184 | if p >= 0 { | ||
185 | // buf[start:p+1] is the block to remove. | ||
186 | // Copy buf[p+1:] over buf[start:] and shrink buf. | ||
187 | copy(buf[start:], buf[p+1:]) | ||
188 | buf = buf[:len(buf)-(p+1-start)] | ||
189 | } | ||
190 | |||
191 | // Add panic heading. | ||
192 | head := fmt.Sprintf("panic: %v\n\n", x) | ||
193 | if len(head) > len(buf) { | ||
194 | // Extremely unlikely to happen. | ||
195 | return head | ||
196 | } | ||
197 | copy(buf[len(head):], buf) | ||
198 | copy(buf, head) | ||
199 | |||
200 | return string(buf) | ||
201 | } | ||
202 | |||
203 | // context represents the context of an in-flight HTTP request. | ||
204 | // It implements the appengine.Context and http.ResponseWriter interfaces. | ||
205 | type context struct { | ||
206 | req *http.Request | ||
207 | |||
208 | outCode int | ||
209 | outHeader http.Header | ||
210 | outBody []byte | ||
211 | |||
212 | pendingLogs struct { | ||
213 | sync.Mutex | ||
214 | lines []*logpb.UserAppLogLine | ||
215 | flushes int | ||
216 | } | ||
217 | |||
218 | apiURL *url.URL | ||
219 | } | ||
220 | |||
221 | var contextKey = "holds a *context" | ||
222 | |||
223 | // jointContext joins two contexts in a superficial way. | ||
224 | // It takes values and timeouts from a base context, and only values from another context. | ||
225 | type jointContext struct { | ||
226 | base netcontext.Context | ||
227 | valuesOnly netcontext.Context | ||
228 | } | ||
229 | |||
230 | func (c jointContext) Deadline() (time.Time, bool) { | ||
231 | return c.base.Deadline() | ||
232 | } | ||
233 | |||
234 | func (c jointContext) Done() <-chan struct{} { | ||
235 | return c.base.Done() | ||
236 | } | ||
237 | |||
238 | func (c jointContext) Err() error { | ||
239 | return c.base.Err() | ||
240 | } | ||
241 | |||
242 | func (c jointContext) Value(key interface{}) interface{} { | ||
243 | if val := c.base.Value(key); val != nil { | ||
244 | return val | ||
245 | } | ||
246 | return c.valuesOnly.Value(key) | ||
247 | } | ||
248 | |||
249 | // fromContext returns the App Engine context or nil if ctx is not | ||
250 | // derived from an App Engine context. | ||
251 | func fromContext(ctx netcontext.Context) *context { | ||
252 | c, _ := ctx.Value(&contextKey).(*context) | ||
253 | return c | ||
254 | } | ||
255 | |||
256 | func withContext(parent netcontext.Context, c *context) netcontext.Context { | ||
257 | ctx := netcontext.WithValue(parent, &contextKey, c) | ||
258 | if ns := c.req.Header.Get(curNamespaceHeader); ns != "" { | ||
259 | ctx = withNamespace(ctx, ns) | ||
260 | } | ||
261 | return ctx | ||
262 | } | ||
263 | |||
264 | func toContext(c *context) netcontext.Context { | ||
265 | return withContext(netcontext.Background(), c) | ||
266 | } | ||
267 | |||
268 | func IncomingHeaders(ctx netcontext.Context) http.Header { | ||
269 | if c := fromContext(ctx); c != nil { | ||
270 | return c.req.Header | ||
271 | } | ||
272 | return nil | ||
273 | } | ||
274 | |||
275 | func ReqContext(req *http.Request) netcontext.Context { | ||
276 | return req.Context() | ||
277 | } | ||
278 | |||
279 | func WithContext(parent netcontext.Context, req *http.Request) netcontext.Context { | ||
280 | return jointContext{ | ||
281 | base: parent, | ||
282 | valuesOnly: req.Context(), | ||
283 | } | ||
284 | } | ||
285 | |||
286 | // DefaultTicket returns a ticket used for background context or dev_appserver. | ||
287 | func DefaultTicket() string { | ||
288 | defaultTicketOnce.Do(func() { | ||
289 | if IsDevAppServer() { | ||
290 | defaultTicket = "testapp" + defaultTicketSuffix | ||
291 | return | ||
292 | } | ||
293 | appID := partitionlessAppID() | ||
294 | escAppID := strings.Replace(strings.Replace(appID, ":", "_", -1), ".", "_", -1) | ||
295 | majVersion := VersionID(nil) | ||
296 | if i := strings.Index(majVersion, "."); i > 0 { | ||
297 | majVersion = majVersion[:i] | ||
298 | } | ||
299 | defaultTicket = fmt.Sprintf("%s/%s.%s.%s", escAppID, ModuleName(nil), majVersion, InstanceID()) | ||
300 | }) | ||
301 | return defaultTicket | ||
302 | } | ||
303 | |||
304 | func BackgroundContext() netcontext.Context { | ||
305 | backgroundContextOnce.Do(func() { | ||
306 | // Compute background security ticket. | ||
307 | ticket := DefaultTicket() | ||
308 | |||
309 | c := &context{ | ||
310 | req: &http.Request{ | ||
311 | Header: http.Header{ | ||
312 | ticketHeader: []string{ticket}, | ||
313 | }, | ||
314 | }, | ||
315 | apiURL: apiURL(), | ||
316 | } | ||
317 | backgroundContext = toContext(c) | ||
318 | |||
319 | // TODO(dsymonds): Wire up the shutdown handler to do a final flush. | ||
320 | go c.logFlusher(make(chan int)) | ||
321 | }) | ||
322 | |||
323 | return backgroundContext | ||
324 | } | ||
325 | |||
326 | // RegisterTestRequest registers the HTTP request req for testing, such that | ||
327 | // any API calls are sent to the provided URL. It returns a closure to delete | ||
328 | // the registration. | ||
329 | // It should only be used by aetest package. | ||
330 | func RegisterTestRequest(req *http.Request, apiURL *url.URL, decorate func(netcontext.Context) netcontext.Context) (*http.Request, func()) { | ||
331 | c := &context{ | ||
332 | req: req, | ||
333 | apiURL: apiURL, | ||
334 | } | ||
335 | ctx := withContext(decorate(req.Context()), c) | ||
336 | req = req.WithContext(ctx) | ||
337 | c.req = req | ||
338 | return req, func() {} | ||
339 | } | ||
340 | |||
341 | var errTimeout = &CallError{ | ||
342 | Detail: "Deadline exceeded", | ||
343 | Code: int32(remotepb.RpcError_CANCELLED), | ||
344 | Timeout: true, | ||
345 | } | ||
346 | |||
347 | func (c *context) Header() http.Header { return c.outHeader } | ||
348 | |||
349 | // Copied from $GOROOT/src/pkg/net/http/transfer.go. Some response status | ||
350 | // codes do not permit a response body (nor response entity headers such as | ||
351 | // Content-Length, Content-Type, etc). | ||
352 | func bodyAllowedForStatus(status int) bool { | ||
353 | switch { | ||
354 | case status >= 100 && status <= 199: | ||
355 | return false | ||
356 | case status == 204: | ||
357 | return false | ||
358 | case status == 304: | ||
359 | return false | ||
360 | } | ||
361 | return true | ||
362 | } | ||
363 | |||
364 | func (c *context) Write(b []byte) (int, error) { | ||
365 | if c.outCode == 0 { | ||
366 | c.WriteHeader(http.StatusOK) | ||
367 | } | ||
368 | if len(b) > 0 && !bodyAllowedForStatus(c.outCode) { | ||
369 | return 0, http.ErrBodyNotAllowed | ||
370 | } | ||
371 | c.outBody = append(c.outBody, b...) | ||
372 | return len(b), nil | ||
373 | } | ||
374 | |||
375 | func (c *context) WriteHeader(code int) { | ||
376 | if c.outCode != 0 { | ||
377 | logf(c, 3, "WriteHeader called multiple times on request.") // error level | ||
378 | return | ||
379 | } | ||
380 | c.outCode = code | ||
381 | } | ||
382 | |||
383 | func (c *context) post(body []byte, timeout time.Duration) (b []byte, err error) { | ||
384 | hreq := &http.Request{ | ||
385 | Method: "POST", | ||
386 | URL: c.apiURL, | ||
387 | Header: http.Header{ | ||
388 | apiEndpointHeader: apiEndpointHeaderValue, | ||
389 | apiMethodHeader: apiMethodHeaderValue, | ||
390 | apiContentType: apiContentTypeValue, | ||
391 | apiDeadlineHeader: []string{strconv.FormatFloat(timeout.Seconds(), 'f', -1, 64)}, | ||
392 | }, | ||
393 | Body: ioutil.NopCloser(bytes.NewReader(body)), | ||
394 | ContentLength: int64(len(body)), | ||
395 | Host: c.apiURL.Host, | ||
396 | } | ||
397 | if info := c.req.Header.Get(dapperHeader); info != "" { | ||
398 | hreq.Header.Set(dapperHeader, info) | ||
399 | } | ||
400 | if info := c.req.Header.Get(traceHeader); info != "" { | ||
401 | hreq.Header.Set(traceHeader, info) | ||
402 | } | ||
403 | |||
404 | tr := apiHTTPClient.Transport.(*http.Transport) | ||
405 | |||
406 | var timedOut int32 // atomic; set to 1 if timed out | ||
407 | t := time.AfterFunc(timeout, func() { | ||
408 | atomic.StoreInt32(&timedOut, 1) | ||
409 | tr.CancelRequest(hreq) | ||
410 | }) | ||
411 | defer t.Stop() | ||
412 | defer func() { | ||
413 | // Check if timeout was exceeded. | ||
414 | if atomic.LoadInt32(&timedOut) != 0 { | ||
415 | err = errTimeout | ||
416 | } | ||
417 | }() | ||
418 | |||
419 | hresp, err := apiHTTPClient.Do(hreq) | ||
420 | if err != nil { | ||
421 | return nil, &CallError{ | ||
422 | Detail: fmt.Sprintf("service bridge HTTP failed: %v", err), | ||
423 | Code: int32(remotepb.RpcError_UNKNOWN), | ||
424 | } | ||
425 | } | ||
426 | defer hresp.Body.Close() | ||
427 | hrespBody, err := ioutil.ReadAll(hresp.Body) | ||
428 | if hresp.StatusCode != 200 { | ||
429 | return nil, &CallError{ | ||
430 | Detail: fmt.Sprintf("service bridge returned HTTP %d (%q)", hresp.StatusCode, hrespBody), | ||
431 | Code: int32(remotepb.RpcError_UNKNOWN), | ||
432 | } | ||
433 | } | ||
434 | if err != nil { | ||
435 | return nil, &CallError{ | ||
436 | Detail: fmt.Sprintf("service bridge response bad: %v", err), | ||
437 | Code: int32(remotepb.RpcError_UNKNOWN), | ||
438 | } | ||
439 | } | ||
440 | return hrespBody, nil | ||
441 | } | ||
442 | |||
443 | func Call(ctx netcontext.Context, service, method string, in, out proto.Message) error { | ||
444 | if ns := NamespaceFromContext(ctx); ns != "" { | ||
445 | if fn, ok := NamespaceMods[service]; ok { | ||
446 | fn(in, ns) | ||
447 | } | ||
448 | } | ||
449 | |||
450 | if f, ctx, ok := callOverrideFromContext(ctx); ok { | ||
451 | return f(ctx, service, method, in, out) | ||
452 | } | ||
453 | |||
454 | // Handle already-done contexts quickly. | ||
455 | select { | ||
456 | case <-ctx.Done(): | ||
457 | return ctx.Err() | ||
458 | default: | ||
459 | } | ||
460 | |||
461 | c := fromContext(ctx) | ||
462 | if c == nil { | ||
463 | // Give a good error message rather than a panic lower down. | ||
464 | return errNotAppEngineContext | ||
465 | } | ||
466 | |||
467 | // Apply transaction modifications if we're in a transaction. | ||
468 | if t := transactionFromContext(ctx); t != nil { | ||
469 | if t.finished { | ||
470 | return errors.New("transaction context has expired") | ||
471 | } | ||
472 | applyTransaction(in, &t.transaction) | ||
473 | } | ||
474 | |||
475 | // Default RPC timeout is 60s. | ||
476 | timeout := 60 * time.Second | ||
477 | if deadline, ok := ctx.Deadline(); ok { | ||
478 | timeout = deadline.Sub(time.Now()) | ||
479 | } | ||
480 | |||
481 | data, err := proto.Marshal(in) | ||
482 | if err != nil { | ||
483 | return err | ||
484 | } | ||
485 | |||
486 | ticket := c.req.Header.Get(ticketHeader) | ||
487 | // Use a test ticket under test environment. | ||
488 | if ticket == "" { | ||
489 | if appid := ctx.Value(&appIDOverrideKey); appid != nil { | ||
490 | ticket = appid.(string) + defaultTicketSuffix | ||
491 | } | ||
492 | } | ||
493 | // Fall back to use background ticket when the request ticket is not available in Flex or dev_appserver. | ||
494 | if ticket == "" { | ||
495 | ticket = DefaultTicket() | ||
496 | } | ||
497 | req := &remotepb.Request{ | ||
498 | ServiceName: &service, | ||
499 | Method: &method, | ||
500 | Request: data, | ||
501 | RequestId: &ticket, | ||
502 | } | ||
503 | hreqBody, err := proto.Marshal(req) | ||
504 | if err != nil { | ||
505 | return err | ||
506 | } | ||
507 | |||
508 | hrespBody, err := c.post(hreqBody, timeout) | ||
509 | if err != nil { | ||
510 | return err | ||
511 | } | ||
512 | |||
513 | res := &remotepb.Response{} | ||
514 | if err := proto.Unmarshal(hrespBody, res); err != nil { | ||
515 | return err | ||
516 | } | ||
517 | if res.RpcError != nil { | ||
518 | ce := &CallError{ | ||
519 | Detail: res.RpcError.GetDetail(), | ||
520 | Code: *res.RpcError.Code, | ||
521 | } | ||
522 | switch remotepb.RpcError_ErrorCode(ce.Code) { | ||
523 | case remotepb.RpcError_CANCELLED, remotepb.RpcError_DEADLINE_EXCEEDED: | ||
524 | ce.Timeout = true | ||
525 | } | ||
526 | return ce | ||
527 | } | ||
528 | if res.ApplicationError != nil { | ||
529 | return &APIError{ | ||
530 | Service: *req.ServiceName, | ||
531 | Detail: res.ApplicationError.GetDetail(), | ||
532 | Code: *res.ApplicationError.Code, | ||
533 | } | ||
534 | } | ||
535 | if res.Exception != nil || res.JavaException != nil { | ||
536 | // This shouldn't happen, but let's be defensive. | ||
537 | return &CallError{ | ||
538 | Detail: "service bridge returned exception", | ||
539 | Code: int32(remotepb.RpcError_UNKNOWN), | ||
540 | } | ||
541 | } | ||
542 | return proto.Unmarshal(res.Response, out) | ||
543 | } | ||
544 | |||
545 | func (c *context) Request() *http.Request { | ||
546 | return c.req | ||
547 | } | ||
548 | |||
549 | func (c *context) addLogLine(ll *logpb.UserAppLogLine) { | ||
550 | // Truncate long log lines. | ||
551 | // TODO(dsymonds): Check if this is still necessary. | ||
552 | const lim = 8 << 10 | ||
553 | if len(*ll.Message) > lim { | ||
554 | suffix := fmt.Sprintf("...(length %d)", len(*ll.Message)) | ||
555 | ll.Message = proto.String((*ll.Message)[:lim-len(suffix)] + suffix) | ||
556 | } | ||
557 | |||
558 | c.pendingLogs.Lock() | ||
559 | c.pendingLogs.lines = append(c.pendingLogs.lines, ll) | ||
560 | c.pendingLogs.Unlock() | ||
561 | } | ||
562 | |||
563 | var logLevelName = map[int64]string{ | ||
564 | 0: "DEBUG", | ||
565 | 1: "INFO", | ||
566 | 2: "WARNING", | ||
567 | 3: "ERROR", | ||
568 | 4: "CRITICAL", | ||
569 | } | ||
570 | |||
571 | func logf(c *context, level int64, format string, args ...interface{}) { | ||
572 | if c == nil { | ||
573 | panic("not an App Engine context") | ||
574 | } | ||
575 | s := fmt.Sprintf(format, args...) | ||
576 | s = strings.TrimRight(s, "\n") // Remove any trailing newline characters. | ||
577 | c.addLogLine(&logpb.UserAppLogLine{ | ||
578 | TimestampUsec: proto.Int64(time.Now().UnixNano() / 1e3), | ||
579 | Level: &level, | ||
580 | Message: &s, | ||
581 | }) | ||
582 | // Only duplicate log to stderr if not running on App Engine second generation | ||
583 | if !IsSecondGen() { | ||
584 | log.Print(logLevelName[level] + ": " + s) | ||
585 | } | ||
586 | } | ||
587 | |||
588 | // flushLog attempts to flush any pending logs to the appserver. | ||
589 | // It should not be called concurrently. | ||
590 | func (c *context) flushLog(force bool) (flushed bool) { | ||
591 | c.pendingLogs.Lock() | ||
592 | // Grab up to 30 MB. We can get away with up to 32 MB, but let's be cautious. | ||
593 | n, rem := 0, 30<<20 | ||
594 | for ; n < len(c.pendingLogs.lines); n++ { | ||
595 | ll := c.pendingLogs.lines[n] | ||
596 | // Each log line will require about 3 bytes of overhead. | ||
597 | nb := proto.Size(ll) + 3 | ||
598 | if nb > rem { | ||
599 | break | ||
600 | } | ||
601 | rem -= nb | ||
602 | } | ||
603 | lines := c.pendingLogs.lines[:n] | ||
604 | c.pendingLogs.lines = c.pendingLogs.lines[n:] | ||
605 | c.pendingLogs.Unlock() | ||
606 | |||
607 | if len(lines) == 0 && !force { | ||
608 | // Nothing to flush. | ||
609 | return false | ||
610 | } | ||
611 | |||
612 | rescueLogs := false | ||
613 | defer func() { | ||
614 | if rescueLogs { | ||
615 | c.pendingLogs.Lock() | ||
616 | c.pendingLogs.lines = append(lines, c.pendingLogs.lines...) | ||
617 | c.pendingLogs.Unlock() | ||
618 | } | ||
619 | }() | ||
620 | |||
621 | buf, err := proto.Marshal(&logpb.UserAppLogGroup{ | ||
622 | LogLine: lines, | ||
623 | }) | ||
624 | if err != nil { | ||
625 | log.Printf("internal.flushLog: marshaling UserAppLogGroup: %v", err) | ||
626 | rescueLogs = true | ||
627 | return false | ||
628 | } | ||
629 | |||
630 | req := &logpb.FlushRequest{ | ||
631 | Logs: buf, | ||
632 | } | ||
633 | res := &basepb.VoidProto{} | ||
634 | c.pendingLogs.Lock() | ||
635 | c.pendingLogs.flushes++ | ||
636 | c.pendingLogs.Unlock() | ||
637 | if err := Call(toContext(c), "logservice", "Flush", req, res); err != nil { | ||
638 | log.Printf("internal.flushLog: Flush RPC: %v", err) | ||
639 | rescueLogs = true | ||
640 | return false | ||
641 | } | ||
642 | return true | ||
643 | } | ||
644 | |||
645 | const ( | ||
646 | // Log flushing parameters. | ||
647 | flushInterval = 1 * time.Second | ||
648 | forceFlushInterval = 60 * time.Second | ||
649 | ) | ||
650 | |||
651 | func (c *context) logFlusher(stop <-chan int) { | ||
652 | lastFlush := time.Now() | ||
653 | tick := time.NewTicker(flushInterval) | ||
654 | for { | ||
655 | select { | ||
656 | case <-stop: | ||
657 | // Request finished. | ||
658 | tick.Stop() | ||
659 | return | ||
660 | case <-tick.C: | ||
661 | force := time.Now().Sub(lastFlush) > forceFlushInterval | ||
662 | if c.flushLog(force) { | ||
663 | lastFlush = time.Now() | ||
664 | } | ||
665 | } | ||
666 | } | ||
667 | } | ||
668 | |||
669 | func ContextForTesting(req *http.Request) netcontext.Context { | ||
670 | return toContext(&context{req: req}) | ||
671 | } | ||
diff --git a/vendor/google.golang.org/appengine/internal/api_classic.go b/vendor/google.golang.org/appengine/internal/api_classic.go new file mode 100644 index 0000000..f0f40b2 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/api_classic.go | |||
@@ -0,0 +1,169 @@ | |||
1 | // Copyright 2015 Google Inc. All rights reserved. | ||
2 | // Use of this source code is governed by the Apache 2.0 | ||
3 | // license that can be found in the LICENSE file. | ||
4 | |||
5 | // +build appengine | ||
6 | |||
7 | package internal | ||
8 | |||
9 | import ( | ||
10 | "errors" | ||
11 | "fmt" | ||
12 | "net/http" | ||
13 | "time" | ||
14 | |||
15 | "appengine" | ||
16 | "appengine_internal" | ||
17 | basepb "appengine_internal/base" | ||
18 | |||
19 | "github.com/golang/protobuf/proto" | ||
20 | netcontext "golang.org/x/net/context" | ||
21 | ) | ||
22 | |||
23 | var contextKey = "holds an appengine.Context" | ||
24 | |||
25 | // fromContext returns the App Engine context or nil if ctx is not | ||
26 | // derived from an App Engine context. | ||
27 | func fromContext(ctx netcontext.Context) appengine.Context { | ||
28 | c, _ := ctx.Value(&contextKey).(appengine.Context) | ||
29 | return c | ||
30 | } | ||
31 | |||
32 | // This is only for classic App Engine adapters. | ||
33 | func ClassicContextFromContext(ctx netcontext.Context) (appengine.Context, error) { | ||
34 | c := fromContext(ctx) | ||
35 | if c == nil { | ||
36 | return nil, errNotAppEngineContext | ||
37 | } | ||
38 | return c, nil | ||
39 | } | ||
40 | |||
41 | func withContext(parent netcontext.Context, c appengine.Context) netcontext.Context { | ||
42 | ctx := netcontext.WithValue(parent, &contextKey, c) | ||
43 | |||
44 | s := &basepb.StringProto{} | ||
45 | c.Call("__go__", "GetNamespace", &basepb.VoidProto{}, s, nil) | ||
46 | if ns := s.GetValue(); ns != "" { | ||
47 | ctx = NamespacedContext(ctx, ns) | ||
48 | } | ||
49 | |||
50 | return ctx | ||
51 | } | ||
52 | |||
53 | func IncomingHeaders(ctx netcontext.Context) http.Header { | ||
54 | if c := fromContext(ctx); c != nil { | ||
55 | if req, ok := c.Request().(*http.Request); ok { | ||
56 | return req.Header | ||
57 | } | ||
58 | } | ||
59 | return nil | ||
60 | } | ||
61 | |||
62 | func ReqContext(req *http.Request) netcontext.Context { | ||
63 | return WithContext(netcontext.Background(), req) | ||
64 | } | ||
65 | |||
66 | func WithContext(parent netcontext.Context, req *http.Request) netcontext.Context { | ||
67 | c := appengine.NewContext(req) | ||
68 | return withContext(parent, c) | ||
69 | } | ||
70 | |||
71 | type testingContext struct { | ||
72 | appengine.Context | ||
73 | |||
74 | req *http.Request | ||
75 | } | ||
76 | |||
77 | func (t *testingContext) FullyQualifiedAppID() string { return "dev~testcontext" } | ||
78 | func (t *testingContext) Call(service, method string, _, _ appengine_internal.ProtoMessage, _ *appengine_internal.CallOptions) error { | ||
79 | if service == "__go__" && method == "GetNamespace" { | ||
80 | return nil | ||
81 | } | ||
82 | return fmt.Errorf("testingContext: unsupported Call") | ||
83 | } | ||
84 | func (t *testingContext) Request() interface{} { return t.req } | ||
85 | |||
86 | func ContextForTesting(req *http.Request) netcontext.Context { | ||
87 | return withContext(netcontext.Background(), &testingContext{req: req}) | ||
88 | } | ||
89 | |||
90 | func Call(ctx netcontext.Context, service, method string, in, out proto.Message) error { | ||
91 | if ns := NamespaceFromContext(ctx); ns != "" { | ||
92 | if fn, ok := NamespaceMods[service]; ok { | ||
93 | fn(in, ns) | ||
94 | } | ||
95 | } | ||
96 | |||
97 | if f, ctx, ok := callOverrideFromContext(ctx); ok { | ||
98 | return f(ctx, service, method, in, out) | ||
99 | } | ||
100 | |||
101 | // Handle already-done contexts quickly. | ||
102 | select { | ||
103 | case <-ctx.Done(): | ||
104 | return ctx.Err() | ||
105 | default: | ||
106 | } | ||
107 | |||
108 | c := fromContext(ctx) | ||
109 | if c == nil { | ||
110 | // Give a good error message rather than a panic lower down. | ||
111 | return errNotAppEngineContext | ||
112 | } | ||
113 | |||
114 | // Apply transaction modifications if we're in a transaction. | ||
115 | if t := transactionFromContext(ctx); t != nil { | ||
116 | if t.finished { | ||
117 | return errors.New("transaction context has expired") | ||
118 | } | ||
119 | applyTransaction(in, &t.transaction) | ||
120 | } | ||
121 | |||
122 | var opts *appengine_internal.CallOptions | ||
123 | if d, ok := ctx.Deadline(); ok { | ||
124 | opts = &appengine_internal.CallOptions{ | ||
125 | Timeout: d.Sub(time.Now()), | ||
126 | } | ||
127 | } | ||
128 | |||
129 | err := c.Call(service, method, in, out, opts) | ||
130 | switch v := err.(type) { | ||
131 | case *appengine_internal.APIError: | ||
132 | return &APIError{ | ||
133 | Service: v.Service, | ||
134 | Detail: v.Detail, | ||
135 | Code: v.Code, | ||
136 | } | ||
137 | case *appengine_internal.CallError: | ||
138 | return &CallError{ | ||
139 | Detail: v.Detail, | ||
140 | Code: v.Code, | ||
141 | Timeout: v.Timeout, | ||
142 | } | ||
143 | } | ||
144 | return err | ||
145 | } | ||
146 | |||
147 | func handleHTTP(w http.ResponseWriter, r *http.Request) { | ||
148 | panic("handleHTTP called; this should be impossible") | ||
149 | } | ||
150 | |||
151 | func logf(c appengine.Context, level int64, format string, args ...interface{}) { | ||
152 | var fn func(format string, args ...interface{}) | ||
153 | switch level { | ||
154 | case 0: | ||
155 | fn = c.Debugf | ||
156 | case 1: | ||
157 | fn = c.Infof | ||
158 | case 2: | ||
159 | fn = c.Warningf | ||
160 | case 3: | ||
161 | fn = c.Errorf | ||
162 | case 4: | ||
163 | fn = c.Criticalf | ||
164 | default: | ||
165 | // This shouldn't happen. | ||
166 | fn = c.Criticalf | ||
167 | } | ||
168 | fn(format, args...) | ||
169 | } | ||
diff --git a/vendor/google.golang.org/appengine/internal/api_common.go b/vendor/google.golang.org/appengine/internal/api_common.go new file mode 100644 index 0000000..e0c0b21 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/api_common.go | |||
@@ -0,0 +1,123 @@ | |||
1 | // Copyright 2015 Google Inc. All rights reserved. | ||
2 | // Use of this source code is governed by the Apache 2.0 | ||
3 | // license that can be found in the LICENSE file. | ||
4 | |||
5 | package internal | ||
6 | |||
7 | import ( | ||
8 | "errors" | ||
9 | "os" | ||
10 | |||
11 | "github.com/golang/protobuf/proto" | ||
12 | netcontext "golang.org/x/net/context" | ||
13 | ) | ||
14 | |||
15 | var errNotAppEngineContext = errors.New("not an App Engine context") | ||
16 | |||
17 | type CallOverrideFunc func(ctx netcontext.Context, service, method string, in, out proto.Message) error | ||
18 | |||
19 | var callOverrideKey = "holds []CallOverrideFunc" | ||
20 | |||
21 | func WithCallOverride(ctx netcontext.Context, f CallOverrideFunc) netcontext.Context { | ||
22 | // We avoid appending to any existing call override | ||
23 | // so we don't risk overwriting a popped stack below. | ||
24 | var cofs []CallOverrideFunc | ||
25 | if uf, ok := ctx.Value(&callOverrideKey).([]CallOverrideFunc); ok { | ||
26 | cofs = append(cofs, uf...) | ||
27 | } | ||
28 | cofs = append(cofs, f) | ||
29 | return netcontext.WithValue(ctx, &callOverrideKey, cofs) | ||
30 | } | ||
31 | |||
32 | func callOverrideFromContext(ctx netcontext.Context) (CallOverrideFunc, netcontext.Context, bool) { | ||
33 | cofs, _ := ctx.Value(&callOverrideKey).([]CallOverrideFunc) | ||
34 | if len(cofs) == 0 { | ||
35 | return nil, nil, false | ||
36 | } | ||
37 | // We found a list of overrides; grab the last, and reconstitute a | ||
38 | // context that will hide it. | ||
39 | f := cofs[len(cofs)-1] | ||
40 | ctx = netcontext.WithValue(ctx, &callOverrideKey, cofs[:len(cofs)-1]) | ||
41 | return f, ctx, true | ||
42 | } | ||
43 | |||
44 | type logOverrideFunc func(level int64, format string, args ...interface{}) | ||
45 | |||
46 | var logOverrideKey = "holds a logOverrideFunc" | ||
47 | |||
48 | func WithLogOverride(ctx netcontext.Context, f logOverrideFunc) netcontext.Context { | ||
49 | return netcontext.WithValue(ctx, &logOverrideKey, f) | ||
50 | } | ||
51 | |||
52 | var appIDOverrideKey = "holds a string, being the full app ID" | ||
53 | |||
54 | func WithAppIDOverride(ctx netcontext.Context, appID string) netcontext.Context { | ||
55 | return netcontext.WithValue(ctx, &appIDOverrideKey, appID) | ||
56 | } | ||
57 | |||
58 | var namespaceKey = "holds the namespace string" | ||
59 | |||
60 | func withNamespace(ctx netcontext.Context, ns string) netcontext.Context { | ||
61 | return netcontext.WithValue(ctx, &namespaceKey, ns) | ||
62 | } | ||
63 | |||
64 | func NamespaceFromContext(ctx netcontext.Context) string { | ||
65 | // If there's no namespace, return the empty string. | ||
66 | ns, _ := ctx.Value(&namespaceKey).(string) | ||
67 | return ns | ||
68 | } | ||
69 | |||
70 | // FullyQualifiedAppID returns the fully-qualified application ID. | ||
71 | // This may contain a partition prefix (e.g. "s~" for High Replication apps), | ||
72 | // or a domain prefix (e.g. "example.com:"). | ||
73 | func FullyQualifiedAppID(ctx netcontext.Context) string { | ||
74 | if id, ok := ctx.Value(&appIDOverrideKey).(string); ok { | ||
75 | return id | ||
76 | } | ||
77 | return fullyQualifiedAppID(ctx) | ||
78 | } | ||
79 | |||
80 | func Logf(ctx netcontext.Context, level int64, format string, args ...interface{}) { | ||
81 | if f, ok := ctx.Value(&logOverrideKey).(logOverrideFunc); ok { | ||
82 | f(level, format, args...) | ||
83 | return | ||
84 | } | ||
85 | c := fromContext(ctx) | ||
86 | if c == nil { | ||
87 | panic(errNotAppEngineContext) | ||
88 | } | ||
89 | logf(c, level, format, args...) | ||
90 | } | ||
91 | |||
92 | // NamespacedContext wraps a Context to support namespaces. | ||
93 | func NamespacedContext(ctx netcontext.Context, namespace string) netcontext.Context { | ||
94 | return withNamespace(ctx, namespace) | ||
95 | } | ||
96 | |||
97 | // SetTestEnv sets the env variables for testing background ticket in Flex. | ||
98 | func SetTestEnv() func() { | ||
99 | var environ = []struct { | ||
100 | key, value string | ||
101 | }{ | ||
102 | {"GAE_LONG_APP_ID", "my-app-id"}, | ||
103 | {"GAE_MINOR_VERSION", "067924799508853122"}, | ||
104 | {"GAE_MODULE_INSTANCE", "0"}, | ||
105 | {"GAE_MODULE_NAME", "default"}, | ||
106 | {"GAE_MODULE_VERSION", "20150612t184001"}, | ||
107 | } | ||
108 | |||
109 | for _, v := range environ { | ||
110 | old := os.Getenv(v.key) | ||
111 | os.Setenv(v.key, v.value) | ||
112 | v.value = old | ||
113 | } | ||
114 | return func() { // Restore old environment after the test completes. | ||
115 | for _, v := range environ { | ||
116 | if v.value == "" { | ||
117 | os.Unsetenv(v.key) | ||
118 | continue | ||
119 | } | ||
120 | os.Setenv(v.key, v.value) | ||
121 | } | ||
122 | } | ||
123 | } | ||
diff --git a/vendor/google.golang.org/appengine/internal/app_id.go b/vendor/google.golang.org/appengine/internal/app_id.go new file mode 100644 index 0000000..11df8c0 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/app_id.go | |||
@@ -0,0 +1,28 @@ | |||
1 | // Copyright 2011 Google Inc. All rights reserved. | ||
2 | // Use of this source code is governed by the Apache 2.0 | ||
3 | // license that can be found in the LICENSE file. | ||
4 | |||
5 | package internal | ||
6 | |||
7 | import ( | ||
8 | "strings" | ||
9 | ) | ||
10 | |||
11 | func parseFullAppID(appid string) (partition, domain, displayID string) { | ||
12 | if i := strings.Index(appid, "~"); i != -1 { | ||
13 | partition, appid = appid[:i], appid[i+1:] | ||
14 | } | ||
15 | if i := strings.Index(appid, ":"); i != -1 { | ||
16 | domain, appid = appid[:i], appid[i+1:] | ||
17 | } | ||
18 | return partition, domain, appid | ||
19 | } | ||
20 | |||
21 | // appID returns "appid" or "domain.com:appid". | ||
22 | func appID(fullAppID string) string { | ||
23 | _, dom, dis := parseFullAppID(fullAppID) | ||
24 | if dom != "" { | ||
25 | return dom + ":" + dis | ||
26 | } | ||
27 | return dis | ||
28 | } | ||
diff --git a/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.pb.go b/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.pb.go new file mode 100644 index 0000000..9a2ff77 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.pb.go | |||
@@ -0,0 +1,611 @@ | |||
1 | // Code generated by protoc-gen-go. DO NOT EDIT. | ||
2 | // source: google.golang.org/appengine/internal/app_identity/app_identity_service.proto | ||
3 | |||
4 | package app_identity | ||
5 | |||
6 | import proto "github.com/golang/protobuf/proto" | ||
7 | import fmt "fmt" | ||
8 | import math "math" | ||
9 | |||
10 | // Reference imports to suppress errors if they are not otherwise used. | ||
11 | var _ = proto.Marshal | ||
12 | var _ = fmt.Errorf | ||
13 | var _ = math.Inf | ||
14 | |||
15 | // This is a compile-time assertion to ensure that this generated file | ||
16 | // is compatible with the proto package it is being compiled against. | ||
17 | // A compilation error at this line likely means your copy of the | ||
18 | // proto package needs to be updated. | ||
19 | const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package | ||
20 | |||
21 | type AppIdentityServiceError_ErrorCode int32 | ||
22 | |||
23 | const ( | ||
24 | AppIdentityServiceError_SUCCESS AppIdentityServiceError_ErrorCode = 0 | ||
25 | AppIdentityServiceError_UNKNOWN_SCOPE AppIdentityServiceError_ErrorCode = 9 | ||
26 | AppIdentityServiceError_BLOB_TOO_LARGE AppIdentityServiceError_ErrorCode = 1000 | ||
27 | AppIdentityServiceError_DEADLINE_EXCEEDED AppIdentityServiceError_ErrorCode = 1001 | ||
28 | AppIdentityServiceError_NOT_A_VALID_APP AppIdentityServiceError_ErrorCode = 1002 | ||
29 | AppIdentityServiceError_UNKNOWN_ERROR AppIdentityServiceError_ErrorCode = 1003 | ||
30 | AppIdentityServiceError_NOT_ALLOWED AppIdentityServiceError_ErrorCode = 1005 | ||
31 | AppIdentityServiceError_NOT_IMPLEMENTED AppIdentityServiceError_ErrorCode = 1006 | ||
32 | ) | ||
33 | |||
34 | var AppIdentityServiceError_ErrorCode_name = map[int32]string{ | ||
35 | 0: "SUCCESS", | ||
36 | 9: "UNKNOWN_SCOPE", | ||
37 | 1000: "BLOB_TOO_LARGE", | ||
38 | 1001: "DEADLINE_EXCEEDED", | ||
39 | 1002: "NOT_A_VALID_APP", | ||
40 | 1003: "UNKNOWN_ERROR", | ||
41 | 1005: "NOT_ALLOWED", | ||
42 | 1006: "NOT_IMPLEMENTED", | ||
43 | } | ||
44 | var AppIdentityServiceError_ErrorCode_value = map[string]int32{ | ||
45 | "SUCCESS": 0, | ||
46 | "UNKNOWN_SCOPE": 9, | ||
47 | "BLOB_TOO_LARGE": 1000, | ||
48 | "DEADLINE_EXCEEDED": 1001, | ||
49 | "NOT_A_VALID_APP": 1002, | ||
50 | "UNKNOWN_ERROR": 1003, | ||
51 | "NOT_ALLOWED": 1005, | ||
52 | "NOT_IMPLEMENTED": 1006, | ||
53 | } | ||
54 | |||
55 | func (x AppIdentityServiceError_ErrorCode) Enum() *AppIdentityServiceError_ErrorCode { | ||
56 | p := new(AppIdentityServiceError_ErrorCode) | ||
57 | *p = x | ||
58 | return p | ||
59 | } | ||
60 | func (x AppIdentityServiceError_ErrorCode) String() string { | ||
61 | return proto.EnumName(AppIdentityServiceError_ErrorCode_name, int32(x)) | ||
62 | } | ||
63 | func (x *AppIdentityServiceError_ErrorCode) UnmarshalJSON(data []byte) error { | ||
64 | value, err := proto.UnmarshalJSONEnum(AppIdentityServiceError_ErrorCode_value, data, "AppIdentityServiceError_ErrorCode") | ||
65 | if err != nil { | ||
66 | return err | ||
67 | } | ||
68 | *x = AppIdentityServiceError_ErrorCode(value) | ||
69 | return nil | ||
70 | } | ||
71 | func (AppIdentityServiceError_ErrorCode) EnumDescriptor() ([]byte, []int) { | ||
72 | return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{0, 0} | ||
73 | } | ||
74 | |||
75 | type AppIdentityServiceError struct { | ||
76 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
77 | XXX_unrecognized []byte `json:"-"` | ||
78 | XXX_sizecache int32 `json:"-"` | ||
79 | } | ||
80 | |||
81 | func (m *AppIdentityServiceError) Reset() { *m = AppIdentityServiceError{} } | ||
82 | func (m *AppIdentityServiceError) String() string { return proto.CompactTextString(m) } | ||
83 | func (*AppIdentityServiceError) ProtoMessage() {} | ||
84 | func (*AppIdentityServiceError) Descriptor() ([]byte, []int) { | ||
85 | return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{0} | ||
86 | } | ||
87 | func (m *AppIdentityServiceError) XXX_Unmarshal(b []byte) error { | ||
88 | return xxx_messageInfo_AppIdentityServiceError.Unmarshal(m, b) | ||
89 | } | ||
90 | func (m *AppIdentityServiceError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
91 | return xxx_messageInfo_AppIdentityServiceError.Marshal(b, m, deterministic) | ||
92 | } | ||
93 | func (dst *AppIdentityServiceError) XXX_Merge(src proto.Message) { | ||
94 | xxx_messageInfo_AppIdentityServiceError.Merge(dst, src) | ||
95 | } | ||
96 | func (m *AppIdentityServiceError) XXX_Size() int { | ||
97 | return xxx_messageInfo_AppIdentityServiceError.Size(m) | ||
98 | } | ||
99 | func (m *AppIdentityServiceError) XXX_DiscardUnknown() { | ||
100 | xxx_messageInfo_AppIdentityServiceError.DiscardUnknown(m) | ||
101 | } | ||
102 | |||
103 | var xxx_messageInfo_AppIdentityServiceError proto.InternalMessageInfo | ||
104 | |||
105 | type SignForAppRequest struct { | ||
106 | BytesToSign []byte `protobuf:"bytes,1,opt,name=bytes_to_sign,json=bytesToSign" json:"bytes_to_sign,omitempty"` | ||
107 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
108 | XXX_unrecognized []byte `json:"-"` | ||
109 | XXX_sizecache int32 `json:"-"` | ||
110 | } | ||
111 | |||
112 | func (m *SignForAppRequest) Reset() { *m = SignForAppRequest{} } | ||
113 | func (m *SignForAppRequest) String() string { return proto.CompactTextString(m) } | ||
114 | func (*SignForAppRequest) ProtoMessage() {} | ||
115 | func (*SignForAppRequest) Descriptor() ([]byte, []int) { | ||
116 | return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{1} | ||
117 | } | ||
118 | func (m *SignForAppRequest) XXX_Unmarshal(b []byte) error { | ||
119 | return xxx_messageInfo_SignForAppRequest.Unmarshal(m, b) | ||
120 | } | ||
121 | func (m *SignForAppRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
122 | return xxx_messageInfo_SignForAppRequest.Marshal(b, m, deterministic) | ||
123 | } | ||
124 | func (dst *SignForAppRequest) XXX_Merge(src proto.Message) { | ||
125 | xxx_messageInfo_SignForAppRequest.Merge(dst, src) | ||
126 | } | ||
127 | func (m *SignForAppRequest) XXX_Size() int { | ||
128 | return xxx_messageInfo_SignForAppRequest.Size(m) | ||
129 | } | ||
130 | func (m *SignForAppRequest) XXX_DiscardUnknown() { | ||
131 | xxx_messageInfo_SignForAppRequest.DiscardUnknown(m) | ||
132 | } | ||
133 | |||
134 | var xxx_messageInfo_SignForAppRequest proto.InternalMessageInfo | ||
135 | |||
136 | func (m *SignForAppRequest) GetBytesToSign() []byte { | ||
137 | if m != nil { | ||
138 | return m.BytesToSign | ||
139 | } | ||
140 | return nil | ||
141 | } | ||
142 | |||
143 | type SignForAppResponse struct { | ||
144 | KeyName *string `protobuf:"bytes,1,opt,name=key_name,json=keyName" json:"key_name,omitempty"` | ||
145 | SignatureBytes []byte `protobuf:"bytes,2,opt,name=signature_bytes,json=signatureBytes" json:"signature_bytes,omitempty"` | ||
146 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
147 | XXX_unrecognized []byte `json:"-"` | ||
148 | XXX_sizecache int32 `json:"-"` | ||
149 | } | ||
150 | |||
151 | func (m *SignForAppResponse) Reset() { *m = SignForAppResponse{} } | ||
152 | func (m *SignForAppResponse) String() string { return proto.CompactTextString(m) } | ||
153 | func (*SignForAppResponse) ProtoMessage() {} | ||
154 | func (*SignForAppResponse) Descriptor() ([]byte, []int) { | ||
155 | return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{2} | ||
156 | } | ||
157 | func (m *SignForAppResponse) XXX_Unmarshal(b []byte) error { | ||
158 | return xxx_messageInfo_SignForAppResponse.Unmarshal(m, b) | ||
159 | } | ||
160 | func (m *SignForAppResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
161 | return xxx_messageInfo_SignForAppResponse.Marshal(b, m, deterministic) | ||
162 | } | ||
163 | func (dst *SignForAppResponse) XXX_Merge(src proto.Message) { | ||
164 | xxx_messageInfo_SignForAppResponse.Merge(dst, src) | ||
165 | } | ||
166 | func (m *SignForAppResponse) XXX_Size() int { | ||
167 | return xxx_messageInfo_SignForAppResponse.Size(m) | ||
168 | } | ||
169 | func (m *SignForAppResponse) XXX_DiscardUnknown() { | ||
170 | xxx_messageInfo_SignForAppResponse.DiscardUnknown(m) | ||
171 | } | ||
172 | |||
173 | var xxx_messageInfo_SignForAppResponse proto.InternalMessageInfo | ||
174 | |||
175 | func (m *SignForAppResponse) GetKeyName() string { | ||
176 | if m != nil && m.KeyName != nil { | ||
177 | return *m.KeyName | ||
178 | } | ||
179 | return "" | ||
180 | } | ||
181 | |||
182 | func (m *SignForAppResponse) GetSignatureBytes() []byte { | ||
183 | if m != nil { | ||
184 | return m.SignatureBytes | ||
185 | } | ||
186 | return nil | ||
187 | } | ||
188 | |||
189 | type GetPublicCertificateForAppRequest struct { | ||
190 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
191 | XXX_unrecognized []byte `json:"-"` | ||
192 | XXX_sizecache int32 `json:"-"` | ||
193 | } | ||
194 | |||
195 | func (m *GetPublicCertificateForAppRequest) Reset() { *m = GetPublicCertificateForAppRequest{} } | ||
196 | func (m *GetPublicCertificateForAppRequest) String() string { return proto.CompactTextString(m) } | ||
197 | func (*GetPublicCertificateForAppRequest) ProtoMessage() {} | ||
198 | func (*GetPublicCertificateForAppRequest) Descriptor() ([]byte, []int) { | ||
199 | return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{3} | ||
200 | } | ||
201 | func (m *GetPublicCertificateForAppRequest) XXX_Unmarshal(b []byte) error { | ||
202 | return xxx_messageInfo_GetPublicCertificateForAppRequest.Unmarshal(m, b) | ||
203 | } | ||
204 | func (m *GetPublicCertificateForAppRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
205 | return xxx_messageInfo_GetPublicCertificateForAppRequest.Marshal(b, m, deterministic) | ||
206 | } | ||
207 | func (dst *GetPublicCertificateForAppRequest) XXX_Merge(src proto.Message) { | ||
208 | xxx_messageInfo_GetPublicCertificateForAppRequest.Merge(dst, src) | ||
209 | } | ||
210 | func (m *GetPublicCertificateForAppRequest) XXX_Size() int { | ||
211 | return xxx_messageInfo_GetPublicCertificateForAppRequest.Size(m) | ||
212 | } | ||
213 | func (m *GetPublicCertificateForAppRequest) XXX_DiscardUnknown() { | ||
214 | xxx_messageInfo_GetPublicCertificateForAppRequest.DiscardUnknown(m) | ||
215 | } | ||
216 | |||
217 | var xxx_messageInfo_GetPublicCertificateForAppRequest proto.InternalMessageInfo | ||
218 | |||
219 | type PublicCertificate struct { | ||
220 | KeyName *string `protobuf:"bytes,1,opt,name=key_name,json=keyName" json:"key_name,omitempty"` | ||
221 | X509CertificatePem *string `protobuf:"bytes,2,opt,name=x509_certificate_pem,json=x509CertificatePem" json:"x509_certificate_pem,omitempty"` | ||
222 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
223 | XXX_unrecognized []byte `json:"-"` | ||
224 | XXX_sizecache int32 `json:"-"` | ||
225 | } | ||
226 | |||
227 | func (m *PublicCertificate) Reset() { *m = PublicCertificate{} } | ||
228 | func (m *PublicCertificate) String() string { return proto.CompactTextString(m) } | ||
229 | func (*PublicCertificate) ProtoMessage() {} | ||
230 | func (*PublicCertificate) Descriptor() ([]byte, []int) { | ||
231 | return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{4} | ||
232 | } | ||
233 | func (m *PublicCertificate) XXX_Unmarshal(b []byte) error { | ||
234 | return xxx_messageInfo_PublicCertificate.Unmarshal(m, b) | ||
235 | } | ||
236 | func (m *PublicCertificate) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
237 | return xxx_messageInfo_PublicCertificate.Marshal(b, m, deterministic) | ||
238 | } | ||
239 | func (dst *PublicCertificate) XXX_Merge(src proto.Message) { | ||
240 | xxx_messageInfo_PublicCertificate.Merge(dst, src) | ||
241 | } | ||
242 | func (m *PublicCertificate) XXX_Size() int { | ||
243 | return xxx_messageInfo_PublicCertificate.Size(m) | ||
244 | } | ||
245 | func (m *PublicCertificate) XXX_DiscardUnknown() { | ||
246 | xxx_messageInfo_PublicCertificate.DiscardUnknown(m) | ||
247 | } | ||
248 | |||
249 | var xxx_messageInfo_PublicCertificate proto.InternalMessageInfo | ||
250 | |||
251 | func (m *PublicCertificate) GetKeyName() string { | ||
252 | if m != nil && m.KeyName != nil { | ||
253 | return *m.KeyName | ||
254 | } | ||
255 | return "" | ||
256 | } | ||
257 | |||
258 | func (m *PublicCertificate) GetX509CertificatePem() string { | ||
259 | if m != nil && m.X509CertificatePem != nil { | ||
260 | return *m.X509CertificatePem | ||
261 | } | ||
262 | return "" | ||
263 | } | ||
264 | |||
265 | type GetPublicCertificateForAppResponse struct { | ||
266 | PublicCertificateList []*PublicCertificate `protobuf:"bytes,1,rep,name=public_certificate_list,json=publicCertificateList" json:"public_certificate_list,omitempty"` | ||
267 | MaxClientCacheTimeInSecond *int64 `protobuf:"varint,2,opt,name=max_client_cache_time_in_second,json=maxClientCacheTimeInSecond" json:"max_client_cache_time_in_second,omitempty"` | ||
268 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
269 | XXX_unrecognized []byte `json:"-"` | ||
270 | XXX_sizecache int32 `json:"-"` | ||
271 | } | ||
272 | |||
273 | func (m *GetPublicCertificateForAppResponse) Reset() { *m = GetPublicCertificateForAppResponse{} } | ||
274 | func (m *GetPublicCertificateForAppResponse) String() string { return proto.CompactTextString(m) } | ||
275 | func (*GetPublicCertificateForAppResponse) ProtoMessage() {} | ||
276 | func (*GetPublicCertificateForAppResponse) Descriptor() ([]byte, []int) { | ||
277 | return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{5} | ||
278 | } | ||
279 | func (m *GetPublicCertificateForAppResponse) XXX_Unmarshal(b []byte) error { | ||
280 | return xxx_messageInfo_GetPublicCertificateForAppResponse.Unmarshal(m, b) | ||
281 | } | ||
282 | func (m *GetPublicCertificateForAppResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
283 | return xxx_messageInfo_GetPublicCertificateForAppResponse.Marshal(b, m, deterministic) | ||
284 | } | ||
285 | func (dst *GetPublicCertificateForAppResponse) XXX_Merge(src proto.Message) { | ||
286 | xxx_messageInfo_GetPublicCertificateForAppResponse.Merge(dst, src) | ||
287 | } | ||
288 | func (m *GetPublicCertificateForAppResponse) XXX_Size() int { | ||
289 | return xxx_messageInfo_GetPublicCertificateForAppResponse.Size(m) | ||
290 | } | ||
291 | func (m *GetPublicCertificateForAppResponse) XXX_DiscardUnknown() { | ||
292 | xxx_messageInfo_GetPublicCertificateForAppResponse.DiscardUnknown(m) | ||
293 | } | ||
294 | |||
295 | var xxx_messageInfo_GetPublicCertificateForAppResponse proto.InternalMessageInfo | ||
296 | |||
297 | func (m *GetPublicCertificateForAppResponse) GetPublicCertificateList() []*PublicCertificate { | ||
298 | if m != nil { | ||
299 | return m.PublicCertificateList | ||
300 | } | ||
301 | return nil | ||
302 | } | ||
303 | |||
304 | func (m *GetPublicCertificateForAppResponse) GetMaxClientCacheTimeInSecond() int64 { | ||
305 | if m != nil && m.MaxClientCacheTimeInSecond != nil { | ||
306 | return *m.MaxClientCacheTimeInSecond | ||
307 | } | ||
308 | return 0 | ||
309 | } | ||
310 | |||
311 | type GetServiceAccountNameRequest struct { | ||
312 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
313 | XXX_unrecognized []byte `json:"-"` | ||
314 | XXX_sizecache int32 `json:"-"` | ||
315 | } | ||
316 | |||
317 | func (m *GetServiceAccountNameRequest) Reset() { *m = GetServiceAccountNameRequest{} } | ||
318 | func (m *GetServiceAccountNameRequest) String() string { return proto.CompactTextString(m) } | ||
319 | func (*GetServiceAccountNameRequest) ProtoMessage() {} | ||
320 | func (*GetServiceAccountNameRequest) Descriptor() ([]byte, []int) { | ||
321 | return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{6} | ||
322 | } | ||
323 | func (m *GetServiceAccountNameRequest) XXX_Unmarshal(b []byte) error { | ||
324 | return xxx_messageInfo_GetServiceAccountNameRequest.Unmarshal(m, b) | ||
325 | } | ||
326 | func (m *GetServiceAccountNameRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
327 | return xxx_messageInfo_GetServiceAccountNameRequest.Marshal(b, m, deterministic) | ||
328 | } | ||
329 | func (dst *GetServiceAccountNameRequest) XXX_Merge(src proto.Message) { | ||
330 | xxx_messageInfo_GetServiceAccountNameRequest.Merge(dst, src) | ||
331 | } | ||
332 | func (m *GetServiceAccountNameRequest) XXX_Size() int { | ||
333 | return xxx_messageInfo_GetServiceAccountNameRequest.Size(m) | ||
334 | } | ||
335 | func (m *GetServiceAccountNameRequest) XXX_DiscardUnknown() { | ||
336 | xxx_messageInfo_GetServiceAccountNameRequest.DiscardUnknown(m) | ||
337 | } | ||
338 | |||
339 | var xxx_messageInfo_GetServiceAccountNameRequest proto.InternalMessageInfo | ||
340 | |||
341 | type GetServiceAccountNameResponse struct { | ||
342 | ServiceAccountName *string `protobuf:"bytes,1,opt,name=service_account_name,json=serviceAccountName" json:"service_account_name,omitempty"` | ||
343 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
344 | XXX_unrecognized []byte `json:"-"` | ||
345 | XXX_sizecache int32 `json:"-"` | ||
346 | } | ||
347 | |||
348 | func (m *GetServiceAccountNameResponse) Reset() { *m = GetServiceAccountNameResponse{} } | ||
349 | func (m *GetServiceAccountNameResponse) String() string { return proto.CompactTextString(m) } | ||
350 | func (*GetServiceAccountNameResponse) ProtoMessage() {} | ||
351 | func (*GetServiceAccountNameResponse) Descriptor() ([]byte, []int) { | ||
352 | return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{7} | ||
353 | } | ||
354 | func (m *GetServiceAccountNameResponse) XXX_Unmarshal(b []byte) error { | ||
355 | return xxx_messageInfo_GetServiceAccountNameResponse.Unmarshal(m, b) | ||
356 | } | ||
357 | func (m *GetServiceAccountNameResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
358 | return xxx_messageInfo_GetServiceAccountNameResponse.Marshal(b, m, deterministic) | ||
359 | } | ||
360 | func (dst *GetServiceAccountNameResponse) XXX_Merge(src proto.Message) { | ||
361 | xxx_messageInfo_GetServiceAccountNameResponse.Merge(dst, src) | ||
362 | } | ||
363 | func (m *GetServiceAccountNameResponse) XXX_Size() int { | ||
364 | return xxx_messageInfo_GetServiceAccountNameResponse.Size(m) | ||
365 | } | ||
366 | func (m *GetServiceAccountNameResponse) XXX_DiscardUnknown() { | ||
367 | xxx_messageInfo_GetServiceAccountNameResponse.DiscardUnknown(m) | ||
368 | } | ||
369 | |||
370 | var xxx_messageInfo_GetServiceAccountNameResponse proto.InternalMessageInfo | ||
371 | |||
372 | func (m *GetServiceAccountNameResponse) GetServiceAccountName() string { | ||
373 | if m != nil && m.ServiceAccountName != nil { | ||
374 | return *m.ServiceAccountName | ||
375 | } | ||
376 | return "" | ||
377 | } | ||
378 | |||
379 | type GetAccessTokenRequest struct { | ||
380 | Scope []string `protobuf:"bytes,1,rep,name=scope" json:"scope,omitempty"` | ||
381 | ServiceAccountId *int64 `protobuf:"varint,2,opt,name=service_account_id,json=serviceAccountId" json:"service_account_id,omitempty"` | ||
382 | ServiceAccountName *string `protobuf:"bytes,3,opt,name=service_account_name,json=serviceAccountName" json:"service_account_name,omitempty"` | ||
383 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
384 | XXX_unrecognized []byte `json:"-"` | ||
385 | XXX_sizecache int32 `json:"-"` | ||
386 | } | ||
387 | |||
388 | func (m *GetAccessTokenRequest) Reset() { *m = GetAccessTokenRequest{} } | ||
389 | func (m *GetAccessTokenRequest) String() string { return proto.CompactTextString(m) } | ||
390 | func (*GetAccessTokenRequest) ProtoMessage() {} | ||
391 | func (*GetAccessTokenRequest) Descriptor() ([]byte, []int) { | ||
392 | return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{8} | ||
393 | } | ||
394 | func (m *GetAccessTokenRequest) XXX_Unmarshal(b []byte) error { | ||
395 | return xxx_messageInfo_GetAccessTokenRequest.Unmarshal(m, b) | ||
396 | } | ||
397 | func (m *GetAccessTokenRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
398 | return xxx_messageInfo_GetAccessTokenRequest.Marshal(b, m, deterministic) | ||
399 | } | ||
400 | func (dst *GetAccessTokenRequest) XXX_Merge(src proto.Message) { | ||
401 | xxx_messageInfo_GetAccessTokenRequest.Merge(dst, src) | ||
402 | } | ||
403 | func (m *GetAccessTokenRequest) XXX_Size() int { | ||
404 | return xxx_messageInfo_GetAccessTokenRequest.Size(m) | ||
405 | } | ||
406 | func (m *GetAccessTokenRequest) XXX_DiscardUnknown() { | ||
407 | xxx_messageInfo_GetAccessTokenRequest.DiscardUnknown(m) | ||
408 | } | ||
409 | |||
410 | var xxx_messageInfo_GetAccessTokenRequest proto.InternalMessageInfo | ||
411 | |||
412 | func (m *GetAccessTokenRequest) GetScope() []string { | ||
413 | if m != nil { | ||
414 | return m.Scope | ||
415 | } | ||
416 | return nil | ||
417 | } | ||
418 | |||
419 | func (m *GetAccessTokenRequest) GetServiceAccountId() int64 { | ||
420 | if m != nil && m.ServiceAccountId != nil { | ||
421 | return *m.ServiceAccountId | ||
422 | } | ||
423 | return 0 | ||
424 | } | ||
425 | |||
426 | func (m *GetAccessTokenRequest) GetServiceAccountName() string { | ||
427 | if m != nil && m.ServiceAccountName != nil { | ||
428 | return *m.ServiceAccountName | ||
429 | } | ||
430 | return "" | ||
431 | } | ||
432 | |||
433 | type GetAccessTokenResponse struct { | ||
434 | AccessToken *string `protobuf:"bytes,1,opt,name=access_token,json=accessToken" json:"access_token,omitempty"` | ||
435 | ExpirationTime *int64 `protobuf:"varint,2,opt,name=expiration_time,json=expirationTime" json:"expiration_time,omitempty"` | ||
436 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
437 | XXX_unrecognized []byte `json:"-"` | ||
438 | XXX_sizecache int32 `json:"-"` | ||
439 | } | ||
440 | |||
441 | func (m *GetAccessTokenResponse) Reset() { *m = GetAccessTokenResponse{} } | ||
442 | func (m *GetAccessTokenResponse) String() string { return proto.CompactTextString(m) } | ||
443 | func (*GetAccessTokenResponse) ProtoMessage() {} | ||
444 | func (*GetAccessTokenResponse) Descriptor() ([]byte, []int) { | ||
445 | return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{9} | ||
446 | } | ||
447 | func (m *GetAccessTokenResponse) XXX_Unmarshal(b []byte) error { | ||
448 | return xxx_messageInfo_GetAccessTokenResponse.Unmarshal(m, b) | ||
449 | } | ||
450 | func (m *GetAccessTokenResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
451 | return xxx_messageInfo_GetAccessTokenResponse.Marshal(b, m, deterministic) | ||
452 | } | ||
453 | func (dst *GetAccessTokenResponse) XXX_Merge(src proto.Message) { | ||
454 | xxx_messageInfo_GetAccessTokenResponse.Merge(dst, src) | ||
455 | } | ||
456 | func (m *GetAccessTokenResponse) XXX_Size() int { | ||
457 | return xxx_messageInfo_GetAccessTokenResponse.Size(m) | ||
458 | } | ||
459 | func (m *GetAccessTokenResponse) XXX_DiscardUnknown() { | ||
460 | xxx_messageInfo_GetAccessTokenResponse.DiscardUnknown(m) | ||
461 | } | ||
462 | |||
463 | var xxx_messageInfo_GetAccessTokenResponse proto.InternalMessageInfo | ||
464 | |||
465 | func (m *GetAccessTokenResponse) GetAccessToken() string { | ||
466 | if m != nil && m.AccessToken != nil { | ||
467 | return *m.AccessToken | ||
468 | } | ||
469 | return "" | ||
470 | } | ||
471 | |||
472 | func (m *GetAccessTokenResponse) GetExpirationTime() int64 { | ||
473 | if m != nil && m.ExpirationTime != nil { | ||
474 | return *m.ExpirationTime | ||
475 | } | ||
476 | return 0 | ||
477 | } | ||
478 | |||
479 | type GetDefaultGcsBucketNameRequest struct { | ||
480 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
481 | XXX_unrecognized []byte `json:"-"` | ||
482 | XXX_sizecache int32 `json:"-"` | ||
483 | } | ||
484 | |||
485 | func (m *GetDefaultGcsBucketNameRequest) Reset() { *m = GetDefaultGcsBucketNameRequest{} } | ||
486 | func (m *GetDefaultGcsBucketNameRequest) String() string { return proto.CompactTextString(m) } | ||
487 | func (*GetDefaultGcsBucketNameRequest) ProtoMessage() {} | ||
488 | func (*GetDefaultGcsBucketNameRequest) Descriptor() ([]byte, []int) { | ||
489 | return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{10} | ||
490 | } | ||
491 | func (m *GetDefaultGcsBucketNameRequest) XXX_Unmarshal(b []byte) error { | ||
492 | return xxx_messageInfo_GetDefaultGcsBucketNameRequest.Unmarshal(m, b) | ||
493 | } | ||
494 | func (m *GetDefaultGcsBucketNameRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
495 | return xxx_messageInfo_GetDefaultGcsBucketNameRequest.Marshal(b, m, deterministic) | ||
496 | } | ||
497 | func (dst *GetDefaultGcsBucketNameRequest) XXX_Merge(src proto.Message) { | ||
498 | xxx_messageInfo_GetDefaultGcsBucketNameRequest.Merge(dst, src) | ||
499 | } | ||
500 | func (m *GetDefaultGcsBucketNameRequest) XXX_Size() int { | ||
501 | return xxx_messageInfo_GetDefaultGcsBucketNameRequest.Size(m) | ||
502 | } | ||
503 | func (m *GetDefaultGcsBucketNameRequest) XXX_DiscardUnknown() { | ||
504 | xxx_messageInfo_GetDefaultGcsBucketNameRequest.DiscardUnknown(m) | ||
505 | } | ||
506 | |||
507 | var xxx_messageInfo_GetDefaultGcsBucketNameRequest proto.InternalMessageInfo | ||
508 | |||
509 | type GetDefaultGcsBucketNameResponse struct { | ||
510 | DefaultGcsBucketName *string `protobuf:"bytes,1,opt,name=default_gcs_bucket_name,json=defaultGcsBucketName" json:"default_gcs_bucket_name,omitempty"` | ||
511 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
512 | XXX_unrecognized []byte `json:"-"` | ||
513 | XXX_sizecache int32 `json:"-"` | ||
514 | } | ||
515 | |||
516 | func (m *GetDefaultGcsBucketNameResponse) Reset() { *m = GetDefaultGcsBucketNameResponse{} } | ||
517 | func (m *GetDefaultGcsBucketNameResponse) String() string { return proto.CompactTextString(m) } | ||
518 | func (*GetDefaultGcsBucketNameResponse) ProtoMessage() {} | ||
519 | func (*GetDefaultGcsBucketNameResponse) Descriptor() ([]byte, []int) { | ||
520 | return fileDescriptor_app_identity_service_08a6e3f74b04cfa4, []int{11} | ||
521 | } | ||
522 | func (m *GetDefaultGcsBucketNameResponse) XXX_Unmarshal(b []byte) error { | ||
523 | return xxx_messageInfo_GetDefaultGcsBucketNameResponse.Unmarshal(m, b) | ||
524 | } | ||
525 | func (m *GetDefaultGcsBucketNameResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
526 | return xxx_messageInfo_GetDefaultGcsBucketNameResponse.Marshal(b, m, deterministic) | ||
527 | } | ||
528 | func (dst *GetDefaultGcsBucketNameResponse) XXX_Merge(src proto.Message) { | ||
529 | xxx_messageInfo_GetDefaultGcsBucketNameResponse.Merge(dst, src) | ||
530 | } | ||
531 | func (m *GetDefaultGcsBucketNameResponse) XXX_Size() int { | ||
532 | return xxx_messageInfo_GetDefaultGcsBucketNameResponse.Size(m) | ||
533 | } | ||
534 | func (m *GetDefaultGcsBucketNameResponse) XXX_DiscardUnknown() { | ||
535 | xxx_messageInfo_GetDefaultGcsBucketNameResponse.DiscardUnknown(m) | ||
536 | } | ||
537 | |||
538 | var xxx_messageInfo_GetDefaultGcsBucketNameResponse proto.InternalMessageInfo | ||
539 | |||
540 | func (m *GetDefaultGcsBucketNameResponse) GetDefaultGcsBucketName() string { | ||
541 | if m != nil && m.DefaultGcsBucketName != nil { | ||
542 | return *m.DefaultGcsBucketName | ||
543 | } | ||
544 | return "" | ||
545 | } | ||
546 | |||
547 | func init() { | ||
548 | proto.RegisterType((*AppIdentityServiceError)(nil), "appengine.AppIdentityServiceError") | ||
549 | proto.RegisterType((*SignForAppRequest)(nil), "appengine.SignForAppRequest") | ||
550 | proto.RegisterType((*SignForAppResponse)(nil), "appengine.SignForAppResponse") | ||
551 | proto.RegisterType((*GetPublicCertificateForAppRequest)(nil), "appengine.GetPublicCertificateForAppRequest") | ||
552 | proto.RegisterType((*PublicCertificate)(nil), "appengine.PublicCertificate") | ||
553 | proto.RegisterType((*GetPublicCertificateForAppResponse)(nil), "appengine.GetPublicCertificateForAppResponse") | ||
554 | proto.RegisterType((*GetServiceAccountNameRequest)(nil), "appengine.GetServiceAccountNameRequest") | ||
555 | proto.RegisterType((*GetServiceAccountNameResponse)(nil), "appengine.GetServiceAccountNameResponse") | ||
556 | proto.RegisterType((*GetAccessTokenRequest)(nil), "appengine.GetAccessTokenRequest") | ||
557 | proto.RegisterType((*GetAccessTokenResponse)(nil), "appengine.GetAccessTokenResponse") | ||
558 | proto.RegisterType((*GetDefaultGcsBucketNameRequest)(nil), "appengine.GetDefaultGcsBucketNameRequest") | ||
559 | proto.RegisterType((*GetDefaultGcsBucketNameResponse)(nil), "appengine.GetDefaultGcsBucketNameResponse") | ||
560 | } | ||
561 | |||
562 | func init() { | ||
563 | proto.RegisterFile("google.golang.org/appengine/internal/app_identity/app_identity_service.proto", fileDescriptor_app_identity_service_08a6e3f74b04cfa4) | ||
564 | } | ||
565 | |||
566 | var fileDescriptor_app_identity_service_08a6e3f74b04cfa4 = []byte{ | ||
567 | // 676 bytes of a gzipped FileDescriptorProto | ||
568 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x54, 0xdb, 0x6e, 0xda, 0x58, | ||
569 | 0x14, 0x1d, 0x26, 0x1a, 0x31, 0x6c, 0x12, 0x62, 0xce, 0x90, 0xcb, 0x8c, 0x32, 0xb9, 0x78, 0x1e, | ||
570 | 0x26, 0x0f, 0x15, 0x89, 0x2a, 0x45, 0x55, 0x1f, 0x8d, 0xed, 0x22, 0x54, 0x07, 0x53, 0x43, 0x9a, | ||
571 | 0xa8, 0x2f, 0xa7, 0xce, 0x61, 0xc7, 0x3d, 0x02, 0x9f, 0xe3, 0xda, 0x87, 0x0a, 0x3e, 0xa2, 0x3f, | ||
572 | 0xd2, 0x9f, 0xe8, 0x5b, 0xbf, 0xa5, 0x17, 0xb5, 0xdf, 0x50, 0xd9, 0x38, 0x5c, 0x92, 0x92, 0x37, | ||
573 | 0xbc, 0xf6, 0x5a, 0xcb, 0x6b, 0x2f, 0x6d, 0x0c, 0x4e, 0x20, 0x65, 0x30, 0xc4, 0x7a, 0x20, 0x87, | ||
574 | 0xbe, 0x08, 0xea, 0x32, 0x0e, 0x4e, 0xfc, 0x28, 0x42, 0x11, 0x70, 0x81, 0x27, 0x5c, 0x28, 0x8c, | ||
575 | 0x85, 0x3f, 0x4c, 0x21, 0xca, 0xfb, 0x28, 0x14, 0x57, 0x93, 0xa5, 0x07, 0x9a, 0x60, 0xfc, 0x8e, | ||
576 | 0x33, 0xac, 0x47, 0xb1, 0x54, 0x92, 0x94, 0x66, 0x5a, 0xfd, 0x53, 0x01, 0x76, 0x8c, 0x28, 0x6a, | ||
577 | 0xe5, 0xc4, 0xee, 0x94, 0x67, 0xc7, 0xb1, 0x8c, 0xf5, 0x0f, 0x05, 0x28, 0x65, 0xbf, 0x4c, 0xd9, | ||
578 | 0x47, 0x52, 0x86, 0x62, 0xf7, 0xc2, 0x34, 0xed, 0x6e, 0x57, 0xfb, 0x8d, 0x54, 0x61, 0xe3, 0xa2, | ||
579 | 0xfd, 0xbc, 0xed, 0x5e, 0xb6, 0x69, 0xd7, 0x74, 0x3b, 0xb6, 0x56, 0x22, 0x7f, 0x41, 0xa5, 0xe1, | ||
580 | 0xb8, 0x0d, 0xda, 0x73, 0x5d, 0xea, 0x18, 0x5e, 0xd3, 0xd6, 0x3e, 0x17, 0xc9, 0x36, 0x54, 0x2d, | ||
581 | 0xdb, 0xb0, 0x9c, 0x56, 0xdb, 0xa6, 0xf6, 0x95, 0x69, 0xdb, 0x96, 0x6d, 0x69, 0x5f, 0x8a, 0xa4, | ||
582 | 0x06, 0x9b, 0x6d, 0xb7, 0x47, 0x0d, 0xfa, 0xd2, 0x70, 0x5a, 0x16, 0x35, 0x3a, 0x1d, 0xed, 0x6b, | ||
583 | 0x91, 0x90, 0xb9, 0xab, 0xed, 0x79, 0xae, 0xa7, 0x7d, 0x2b, 0x12, 0x0d, 0xca, 0x19, 0xd3, 0x71, | ||
584 | 0xdc, 0x4b, 0xdb, 0xd2, 0xbe, 0xcf, 0xb4, 0xad, 0xf3, 0x8e, 0x63, 0x9f, 0xdb, 0xed, 0x9e, 0x6d, | ||
585 | 0x69, 0x3f, 0x8a, 0xfa, 0x13, 0xa8, 0x76, 0x79, 0x20, 0x9e, 0xc9, 0xd8, 0x88, 0x22, 0x0f, 0xdf, | ||
586 | 0x8e, 0x30, 0x51, 0x44, 0x87, 0x8d, 0xeb, 0x89, 0xc2, 0x84, 0x2a, 0x49, 0x13, 0x1e, 0x88, 0xdd, | ||
587 | 0xc2, 0x61, 0xe1, 0x78, 0xdd, 0x2b, 0x67, 0x60, 0x4f, 0xa6, 0x02, 0xfd, 0x0a, 0xc8, 0xa2, 0x30, | ||
588 | 0x89, 0xa4, 0x48, 0x90, 0xfc, 0x0d, 0x7f, 0x0e, 0x70, 0x42, 0x85, 0x1f, 0x62, 0x26, 0x2a, 0x79, | ||
589 | 0xc5, 0x01, 0x4e, 0xda, 0x7e, 0x88, 0xe4, 0x7f, 0xd8, 0x4c, 0xbd, 0x7c, 0x35, 0x8a, 0x91, 0x66, | ||
590 | 0x4e, 0xbb, 0xbf, 0x67, 0xb6, 0x95, 0x19, 0xdc, 0x48, 0x51, 0xfd, 0x3f, 0x38, 0x6a, 0xa2, 0xea, | ||
591 | 0x8c, 0xae, 0x87, 0x9c, 0x99, 0x18, 0x2b, 0x7e, 0xc3, 0x99, 0xaf, 0x70, 0x29, 0xa2, 0xfe, 0x1a, | ||
592 | 0xaa, 0xf7, 0x18, 0x0f, 0xbd, 0xfd, 0x14, 0x6a, 0xe3, 0xb3, 0xd3, 0xa7, 0x94, 0xcd, 0xe9, 0x34, | ||
593 | 0xc2, 0x30, 0x8b, 0x50, 0xf2, 0x48, 0x3a, 0x5b, 0x70, 0xea, 0x60, 0xa8, 0x7f, 0x2c, 0x80, 0xfe, | ||
594 | 0x50, 0x8e, 0x7c, 0xe3, 0x1e, 0xec, 0x44, 0x19, 0x65, 0xc9, 0x7a, 0xc8, 0x13, 0xb5, 0x5b, 0x38, | ||
595 | 0x5c, 0x3b, 0x2e, 0x3f, 0xde, 0xab, 0xcf, 0xce, 0xa6, 0x7e, 0xcf, 0xcc, 0xdb, 0x8a, 0xee, 0x42, | ||
596 | 0x0e, 0x4f, 0x14, 0x31, 0xe1, 0x20, 0xf4, 0xc7, 0x94, 0x0d, 0x39, 0x0a, 0x45, 0x99, 0xcf, 0xde, | ||
597 | 0x20, 0x55, 0x3c, 0x44, 0xca, 0x05, 0x4d, 0x90, 0x49, 0xd1, 0xcf, 0x92, 0xaf, 0x79, 0xff, 0x84, | ||
598 | 0xfe, 0xd8, 0xcc, 0x58, 0x66, 0x4a, 0xea, 0xf1, 0x10, 0x5b, 0xa2, 0x9b, 0x31, 0xf4, 0x7d, 0xd8, | ||
599 | 0x6b, 0xa2, 0xca, 0x6f, 0xd3, 0x60, 0x4c, 0x8e, 0x84, 0x4a, 0xcb, 0xb8, 0xed, 0xf0, 0x05, 0xfc, | ||
600 | 0xbb, 0x62, 0x9e, 0xef, 0x76, 0x0a, 0xb5, 0xfc, 0x1f, 0x40, 0xfd, 0xe9, 0x78, 0xb1, 0x5b, 0x92, | ||
601 | 0xdc, 0x53, 0xea, 0xef, 0x0b, 0xb0, 0xd5, 0x44, 0x65, 0x30, 0x86, 0x49, 0xd2, 0x93, 0x03, 0x14, | ||
602 | 0xb7, 0x37, 0x55, 0x83, 0x3f, 0x12, 0x26, 0x23, 0xcc, 0x5a, 0x29, 0x79, 0xd3, 0x07, 0xf2, 0x08, | ||
603 | 0xc8, 0xdd, 0x37, 0xf0, 0xdb, 0xd5, 0xb4, 0x65, 0xff, 0x56, 0x7f, 0x65, 0x9e, 0xb5, 0x95, 0x79, | ||
604 | 0xfa, 0xb0, 0x7d, 0x37, 0x4e, 0xbe, 0xdb, 0x11, 0xac, 0xfb, 0x19, 0x4c, 0x55, 0x8a, 0xe7, 0x3b, | ||
605 | 0x95, 0xfd, 0x39, 0x35, 0xbd, 0x58, 0x1c, 0x47, 0x3c, 0xf6, 0x15, 0x97, 0x22, 0xab, 0x3f, 0x4f, | ||
606 | 0x56, 0x99, 0xc3, 0x69, 0xe1, 0xfa, 0x21, 0xec, 0x37, 0x51, 0x59, 0x78, 0xe3, 0x8f, 0x86, 0xaa, | ||
607 | 0xc9, 0x92, 0xc6, 0x88, 0x0d, 0x70, 0xa9, 0xea, 0x2b, 0x38, 0x58, 0xc9, 0xc8, 0x03, 0x9d, 0xc1, | ||
608 | 0x4e, 0x7f, 0x3a, 0xa7, 0x01, 0x4b, 0xe8, 0x75, 0xc6, 0x58, 0xec, 0xbb, 0xd6, 0xff, 0x85, 0xbc, | ||
609 | 0x51, 0x79, 0xb5, 0xbe, 0xf8, 0xc9, 0xfa, 0x19, 0x00, 0x00, 0xff, 0xff, 0x37, 0x4c, 0x56, 0x38, | ||
610 | 0xf3, 0x04, 0x00, 0x00, | ||
611 | } | ||
diff --git a/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.proto b/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.proto new file mode 100644 index 0000000..19610ca --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/app_identity/app_identity_service.proto | |||
@@ -0,0 +1,64 @@ | |||
1 | syntax = "proto2"; | ||
2 | option go_package = "app_identity"; | ||
3 | |||
4 | package appengine; | ||
5 | |||
6 | message AppIdentityServiceError { | ||
7 | enum ErrorCode { | ||
8 | SUCCESS = 0; | ||
9 | UNKNOWN_SCOPE = 9; | ||
10 | BLOB_TOO_LARGE = 1000; | ||
11 | DEADLINE_EXCEEDED = 1001; | ||
12 | NOT_A_VALID_APP = 1002; | ||
13 | UNKNOWN_ERROR = 1003; | ||
14 | NOT_ALLOWED = 1005; | ||
15 | NOT_IMPLEMENTED = 1006; | ||
16 | } | ||
17 | } | ||
18 | |||
19 | message SignForAppRequest { | ||
20 | optional bytes bytes_to_sign = 1; | ||
21 | } | ||
22 | |||
23 | message SignForAppResponse { | ||
24 | optional string key_name = 1; | ||
25 | optional bytes signature_bytes = 2; | ||
26 | } | ||
27 | |||
28 | message GetPublicCertificateForAppRequest { | ||
29 | } | ||
30 | |||
31 | message PublicCertificate { | ||
32 | optional string key_name = 1; | ||
33 | optional string x509_certificate_pem = 2; | ||
34 | } | ||
35 | |||
36 | message GetPublicCertificateForAppResponse { | ||
37 | repeated PublicCertificate public_certificate_list = 1; | ||
38 | optional int64 max_client_cache_time_in_second = 2; | ||
39 | } | ||
40 | |||
41 | message GetServiceAccountNameRequest { | ||
42 | } | ||
43 | |||
44 | message GetServiceAccountNameResponse { | ||
45 | optional string service_account_name = 1; | ||
46 | } | ||
47 | |||
48 | message GetAccessTokenRequest { | ||
49 | repeated string scope = 1; | ||
50 | optional int64 service_account_id = 2; | ||
51 | optional string service_account_name = 3; | ||
52 | } | ||
53 | |||
54 | message GetAccessTokenResponse { | ||
55 | optional string access_token = 1; | ||
56 | optional int64 expiration_time = 2; | ||
57 | } | ||
58 | |||
59 | message GetDefaultGcsBucketNameRequest { | ||
60 | } | ||
61 | |||
62 | message GetDefaultGcsBucketNameResponse { | ||
63 | optional string default_gcs_bucket_name = 1; | ||
64 | } | ||
diff --git a/vendor/google.golang.org/appengine/internal/base/api_base.pb.go b/vendor/google.golang.org/appengine/internal/base/api_base.pb.go new file mode 100644 index 0000000..db4777e --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/base/api_base.pb.go | |||
@@ -0,0 +1,308 @@ | |||
1 | // Code generated by protoc-gen-go. DO NOT EDIT. | ||
2 | // source: google.golang.org/appengine/internal/base/api_base.proto | ||
3 | |||
4 | package base | ||
5 | |||
6 | import proto "github.com/golang/protobuf/proto" | ||
7 | import fmt "fmt" | ||
8 | import math "math" | ||
9 | |||
10 | // Reference imports to suppress errors if they are not otherwise used. | ||
11 | var _ = proto.Marshal | ||
12 | var _ = fmt.Errorf | ||
13 | var _ = math.Inf | ||
14 | |||
15 | // This is a compile-time assertion to ensure that this generated file | ||
16 | // is compatible with the proto package it is being compiled against. | ||
17 | // A compilation error at this line likely means your copy of the | ||
18 | // proto package needs to be updated. | ||
19 | const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package | ||
20 | |||
21 | type StringProto struct { | ||
22 | Value *string `protobuf:"bytes,1,req,name=value" json:"value,omitempty"` | ||
23 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
24 | XXX_unrecognized []byte `json:"-"` | ||
25 | XXX_sizecache int32 `json:"-"` | ||
26 | } | ||
27 | |||
28 | func (m *StringProto) Reset() { *m = StringProto{} } | ||
29 | func (m *StringProto) String() string { return proto.CompactTextString(m) } | ||
30 | func (*StringProto) ProtoMessage() {} | ||
31 | func (*StringProto) Descriptor() ([]byte, []int) { | ||
32 | return fileDescriptor_api_base_9d49f8792e0c1140, []int{0} | ||
33 | } | ||
34 | func (m *StringProto) XXX_Unmarshal(b []byte) error { | ||
35 | return xxx_messageInfo_StringProto.Unmarshal(m, b) | ||
36 | } | ||
37 | func (m *StringProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
38 | return xxx_messageInfo_StringProto.Marshal(b, m, deterministic) | ||
39 | } | ||
40 | func (dst *StringProto) XXX_Merge(src proto.Message) { | ||
41 | xxx_messageInfo_StringProto.Merge(dst, src) | ||
42 | } | ||
43 | func (m *StringProto) XXX_Size() int { | ||
44 | return xxx_messageInfo_StringProto.Size(m) | ||
45 | } | ||
46 | func (m *StringProto) XXX_DiscardUnknown() { | ||
47 | xxx_messageInfo_StringProto.DiscardUnknown(m) | ||
48 | } | ||
49 | |||
50 | var xxx_messageInfo_StringProto proto.InternalMessageInfo | ||
51 | |||
52 | func (m *StringProto) GetValue() string { | ||
53 | if m != nil && m.Value != nil { | ||
54 | return *m.Value | ||
55 | } | ||
56 | return "" | ||
57 | } | ||
58 | |||
59 | type Integer32Proto struct { | ||
60 | Value *int32 `protobuf:"varint,1,req,name=value" json:"value,omitempty"` | ||
61 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
62 | XXX_unrecognized []byte `json:"-"` | ||
63 | XXX_sizecache int32 `json:"-"` | ||
64 | } | ||
65 | |||
66 | func (m *Integer32Proto) Reset() { *m = Integer32Proto{} } | ||
67 | func (m *Integer32Proto) String() string { return proto.CompactTextString(m) } | ||
68 | func (*Integer32Proto) ProtoMessage() {} | ||
69 | func (*Integer32Proto) Descriptor() ([]byte, []int) { | ||
70 | return fileDescriptor_api_base_9d49f8792e0c1140, []int{1} | ||
71 | } | ||
72 | func (m *Integer32Proto) XXX_Unmarshal(b []byte) error { | ||
73 | return xxx_messageInfo_Integer32Proto.Unmarshal(m, b) | ||
74 | } | ||
75 | func (m *Integer32Proto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
76 | return xxx_messageInfo_Integer32Proto.Marshal(b, m, deterministic) | ||
77 | } | ||
78 | func (dst *Integer32Proto) XXX_Merge(src proto.Message) { | ||
79 | xxx_messageInfo_Integer32Proto.Merge(dst, src) | ||
80 | } | ||
81 | func (m *Integer32Proto) XXX_Size() int { | ||
82 | return xxx_messageInfo_Integer32Proto.Size(m) | ||
83 | } | ||
84 | func (m *Integer32Proto) XXX_DiscardUnknown() { | ||
85 | xxx_messageInfo_Integer32Proto.DiscardUnknown(m) | ||
86 | } | ||
87 | |||
88 | var xxx_messageInfo_Integer32Proto proto.InternalMessageInfo | ||
89 | |||
90 | func (m *Integer32Proto) GetValue() int32 { | ||
91 | if m != nil && m.Value != nil { | ||
92 | return *m.Value | ||
93 | } | ||
94 | return 0 | ||
95 | } | ||
96 | |||
97 | type Integer64Proto struct { | ||
98 | Value *int64 `protobuf:"varint,1,req,name=value" json:"value,omitempty"` | ||
99 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
100 | XXX_unrecognized []byte `json:"-"` | ||
101 | XXX_sizecache int32 `json:"-"` | ||
102 | } | ||
103 | |||
104 | func (m *Integer64Proto) Reset() { *m = Integer64Proto{} } | ||
105 | func (m *Integer64Proto) String() string { return proto.CompactTextString(m) } | ||
106 | func (*Integer64Proto) ProtoMessage() {} | ||
107 | func (*Integer64Proto) Descriptor() ([]byte, []int) { | ||
108 | return fileDescriptor_api_base_9d49f8792e0c1140, []int{2} | ||
109 | } | ||
110 | func (m *Integer64Proto) XXX_Unmarshal(b []byte) error { | ||
111 | return xxx_messageInfo_Integer64Proto.Unmarshal(m, b) | ||
112 | } | ||
113 | func (m *Integer64Proto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
114 | return xxx_messageInfo_Integer64Proto.Marshal(b, m, deterministic) | ||
115 | } | ||
116 | func (dst *Integer64Proto) XXX_Merge(src proto.Message) { | ||
117 | xxx_messageInfo_Integer64Proto.Merge(dst, src) | ||
118 | } | ||
119 | func (m *Integer64Proto) XXX_Size() int { | ||
120 | return xxx_messageInfo_Integer64Proto.Size(m) | ||
121 | } | ||
122 | func (m *Integer64Proto) XXX_DiscardUnknown() { | ||
123 | xxx_messageInfo_Integer64Proto.DiscardUnknown(m) | ||
124 | } | ||
125 | |||
126 | var xxx_messageInfo_Integer64Proto proto.InternalMessageInfo | ||
127 | |||
128 | func (m *Integer64Proto) GetValue() int64 { | ||
129 | if m != nil && m.Value != nil { | ||
130 | return *m.Value | ||
131 | } | ||
132 | return 0 | ||
133 | } | ||
134 | |||
135 | type BoolProto struct { | ||
136 | Value *bool `protobuf:"varint,1,req,name=value" json:"value,omitempty"` | ||
137 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
138 | XXX_unrecognized []byte `json:"-"` | ||
139 | XXX_sizecache int32 `json:"-"` | ||
140 | } | ||
141 | |||
142 | func (m *BoolProto) Reset() { *m = BoolProto{} } | ||
143 | func (m *BoolProto) String() string { return proto.CompactTextString(m) } | ||
144 | func (*BoolProto) ProtoMessage() {} | ||
145 | func (*BoolProto) Descriptor() ([]byte, []int) { | ||
146 | return fileDescriptor_api_base_9d49f8792e0c1140, []int{3} | ||
147 | } | ||
148 | func (m *BoolProto) XXX_Unmarshal(b []byte) error { | ||
149 | return xxx_messageInfo_BoolProto.Unmarshal(m, b) | ||
150 | } | ||
151 | func (m *BoolProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
152 | return xxx_messageInfo_BoolProto.Marshal(b, m, deterministic) | ||
153 | } | ||
154 | func (dst *BoolProto) XXX_Merge(src proto.Message) { | ||
155 | xxx_messageInfo_BoolProto.Merge(dst, src) | ||
156 | } | ||
157 | func (m *BoolProto) XXX_Size() int { | ||
158 | return xxx_messageInfo_BoolProto.Size(m) | ||
159 | } | ||
160 | func (m *BoolProto) XXX_DiscardUnknown() { | ||
161 | xxx_messageInfo_BoolProto.DiscardUnknown(m) | ||
162 | } | ||
163 | |||
164 | var xxx_messageInfo_BoolProto proto.InternalMessageInfo | ||
165 | |||
166 | func (m *BoolProto) GetValue() bool { | ||
167 | if m != nil && m.Value != nil { | ||
168 | return *m.Value | ||
169 | } | ||
170 | return false | ||
171 | } | ||
172 | |||
173 | type DoubleProto struct { | ||
174 | Value *float64 `protobuf:"fixed64,1,req,name=value" json:"value,omitempty"` | ||
175 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
176 | XXX_unrecognized []byte `json:"-"` | ||
177 | XXX_sizecache int32 `json:"-"` | ||
178 | } | ||
179 | |||
180 | func (m *DoubleProto) Reset() { *m = DoubleProto{} } | ||
181 | func (m *DoubleProto) String() string { return proto.CompactTextString(m) } | ||
182 | func (*DoubleProto) ProtoMessage() {} | ||
183 | func (*DoubleProto) Descriptor() ([]byte, []int) { | ||
184 | return fileDescriptor_api_base_9d49f8792e0c1140, []int{4} | ||
185 | } | ||
186 | func (m *DoubleProto) XXX_Unmarshal(b []byte) error { | ||
187 | return xxx_messageInfo_DoubleProto.Unmarshal(m, b) | ||
188 | } | ||
189 | func (m *DoubleProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
190 | return xxx_messageInfo_DoubleProto.Marshal(b, m, deterministic) | ||
191 | } | ||
192 | func (dst *DoubleProto) XXX_Merge(src proto.Message) { | ||
193 | xxx_messageInfo_DoubleProto.Merge(dst, src) | ||
194 | } | ||
195 | func (m *DoubleProto) XXX_Size() int { | ||
196 | return xxx_messageInfo_DoubleProto.Size(m) | ||
197 | } | ||
198 | func (m *DoubleProto) XXX_DiscardUnknown() { | ||
199 | xxx_messageInfo_DoubleProto.DiscardUnknown(m) | ||
200 | } | ||
201 | |||
202 | var xxx_messageInfo_DoubleProto proto.InternalMessageInfo | ||
203 | |||
204 | func (m *DoubleProto) GetValue() float64 { | ||
205 | if m != nil && m.Value != nil { | ||
206 | return *m.Value | ||
207 | } | ||
208 | return 0 | ||
209 | } | ||
210 | |||
211 | type BytesProto struct { | ||
212 | Value []byte `protobuf:"bytes,1,req,name=value" json:"value,omitempty"` | ||
213 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
214 | XXX_unrecognized []byte `json:"-"` | ||
215 | XXX_sizecache int32 `json:"-"` | ||
216 | } | ||
217 | |||
218 | func (m *BytesProto) Reset() { *m = BytesProto{} } | ||
219 | func (m *BytesProto) String() string { return proto.CompactTextString(m) } | ||
220 | func (*BytesProto) ProtoMessage() {} | ||
221 | func (*BytesProto) Descriptor() ([]byte, []int) { | ||
222 | return fileDescriptor_api_base_9d49f8792e0c1140, []int{5} | ||
223 | } | ||
224 | func (m *BytesProto) XXX_Unmarshal(b []byte) error { | ||
225 | return xxx_messageInfo_BytesProto.Unmarshal(m, b) | ||
226 | } | ||
227 | func (m *BytesProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
228 | return xxx_messageInfo_BytesProto.Marshal(b, m, deterministic) | ||
229 | } | ||
230 | func (dst *BytesProto) XXX_Merge(src proto.Message) { | ||
231 | xxx_messageInfo_BytesProto.Merge(dst, src) | ||
232 | } | ||
233 | func (m *BytesProto) XXX_Size() int { | ||
234 | return xxx_messageInfo_BytesProto.Size(m) | ||
235 | } | ||
236 | func (m *BytesProto) XXX_DiscardUnknown() { | ||
237 | xxx_messageInfo_BytesProto.DiscardUnknown(m) | ||
238 | } | ||
239 | |||
240 | var xxx_messageInfo_BytesProto proto.InternalMessageInfo | ||
241 | |||
242 | func (m *BytesProto) GetValue() []byte { | ||
243 | if m != nil { | ||
244 | return m.Value | ||
245 | } | ||
246 | return nil | ||
247 | } | ||
248 | |||
249 | type VoidProto struct { | ||
250 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
251 | XXX_unrecognized []byte `json:"-"` | ||
252 | XXX_sizecache int32 `json:"-"` | ||
253 | } | ||
254 | |||
255 | func (m *VoidProto) Reset() { *m = VoidProto{} } | ||
256 | func (m *VoidProto) String() string { return proto.CompactTextString(m) } | ||
257 | func (*VoidProto) ProtoMessage() {} | ||
258 | func (*VoidProto) Descriptor() ([]byte, []int) { | ||
259 | return fileDescriptor_api_base_9d49f8792e0c1140, []int{6} | ||
260 | } | ||
261 | func (m *VoidProto) XXX_Unmarshal(b []byte) error { | ||
262 | return xxx_messageInfo_VoidProto.Unmarshal(m, b) | ||
263 | } | ||
264 | func (m *VoidProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
265 | return xxx_messageInfo_VoidProto.Marshal(b, m, deterministic) | ||
266 | } | ||
267 | func (dst *VoidProto) XXX_Merge(src proto.Message) { | ||
268 | xxx_messageInfo_VoidProto.Merge(dst, src) | ||
269 | } | ||
270 | func (m *VoidProto) XXX_Size() int { | ||
271 | return xxx_messageInfo_VoidProto.Size(m) | ||
272 | } | ||
273 | func (m *VoidProto) XXX_DiscardUnknown() { | ||
274 | xxx_messageInfo_VoidProto.DiscardUnknown(m) | ||
275 | } | ||
276 | |||
277 | var xxx_messageInfo_VoidProto proto.InternalMessageInfo | ||
278 | |||
279 | func init() { | ||
280 | proto.RegisterType((*StringProto)(nil), "appengine.base.StringProto") | ||
281 | proto.RegisterType((*Integer32Proto)(nil), "appengine.base.Integer32Proto") | ||
282 | proto.RegisterType((*Integer64Proto)(nil), "appengine.base.Integer64Proto") | ||
283 | proto.RegisterType((*BoolProto)(nil), "appengine.base.BoolProto") | ||
284 | proto.RegisterType((*DoubleProto)(nil), "appengine.base.DoubleProto") | ||
285 | proto.RegisterType((*BytesProto)(nil), "appengine.base.BytesProto") | ||
286 | proto.RegisterType((*VoidProto)(nil), "appengine.base.VoidProto") | ||
287 | } | ||
288 | |||
289 | func init() { | ||
290 | proto.RegisterFile("google.golang.org/appengine/internal/base/api_base.proto", fileDescriptor_api_base_9d49f8792e0c1140) | ||
291 | } | ||
292 | |||
293 | var fileDescriptor_api_base_9d49f8792e0c1140 = []byte{ | ||
294 | // 199 bytes of a gzipped FileDescriptorProto | ||
295 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0xcf, 0x3f, 0x4b, 0xc6, 0x30, | ||
296 | 0x10, 0x06, 0x70, 0x5a, 0xad, 0xb4, 0x57, 0xe9, 0x20, 0x0e, 0x1d, 0xb5, 0x05, 0x71, 0x4a, 0x40, | ||
297 | 0x45, 0x9c, 0x83, 0x8b, 0x9b, 0x28, 0x38, 0xb8, 0x48, 0x8a, 0xc7, 0x11, 0x08, 0xb9, 0x90, 0xa6, | ||
298 | 0x82, 0xdf, 0x5e, 0xda, 0xd2, 0xfa, 0xc2, 0x9b, 0xed, 0xfe, 0xfc, 0xe0, 0xe1, 0x81, 0x27, 0x62, | ||
299 | 0x26, 0x8b, 0x82, 0xd8, 0x6a, 0x47, 0x82, 0x03, 0x49, 0xed, 0x3d, 0x3a, 0x32, 0x0e, 0xa5, 0x71, | ||
300 | 0x11, 0x83, 0xd3, 0x56, 0x0e, 0x7a, 0x44, 0xa9, 0xbd, 0xf9, 0x9a, 0x07, 0xe1, 0x03, 0x47, 0xbe, | ||
301 | 0x68, 0x76, 0x27, 0xe6, 0x6b, 0xd7, 0x43, 0xfd, 0x1e, 0x83, 0x71, 0xf4, 0xba, 0xbc, 0x2f, 0xa1, | ||
302 | 0xf8, 0xd1, 0x76, 0xc2, 0x36, 0xbb, 0xca, 0x6f, 0xab, 0xb7, 0x75, 0xe9, 0x6e, 0xa0, 0x79, 0x71, | ||
303 | 0x11, 0x09, 0xc3, 0xfd, 0x5d, 0xc2, 0x15, 0xc7, 0xee, 0xf1, 0x21, 0xe1, 0x4e, 0x36, 0x77, 0x0d, | ||
304 | 0x95, 0x62, 0xb6, 0x09, 0x52, 0x6e, 0xa4, 0x87, 0xfa, 0x99, 0xa7, 0xc1, 0x62, 0x02, 0x65, 0xff, | ||
305 | 0x79, 0xa0, 0x7e, 0x23, 0x8e, 0xab, 0x69, 0x0f, 0xcd, 0xb9, 0xca, 0xcb, 0xdd, 0xd5, 0x50, 0x7d, | ||
306 | 0xb0, 0xf9, 0x5e, 0x98, 0x3a, 0xfb, 0x3c, 0x9d, 0x9b, 0xff, 0x05, 0x00, 0x00, 0xff, 0xff, 0xba, | ||
307 | 0x37, 0x25, 0xea, 0x44, 0x01, 0x00, 0x00, | ||
308 | } | ||
diff --git a/vendor/google.golang.org/appengine/internal/base/api_base.proto b/vendor/google.golang.org/appengine/internal/base/api_base.proto new file mode 100644 index 0000000..56cd7a3 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/base/api_base.proto | |||
@@ -0,0 +1,33 @@ | |||
1 | // Built-in base types for API calls. Primarily useful as return types. | ||
2 | |||
3 | syntax = "proto2"; | ||
4 | option go_package = "base"; | ||
5 | |||
6 | package appengine.base; | ||
7 | |||
8 | message StringProto { | ||
9 | required string value = 1; | ||
10 | } | ||
11 | |||
12 | message Integer32Proto { | ||
13 | required int32 value = 1; | ||
14 | } | ||
15 | |||
16 | message Integer64Proto { | ||
17 | required int64 value = 1; | ||
18 | } | ||
19 | |||
20 | message BoolProto { | ||
21 | required bool value = 1; | ||
22 | } | ||
23 | |||
24 | message DoubleProto { | ||
25 | required double value = 1; | ||
26 | } | ||
27 | |||
28 | message BytesProto { | ||
29 | required bytes value = 1 [ctype=CORD]; | ||
30 | } | ||
31 | |||
32 | message VoidProto { | ||
33 | } | ||
diff --git a/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.pb.go b/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.pb.go new file mode 100644 index 0000000..2fb7482 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.pb.go | |||
@@ -0,0 +1,4367 @@ | |||
1 | // Code generated by protoc-gen-go. DO NOT EDIT. | ||
2 | // source: google.golang.org/appengine/internal/datastore/datastore_v3.proto | ||
3 | |||
4 | package datastore | ||
5 | |||
6 | import proto "github.com/golang/protobuf/proto" | ||
7 | import fmt "fmt" | ||
8 | import math "math" | ||
9 | |||
10 | // Reference imports to suppress errors if they are not otherwise used. | ||
11 | var _ = proto.Marshal | ||
12 | var _ = fmt.Errorf | ||
13 | var _ = math.Inf | ||
14 | |||
15 | // This is a compile-time assertion to ensure that this generated file | ||
16 | // is compatible with the proto package it is being compiled against. | ||
17 | // A compilation error at this line likely means your copy of the | ||
18 | // proto package needs to be updated. | ||
19 | const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package | ||
20 | |||
21 | type Property_Meaning int32 | ||
22 | |||
23 | const ( | ||
24 | Property_NO_MEANING Property_Meaning = 0 | ||
25 | Property_BLOB Property_Meaning = 14 | ||
26 | Property_TEXT Property_Meaning = 15 | ||
27 | Property_BYTESTRING Property_Meaning = 16 | ||
28 | Property_ATOM_CATEGORY Property_Meaning = 1 | ||
29 | Property_ATOM_LINK Property_Meaning = 2 | ||
30 | Property_ATOM_TITLE Property_Meaning = 3 | ||
31 | Property_ATOM_CONTENT Property_Meaning = 4 | ||
32 | Property_ATOM_SUMMARY Property_Meaning = 5 | ||
33 | Property_ATOM_AUTHOR Property_Meaning = 6 | ||
34 | Property_GD_WHEN Property_Meaning = 7 | ||
35 | Property_GD_EMAIL Property_Meaning = 8 | ||
36 | Property_GEORSS_POINT Property_Meaning = 9 | ||
37 | Property_GD_IM Property_Meaning = 10 | ||
38 | Property_GD_PHONENUMBER Property_Meaning = 11 | ||
39 | Property_GD_POSTALADDRESS Property_Meaning = 12 | ||
40 | Property_GD_RATING Property_Meaning = 13 | ||
41 | Property_BLOBKEY Property_Meaning = 17 | ||
42 | Property_ENTITY_PROTO Property_Meaning = 19 | ||
43 | Property_INDEX_VALUE Property_Meaning = 18 | ||
44 | ) | ||
45 | |||
46 | var Property_Meaning_name = map[int32]string{ | ||
47 | 0: "NO_MEANING", | ||
48 | 14: "BLOB", | ||
49 | 15: "TEXT", | ||
50 | 16: "BYTESTRING", | ||
51 | 1: "ATOM_CATEGORY", | ||
52 | 2: "ATOM_LINK", | ||
53 | 3: "ATOM_TITLE", | ||
54 | 4: "ATOM_CONTENT", | ||
55 | 5: "ATOM_SUMMARY", | ||
56 | 6: "ATOM_AUTHOR", | ||
57 | 7: "GD_WHEN", | ||
58 | 8: "GD_EMAIL", | ||
59 | 9: "GEORSS_POINT", | ||
60 | 10: "GD_IM", | ||
61 | 11: "GD_PHONENUMBER", | ||
62 | 12: "GD_POSTALADDRESS", | ||
63 | 13: "GD_RATING", | ||
64 | 17: "BLOBKEY", | ||
65 | 19: "ENTITY_PROTO", | ||
66 | 18: "INDEX_VALUE", | ||
67 | } | ||
68 | var Property_Meaning_value = map[string]int32{ | ||
69 | "NO_MEANING": 0, | ||
70 | "BLOB": 14, | ||
71 | "TEXT": 15, | ||
72 | "BYTESTRING": 16, | ||
73 | "ATOM_CATEGORY": 1, | ||
74 | "ATOM_LINK": 2, | ||
75 | "ATOM_TITLE": 3, | ||
76 | "ATOM_CONTENT": 4, | ||
77 | "ATOM_SUMMARY": 5, | ||
78 | "ATOM_AUTHOR": 6, | ||
79 | "GD_WHEN": 7, | ||
80 | "GD_EMAIL": 8, | ||
81 | "GEORSS_POINT": 9, | ||
82 | "GD_IM": 10, | ||
83 | "GD_PHONENUMBER": 11, | ||
84 | "GD_POSTALADDRESS": 12, | ||
85 | "GD_RATING": 13, | ||
86 | "BLOBKEY": 17, | ||
87 | "ENTITY_PROTO": 19, | ||
88 | "INDEX_VALUE": 18, | ||
89 | } | ||
90 | |||
91 | func (x Property_Meaning) Enum() *Property_Meaning { | ||
92 | p := new(Property_Meaning) | ||
93 | *p = x | ||
94 | return p | ||
95 | } | ||
96 | func (x Property_Meaning) String() string { | ||
97 | return proto.EnumName(Property_Meaning_name, int32(x)) | ||
98 | } | ||
99 | func (x *Property_Meaning) UnmarshalJSON(data []byte) error { | ||
100 | value, err := proto.UnmarshalJSONEnum(Property_Meaning_value, data, "Property_Meaning") | ||
101 | if err != nil { | ||
102 | return err | ||
103 | } | ||
104 | *x = Property_Meaning(value) | ||
105 | return nil | ||
106 | } | ||
107 | func (Property_Meaning) EnumDescriptor() ([]byte, []int) { | ||
108 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{2, 0} | ||
109 | } | ||
110 | |||
111 | type Property_FtsTokenizationOption int32 | ||
112 | |||
113 | const ( | ||
114 | Property_HTML Property_FtsTokenizationOption = 1 | ||
115 | Property_ATOM Property_FtsTokenizationOption = 2 | ||
116 | ) | ||
117 | |||
118 | var Property_FtsTokenizationOption_name = map[int32]string{ | ||
119 | 1: "HTML", | ||
120 | 2: "ATOM", | ||
121 | } | ||
122 | var Property_FtsTokenizationOption_value = map[string]int32{ | ||
123 | "HTML": 1, | ||
124 | "ATOM": 2, | ||
125 | } | ||
126 | |||
127 | func (x Property_FtsTokenizationOption) Enum() *Property_FtsTokenizationOption { | ||
128 | p := new(Property_FtsTokenizationOption) | ||
129 | *p = x | ||
130 | return p | ||
131 | } | ||
132 | func (x Property_FtsTokenizationOption) String() string { | ||
133 | return proto.EnumName(Property_FtsTokenizationOption_name, int32(x)) | ||
134 | } | ||
135 | func (x *Property_FtsTokenizationOption) UnmarshalJSON(data []byte) error { | ||
136 | value, err := proto.UnmarshalJSONEnum(Property_FtsTokenizationOption_value, data, "Property_FtsTokenizationOption") | ||
137 | if err != nil { | ||
138 | return err | ||
139 | } | ||
140 | *x = Property_FtsTokenizationOption(value) | ||
141 | return nil | ||
142 | } | ||
143 | func (Property_FtsTokenizationOption) EnumDescriptor() ([]byte, []int) { | ||
144 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{2, 1} | ||
145 | } | ||
146 | |||
147 | type EntityProto_Kind int32 | ||
148 | |||
149 | const ( | ||
150 | EntityProto_GD_CONTACT EntityProto_Kind = 1 | ||
151 | EntityProto_GD_EVENT EntityProto_Kind = 2 | ||
152 | EntityProto_GD_MESSAGE EntityProto_Kind = 3 | ||
153 | ) | ||
154 | |||
155 | var EntityProto_Kind_name = map[int32]string{ | ||
156 | 1: "GD_CONTACT", | ||
157 | 2: "GD_EVENT", | ||
158 | 3: "GD_MESSAGE", | ||
159 | } | ||
160 | var EntityProto_Kind_value = map[string]int32{ | ||
161 | "GD_CONTACT": 1, | ||
162 | "GD_EVENT": 2, | ||
163 | "GD_MESSAGE": 3, | ||
164 | } | ||
165 | |||
166 | func (x EntityProto_Kind) Enum() *EntityProto_Kind { | ||
167 | p := new(EntityProto_Kind) | ||
168 | *p = x | ||
169 | return p | ||
170 | } | ||
171 | func (x EntityProto_Kind) String() string { | ||
172 | return proto.EnumName(EntityProto_Kind_name, int32(x)) | ||
173 | } | ||
174 | func (x *EntityProto_Kind) UnmarshalJSON(data []byte) error { | ||
175 | value, err := proto.UnmarshalJSONEnum(EntityProto_Kind_value, data, "EntityProto_Kind") | ||
176 | if err != nil { | ||
177 | return err | ||
178 | } | ||
179 | *x = EntityProto_Kind(value) | ||
180 | return nil | ||
181 | } | ||
182 | func (EntityProto_Kind) EnumDescriptor() ([]byte, []int) { | ||
183 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{6, 0} | ||
184 | } | ||
185 | |||
186 | type Index_Property_Direction int32 | ||
187 | |||
188 | const ( | ||
189 | Index_Property_ASCENDING Index_Property_Direction = 1 | ||
190 | Index_Property_DESCENDING Index_Property_Direction = 2 | ||
191 | ) | ||
192 | |||
193 | var Index_Property_Direction_name = map[int32]string{ | ||
194 | 1: "ASCENDING", | ||
195 | 2: "DESCENDING", | ||
196 | } | ||
197 | var Index_Property_Direction_value = map[string]int32{ | ||
198 | "ASCENDING": 1, | ||
199 | "DESCENDING": 2, | ||
200 | } | ||
201 | |||
202 | func (x Index_Property_Direction) Enum() *Index_Property_Direction { | ||
203 | p := new(Index_Property_Direction) | ||
204 | *p = x | ||
205 | return p | ||
206 | } | ||
207 | func (x Index_Property_Direction) String() string { | ||
208 | return proto.EnumName(Index_Property_Direction_name, int32(x)) | ||
209 | } | ||
210 | func (x *Index_Property_Direction) UnmarshalJSON(data []byte) error { | ||
211 | value, err := proto.UnmarshalJSONEnum(Index_Property_Direction_value, data, "Index_Property_Direction") | ||
212 | if err != nil { | ||
213 | return err | ||
214 | } | ||
215 | *x = Index_Property_Direction(value) | ||
216 | return nil | ||
217 | } | ||
218 | func (Index_Property_Direction) EnumDescriptor() ([]byte, []int) { | ||
219 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{8, 0, 0} | ||
220 | } | ||
221 | |||
222 | type CompositeIndex_State int32 | ||
223 | |||
224 | const ( | ||
225 | CompositeIndex_WRITE_ONLY CompositeIndex_State = 1 | ||
226 | CompositeIndex_READ_WRITE CompositeIndex_State = 2 | ||
227 | CompositeIndex_DELETED CompositeIndex_State = 3 | ||
228 | CompositeIndex_ERROR CompositeIndex_State = 4 | ||
229 | ) | ||
230 | |||
231 | var CompositeIndex_State_name = map[int32]string{ | ||
232 | 1: "WRITE_ONLY", | ||
233 | 2: "READ_WRITE", | ||
234 | 3: "DELETED", | ||
235 | 4: "ERROR", | ||
236 | } | ||
237 | var CompositeIndex_State_value = map[string]int32{ | ||
238 | "WRITE_ONLY": 1, | ||
239 | "READ_WRITE": 2, | ||
240 | "DELETED": 3, | ||
241 | "ERROR": 4, | ||
242 | } | ||
243 | |||
244 | func (x CompositeIndex_State) Enum() *CompositeIndex_State { | ||
245 | p := new(CompositeIndex_State) | ||
246 | *p = x | ||
247 | return p | ||
248 | } | ||
249 | func (x CompositeIndex_State) String() string { | ||
250 | return proto.EnumName(CompositeIndex_State_name, int32(x)) | ||
251 | } | ||
252 | func (x *CompositeIndex_State) UnmarshalJSON(data []byte) error { | ||
253 | value, err := proto.UnmarshalJSONEnum(CompositeIndex_State_value, data, "CompositeIndex_State") | ||
254 | if err != nil { | ||
255 | return err | ||
256 | } | ||
257 | *x = CompositeIndex_State(value) | ||
258 | return nil | ||
259 | } | ||
260 | func (CompositeIndex_State) EnumDescriptor() ([]byte, []int) { | ||
261 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{9, 0} | ||
262 | } | ||
263 | |||
264 | type Snapshot_Status int32 | ||
265 | |||
266 | const ( | ||
267 | Snapshot_INACTIVE Snapshot_Status = 0 | ||
268 | Snapshot_ACTIVE Snapshot_Status = 1 | ||
269 | ) | ||
270 | |||
271 | var Snapshot_Status_name = map[int32]string{ | ||
272 | 0: "INACTIVE", | ||
273 | 1: "ACTIVE", | ||
274 | } | ||
275 | var Snapshot_Status_value = map[string]int32{ | ||
276 | "INACTIVE": 0, | ||
277 | "ACTIVE": 1, | ||
278 | } | ||
279 | |||
280 | func (x Snapshot_Status) Enum() *Snapshot_Status { | ||
281 | p := new(Snapshot_Status) | ||
282 | *p = x | ||
283 | return p | ||
284 | } | ||
285 | func (x Snapshot_Status) String() string { | ||
286 | return proto.EnumName(Snapshot_Status_name, int32(x)) | ||
287 | } | ||
288 | func (x *Snapshot_Status) UnmarshalJSON(data []byte) error { | ||
289 | value, err := proto.UnmarshalJSONEnum(Snapshot_Status_value, data, "Snapshot_Status") | ||
290 | if err != nil { | ||
291 | return err | ||
292 | } | ||
293 | *x = Snapshot_Status(value) | ||
294 | return nil | ||
295 | } | ||
296 | func (Snapshot_Status) EnumDescriptor() ([]byte, []int) { | ||
297 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{12, 0} | ||
298 | } | ||
299 | |||
300 | type Query_Hint int32 | ||
301 | |||
302 | const ( | ||
303 | Query_ORDER_FIRST Query_Hint = 1 | ||
304 | Query_ANCESTOR_FIRST Query_Hint = 2 | ||
305 | Query_FILTER_FIRST Query_Hint = 3 | ||
306 | ) | ||
307 | |||
308 | var Query_Hint_name = map[int32]string{ | ||
309 | 1: "ORDER_FIRST", | ||
310 | 2: "ANCESTOR_FIRST", | ||
311 | 3: "FILTER_FIRST", | ||
312 | } | ||
313 | var Query_Hint_value = map[string]int32{ | ||
314 | "ORDER_FIRST": 1, | ||
315 | "ANCESTOR_FIRST": 2, | ||
316 | "FILTER_FIRST": 3, | ||
317 | } | ||
318 | |||
319 | func (x Query_Hint) Enum() *Query_Hint { | ||
320 | p := new(Query_Hint) | ||
321 | *p = x | ||
322 | return p | ||
323 | } | ||
324 | func (x Query_Hint) String() string { | ||
325 | return proto.EnumName(Query_Hint_name, int32(x)) | ||
326 | } | ||
327 | func (x *Query_Hint) UnmarshalJSON(data []byte) error { | ||
328 | value, err := proto.UnmarshalJSONEnum(Query_Hint_value, data, "Query_Hint") | ||
329 | if err != nil { | ||
330 | return err | ||
331 | } | ||
332 | *x = Query_Hint(value) | ||
333 | return nil | ||
334 | } | ||
335 | func (Query_Hint) EnumDescriptor() ([]byte, []int) { | ||
336 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{15, 0} | ||
337 | } | ||
338 | |||
339 | type Query_Filter_Operator int32 | ||
340 | |||
341 | const ( | ||
342 | Query_Filter_LESS_THAN Query_Filter_Operator = 1 | ||
343 | Query_Filter_LESS_THAN_OR_EQUAL Query_Filter_Operator = 2 | ||
344 | Query_Filter_GREATER_THAN Query_Filter_Operator = 3 | ||
345 | Query_Filter_GREATER_THAN_OR_EQUAL Query_Filter_Operator = 4 | ||
346 | Query_Filter_EQUAL Query_Filter_Operator = 5 | ||
347 | Query_Filter_IN Query_Filter_Operator = 6 | ||
348 | Query_Filter_EXISTS Query_Filter_Operator = 7 | ||
349 | ) | ||
350 | |||
351 | var Query_Filter_Operator_name = map[int32]string{ | ||
352 | 1: "LESS_THAN", | ||
353 | 2: "LESS_THAN_OR_EQUAL", | ||
354 | 3: "GREATER_THAN", | ||
355 | 4: "GREATER_THAN_OR_EQUAL", | ||
356 | 5: "EQUAL", | ||
357 | 6: "IN", | ||
358 | 7: "EXISTS", | ||
359 | } | ||
360 | var Query_Filter_Operator_value = map[string]int32{ | ||
361 | "LESS_THAN": 1, | ||
362 | "LESS_THAN_OR_EQUAL": 2, | ||
363 | "GREATER_THAN": 3, | ||
364 | "GREATER_THAN_OR_EQUAL": 4, | ||
365 | "EQUAL": 5, | ||
366 | "IN": 6, | ||
367 | "EXISTS": 7, | ||
368 | } | ||
369 | |||
370 | func (x Query_Filter_Operator) Enum() *Query_Filter_Operator { | ||
371 | p := new(Query_Filter_Operator) | ||
372 | *p = x | ||
373 | return p | ||
374 | } | ||
375 | func (x Query_Filter_Operator) String() string { | ||
376 | return proto.EnumName(Query_Filter_Operator_name, int32(x)) | ||
377 | } | ||
378 | func (x *Query_Filter_Operator) UnmarshalJSON(data []byte) error { | ||
379 | value, err := proto.UnmarshalJSONEnum(Query_Filter_Operator_value, data, "Query_Filter_Operator") | ||
380 | if err != nil { | ||
381 | return err | ||
382 | } | ||
383 | *x = Query_Filter_Operator(value) | ||
384 | return nil | ||
385 | } | ||
386 | func (Query_Filter_Operator) EnumDescriptor() ([]byte, []int) { | ||
387 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{15, 0, 0} | ||
388 | } | ||
389 | |||
390 | type Query_Order_Direction int32 | ||
391 | |||
392 | const ( | ||
393 | Query_Order_ASCENDING Query_Order_Direction = 1 | ||
394 | Query_Order_DESCENDING Query_Order_Direction = 2 | ||
395 | ) | ||
396 | |||
397 | var Query_Order_Direction_name = map[int32]string{ | ||
398 | 1: "ASCENDING", | ||
399 | 2: "DESCENDING", | ||
400 | } | ||
401 | var Query_Order_Direction_value = map[string]int32{ | ||
402 | "ASCENDING": 1, | ||
403 | "DESCENDING": 2, | ||
404 | } | ||
405 | |||
406 | func (x Query_Order_Direction) Enum() *Query_Order_Direction { | ||
407 | p := new(Query_Order_Direction) | ||
408 | *p = x | ||
409 | return p | ||
410 | } | ||
411 | func (x Query_Order_Direction) String() string { | ||
412 | return proto.EnumName(Query_Order_Direction_name, int32(x)) | ||
413 | } | ||
414 | func (x *Query_Order_Direction) UnmarshalJSON(data []byte) error { | ||
415 | value, err := proto.UnmarshalJSONEnum(Query_Order_Direction_value, data, "Query_Order_Direction") | ||
416 | if err != nil { | ||
417 | return err | ||
418 | } | ||
419 | *x = Query_Order_Direction(value) | ||
420 | return nil | ||
421 | } | ||
422 | func (Query_Order_Direction) EnumDescriptor() ([]byte, []int) { | ||
423 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{15, 1, 0} | ||
424 | } | ||
425 | |||
426 | type Error_ErrorCode int32 | ||
427 | |||
428 | const ( | ||
429 | Error_BAD_REQUEST Error_ErrorCode = 1 | ||
430 | Error_CONCURRENT_TRANSACTION Error_ErrorCode = 2 | ||
431 | Error_INTERNAL_ERROR Error_ErrorCode = 3 | ||
432 | Error_NEED_INDEX Error_ErrorCode = 4 | ||
433 | Error_TIMEOUT Error_ErrorCode = 5 | ||
434 | Error_PERMISSION_DENIED Error_ErrorCode = 6 | ||
435 | Error_BIGTABLE_ERROR Error_ErrorCode = 7 | ||
436 | Error_COMMITTED_BUT_STILL_APPLYING Error_ErrorCode = 8 | ||
437 | Error_CAPABILITY_DISABLED Error_ErrorCode = 9 | ||
438 | Error_TRY_ALTERNATE_BACKEND Error_ErrorCode = 10 | ||
439 | Error_SAFE_TIME_TOO_OLD Error_ErrorCode = 11 | ||
440 | ) | ||
441 | |||
442 | var Error_ErrorCode_name = map[int32]string{ | ||
443 | 1: "BAD_REQUEST", | ||
444 | 2: "CONCURRENT_TRANSACTION", | ||
445 | 3: "INTERNAL_ERROR", | ||
446 | 4: "NEED_INDEX", | ||
447 | 5: "TIMEOUT", | ||
448 | 6: "PERMISSION_DENIED", | ||
449 | 7: "BIGTABLE_ERROR", | ||
450 | 8: "COMMITTED_BUT_STILL_APPLYING", | ||
451 | 9: "CAPABILITY_DISABLED", | ||
452 | 10: "TRY_ALTERNATE_BACKEND", | ||
453 | 11: "SAFE_TIME_TOO_OLD", | ||
454 | } | ||
455 | var Error_ErrorCode_value = map[string]int32{ | ||
456 | "BAD_REQUEST": 1, | ||
457 | "CONCURRENT_TRANSACTION": 2, | ||
458 | "INTERNAL_ERROR": 3, | ||
459 | "NEED_INDEX": 4, | ||
460 | "TIMEOUT": 5, | ||
461 | "PERMISSION_DENIED": 6, | ||
462 | "BIGTABLE_ERROR": 7, | ||
463 | "COMMITTED_BUT_STILL_APPLYING": 8, | ||
464 | "CAPABILITY_DISABLED": 9, | ||
465 | "TRY_ALTERNATE_BACKEND": 10, | ||
466 | "SAFE_TIME_TOO_OLD": 11, | ||
467 | } | ||
468 | |||
469 | func (x Error_ErrorCode) Enum() *Error_ErrorCode { | ||
470 | p := new(Error_ErrorCode) | ||
471 | *p = x | ||
472 | return p | ||
473 | } | ||
474 | func (x Error_ErrorCode) String() string { | ||
475 | return proto.EnumName(Error_ErrorCode_name, int32(x)) | ||
476 | } | ||
477 | func (x *Error_ErrorCode) UnmarshalJSON(data []byte) error { | ||
478 | value, err := proto.UnmarshalJSONEnum(Error_ErrorCode_value, data, "Error_ErrorCode") | ||
479 | if err != nil { | ||
480 | return err | ||
481 | } | ||
482 | *x = Error_ErrorCode(value) | ||
483 | return nil | ||
484 | } | ||
485 | func (Error_ErrorCode) EnumDescriptor() ([]byte, []int) { | ||
486 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{19, 0} | ||
487 | } | ||
488 | |||
489 | type PutRequest_AutoIdPolicy int32 | ||
490 | |||
491 | const ( | ||
492 | PutRequest_CURRENT PutRequest_AutoIdPolicy = 0 | ||
493 | PutRequest_SEQUENTIAL PutRequest_AutoIdPolicy = 1 | ||
494 | ) | ||
495 | |||
496 | var PutRequest_AutoIdPolicy_name = map[int32]string{ | ||
497 | 0: "CURRENT", | ||
498 | 1: "SEQUENTIAL", | ||
499 | } | ||
500 | var PutRequest_AutoIdPolicy_value = map[string]int32{ | ||
501 | "CURRENT": 0, | ||
502 | "SEQUENTIAL": 1, | ||
503 | } | ||
504 | |||
505 | func (x PutRequest_AutoIdPolicy) Enum() *PutRequest_AutoIdPolicy { | ||
506 | p := new(PutRequest_AutoIdPolicy) | ||
507 | *p = x | ||
508 | return p | ||
509 | } | ||
510 | func (x PutRequest_AutoIdPolicy) String() string { | ||
511 | return proto.EnumName(PutRequest_AutoIdPolicy_name, int32(x)) | ||
512 | } | ||
513 | func (x *PutRequest_AutoIdPolicy) UnmarshalJSON(data []byte) error { | ||
514 | value, err := proto.UnmarshalJSONEnum(PutRequest_AutoIdPolicy_value, data, "PutRequest_AutoIdPolicy") | ||
515 | if err != nil { | ||
516 | return err | ||
517 | } | ||
518 | *x = PutRequest_AutoIdPolicy(value) | ||
519 | return nil | ||
520 | } | ||
521 | func (PutRequest_AutoIdPolicy) EnumDescriptor() ([]byte, []int) { | ||
522 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{23, 0} | ||
523 | } | ||
524 | |||
525 | type BeginTransactionRequest_TransactionMode int32 | ||
526 | |||
527 | const ( | ||
528 | BeginTransactionRequest_UNKNOWN BeginTransactionRequest_TransactionMode = 0 | ||
529 | BeginTransactionRequest_READ_ONLY BeginTransactionRequest_TransactionMode = 1 | ||
530 | BeginTransactionRequest_READ_WRITE BeginTransactionRequest_TransactionMode = 2 | ||
531 | ) | ||
532 | |||
533 | var BeginTransactionRequest_TransactionMode_name = map[int32]string{ | ||
534 | 0: "UNKNOWN", | ||
535 | 1: "READ_ONLY", | ||
536 | 2: "READ_WRITE", | ||
537 | } | ||
538 | var BeginTransactionRequest_TransactionMode_value = map[string]int32{ | ||
539 | "UNKNOWN": 0, | ||
540 | "READ_ONLY": 1, | ||
541 | "READ_WRITE": 2, | ||
542 | } | ||
543 | |||
544 | func (x BeginTransactionRequest_TransactionMode) Enum() *BeginTransactionRequest_TransactionMode { | ||
545 | p := new(BeginTransactionRequest_TransactionMode) | ||
546 | *p = x | ||
547 | return p | ||
548 | } | ||
549 | func (x BeginTransactionRequest_TransactionMode) String() string { | ||
550 | return proto.EnumName(BeginTransactionRequest_TransactionMode_name, int32(x)) | ||
551 | } | ||
552 | func (x *BeginTransactionRequest_TransactionMode) UnmarshalJSON(data []byte) error { | ||
553 | value, err := proto.UnmarshalJSONEnum(BeginTransactionRequest_TransactionMode_value, data, "BeginTransactionRequest_TransactionMode") | ||
554 | if err != nil { | ||
555 | return err | ||
556 | } | ||
557 | *x = BeginTransactionRequest_TransactionMode(value) | ||
558 | return nil | ||
559 | } | ||
560 | func (BeginTransactionRequest_TransactionMode) EnumDescriptor() ([]byte, []int) { | ||
561 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{36, 0} | ||
562 | } | ||
563 | |||
564 | type Action struct { | ||
565 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
566 | XXX_unrecognized []byte `json:"-"` | ||
567 | XXX_sizecache int32 `json:"-"` | ||
568 | } | ||
569 | |||
570 | func (m *Action) Reset() { *m = Action{} } | ||
571 | func (m *Action) String() string { return proto.CompactTextString(m) } | ||
572 | func (*Action) ProtoMessage() {} | ||
573 | func (*Action) Descriptor() ([]byte, []int) { | ||
574 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{0} | ||
575 | } | ||
576 | func (m *Action) XXX_Unmarshal(b []byte) error { | ||
577 | return xxx_messageInfo_Action.Unmarshal(m, b) | ||
578 | } | ||
579 | func (m *Action) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
580 | return xxx_messageInfo_Action.Marshal(b, m, deterministic) | ||
581 | } | ||
582 | func (dst *Action) XXX_Merge(src proto.Message) { | ||
583 | xxx_messageInfo_Action.Merge(dst, src) | ||
584 | } | ||
585 | func (m *Action) XXX_Size() int { | ||
586 | return xxx_messageInfo_Action.Size(m) | ||
587 | } | ||
588 | func (m *Action) XXX_DiscardUnknown() { | ||
589 | xxx_messageInfo_Action.DiscardUnknown(m) | ||
590 | } | ||
591 | |||
592 | var xxx_messageInfo_Action proto.InternalMessageInfo | ||
593 | |||
594 | type PropertyValue struct { | ||
595 | Int64Value *int64 `protobuf:"varint,1,opt,name=int64Value" json:"int64Value,omitempty"` | ||
596 | BooleanValue *bool `protobuf:"varint,2,opt,name=booleanValue" json:"booleanValue,omitempty"` | ||
597 | StringValue *string `protobuf:"bytes,3,opt,name=stringValue" json:"stringValue,omitempty"` | ||
598 | DoubleValue *float64 `protobuf:"fixed64,4,opt,name=doubleValue" json:"doubleValue,omitempty"` | ||
599 | Pointvalue *PropertyValue_PointValue `protobuf:"group,5,opt,name=PointValue,json=pointvalue" json:"pointvalue,omitempty"` | ||
600 | Uservalue *PropertyValue_UserValue `protobuf:"group,8,opt,name=UserValue,json=uservalue" json:"uservalue,omitempty"` | ||
601 | Referencevalue *PropertyValue_ReferenceValue `protobuf:"group,12,opt,name=ReferenceValue,json=referencevalue" json:"referencevalue,omitempty"` | ||
602 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
603 | XXX_unrecognized []byte `json:"-"` | ||
604 | XXX_sizecache int32 `json:"-"` | ||
605 | } | ||
606 | |||
607 | func (m *PropertyValue) Reset() { *m = PropertyValue{} } | ||
608 | func (m *PropertyValue) String() string { return proto.CompactTextString(m) } | ||
609 | func (*PropertyValue) ProtoMessage() {} | ||
610 | func (*PropertyValue) Descriptor() ([]byte, []int) { | ||
611 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{1} | ||
612 | } | ||
613 | func (m *PropertyValue) XXX_Unmarshal(b []byte) error { | ||
614 | return xxx_messageInfo_PropertyValue.Unmarshal(m, b) | ||
615 | } | ||
616 | func (m *PropertyValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
617 | return xxx_messageInfo_PropertyValue.Marshal(b, m, deterministic) | ||
618 | } | ||
619 | func (dst *PropertyValue) XXX_Merge(src proto.Message) { | ||
620 | xxx_messageInfo_PropertyValue.Merge(dst, src) | ||
621 | } | ||
622 | func (m *PropertyValue) XXX_Size() int { | ||
623 | return xxx_messageInfo_PropertyValue.Size(m) | ||
624 | } | ||
625 | func (m *PropertyValue) XXX_DiscardUnknown() { | ||
626 | xxx_messageInfo_PropertyValue.DiscardUnknown(m) | ||
627 | } | ||
628 | |||
629 | var xxx_messageInfo_PropertyValue proto.InternalMessageInfo | ||
630 | |||
631 | func (m *PropertyValue) GetInt64Value() int64 { | ||
632 | if m != nil && m.Int64Value != nil { | ||
633 | return *m.Int64Value | ||
634 | } | ||
635 | return 0 | ||
636 | } | ||
637 | |||
638 | func (m *PropertyValue) GetBooleanValue() bool { | ||
639 | if m != nil && m.BooleanValue != nil { | ||
640 | return *m.BooleanValue | ||
641 | } | ||
642 | return false | ||
643 | } | ||
644 | |||
645 | func (m *PropertyValue) GetStringValue() string { | ||
646 | if m != nil && m.StringValue != nil { | ||
647 | return *m.StringValue | ||
648 | } | ||
649 | return "" | ||
650 | } | ||
651 | |||
652 | func (m *PropertyValue) GetDoubleValue() float64 { | ||
653 | if m != nil && m.DoubleValue != nil { | ||
654 | return *m.DoubleValue | ||
655 | } | ||
656 | return 0 | ||
657 | } | ||
658 | |||
659 | func (m *PropertyValue) GetPointvalue() *PropertyValue_PointValue { | ||
660 | if m != nil { | ||
661 | return m.Pointvalue | ||
662 | } | ||
663 | return nil | ||
664 | } | ||
665 | |||
666 | func (m *PropertyValue) GetUservalue() *PropertyValue_UserValue { | ||
667 | if m != nil { | ||
668 | return m.Uservalue | ||
669 | } | ||
670 | return nil | ||
671 | } | ||
672 | |||
673 | func (m *PropertyValue) GetReferencevalue() *PropertyValue_ReferenceValue { | ||
674 | if m != nil { | ||
675 | return m.Referencevalue | ||
676 | } | ||
677 | return nil | ||
678 | } | ||
679 | |||
680 | type PropertyValue_PointValue struct { | ||
681 | X *float64 `protobuf:"fixed64,6,req,name=x" json:"x,omitempty"` | ||
682 | Y *float64 `protobuf:"fixed64,7,req,name=y" json:"y,omitempty"` | ||
683 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
684 | XXX_unrecognized []byte `json:"-"` | ||
685 | XXX_sizecache int32 `json:"-"` | ||
686 | } | ||
687 | |||
688 | func (m *PropertyValue_PointValue) Reset() { *m = PropertyValue_PointValue{} } | ||
689 | func (m *PropertyValue_PointValue) String() string { return proto.CompactTextString(m) } | ||
690 | func (*PropertyValue_PointValue) ProtoMessage() {} | ||
691 | func (*PropertyValue_PointValue) Descriptor() ([]byte, []int) { | ||
692 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{1, 0} | ||
693 | } | ||
694 | func (m *PropertyValue_PointValue) XXX_Unmarshal(b []byte) error { | ||
695 | return xxx_messageInfo_PropertyValue_PointValue.Unmarshal(m, b) | ||
696 | } | ||
697 | func (m *PropertyValue_PointValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
698 | return xxx_messageInfo_PropertyValue_PointValue.Marshal(b, m, deterministic) | ||
699 | } | ||
700 | func (dst *PropertyValue_PointValue) XXX_Merge(src proto.Message) { | ||
701 | xxx_messageInfo_PropertyValue_PointValue.Merge(dst, src) | ||
702 | } | ||
703 | func (m *PropertyValue_PointValue) XXX_Size() int { | ||
704 | return xxx_messageInfo_PropertyValue_PointValue.Size(m) | ||
705 | } | ||
706 | func (m *PropertyValue_PointValue) XXX_DiscardUnknown() { | ||
707 | xxx_messageInfo_PropertyValue_PointValue.DiscardUnknown(m) | ||
708 | } | ||
709 | |||
710 | var xxx_messageInfo_PropertyValue_PointValue proto.InternalMessageInfo | ||
711 | |||
712 | func (m *PropertyValue_PointValue) GetX() float64 { | ||
713 | if m != nil && m.X != nil { | ||
714 | return *m.X | ||
715 | } | ||
716 | return 0 | ||
717 | } | ||
718 | |||
719 | func (m *PropertyValue_PointValue) GetY() float64 { | ||
720 | if m != nil && m.Y != nil { | ||
721 | return *m.Y | ||
722 | } | ||
723 | return 0 | ||
724 | } | ||
725 | |||
726 | type PropertyValue_UserValue struct { | ||
727 | Email *string `protobuf:"bytes,9,req,name=email" json:"email,omitempty"` | ||
728 | AuthDomain *string `protobuf:"bytes,10,req,name=auth_domain,json=authDomain" json:"auth_domain,omitempty"` | ||
729 | Nickname *string `protobuf:"bytes,11,opt,name=nickname" json:"nickname,omitempty"` | ||
730 | FederatedIdentity *string `protobuf:"bytes,21,opt,name=federated_identity,json=federatedIdentity" json:"federated_identity,omitempty"` | ||
731 | FederatedProvider *string `protobuf:"bytes,22,opt,name=federated_provider,json=federatedProvider" json:"federated_provider,omitempty"` | ||
732 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
733 | XXX_unrecognized []byte `json:"-"` | ||
734 | XXX_sizecache int32 `json:"-"` | ||
735 | } | ||
736 | |||
737 | func (m *PropertyValue_UserValue) Reset() { *m = PropertyValue_UserValue{} } | ||
738 | func (m *PropertyValue_UserValue) String() string { return proto.CompactTextString(m) } | ||
739 | func (*PropertyValue_UserValue) ProtoMessage() {} | ||
740 | func (*PropertyValue_UserValue) Descriptor() ([]byte, []int) { | ||
741 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{1, 1} | ||
742 | } | ||
743 | func (m *PropertyValue_UserValue) XXX_Unmarshal(b []byte) error { | ||
744 | return xxx_messageInfo_PropertyValue_UserValue.Unmarshal(m, b) | ||
745 | } | ||
746 | func (m *PropertyValue_UserValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
747 | return xxx_messageInfo_PropertyValue_UserValue.Marshal(b, m, deterministic) | ||
748 | } | ||
749 | func (dst *PropertyValue_UserValue) XXX_Merge(src proto.Message) { | ||
750 | xxx_messageInfo_PropertyValue_UserValue.Merge(dst, src) | ||
751 | } | ||
752 | func (m *PropertyValue_UserValue) XXX_Size() int { | ||
753 | return xxx_messageInfo_PropertyValue_UserValue.Size(m) | ||
754 | } | ||
755 | func (m *PropertyValue_UserValue) XXX_DiscardUnknown() { | ||
756 | xxx_messageInfo_PropertyValue_UserValue.DiscardUnknown(m) | ||
757 | } | ||
758 | |||
759 | var xxx_messageInfo_PropertyValue_UserValue proto.InternalMessageInfo | ||
760 | |||
761 | func (m *PropertyValue_UserValue) GetEmail() string { | ||
762 | if m != nil && m.Email != nil { | ||
763 | return *m.Email | ||
764 | } | ||
765 | return "" | ||
766 | } | ||
767 | |||
768 | func (m *PropertyValue_UserValue) GetAuthDomain() string { | ||
769 | if m != nil && m.AuthDomain != nil { | ||
770 | return *m.AuthDomain | ||
771 | } | ||
772 | return "" | ||
773 | } | ||
774 | |||
775 | func (m *PropertyValue_UserValue) GetNickname() string { | ||
776 | if m != nil && m.Nickname != nil { | ||
777 | return *m.Nickname | ||
778 | } | ||
779 | return "" | ||
780 | } | ||
781 | |||
782 | func (m *PropertyValue_UserValue) GetFederatedIdentity() string { | ||
783 | if m != nil && m.FederatedIdentity != nil { | ||
784 | return *m.FederatedIdentity | ||
785 | } | ||
786 | return "" | ||
787 | } | ||
788 | |||
789 | func (m *PropertyValue_UserValue) GetFederatedProvider() string { | ||
790 | if m != nil && m.FederatedProvider != nil { | ||
791 | return *m.FederatedProvider | ||
792 | } | ||
793 | return "" | ||
794 | } | ||
795 | |||
796 | type PropertyValue_ReferenceValue struct { | ||
797 | App *string `protobuf:"bytes,13,req,name=app" json:"app,omitempty"` | ||
798 | NameSpace *string `protobuf:"bytes,20,opt,name=name_space,json=nameSpace" json:"name_space,omitempty"` | ||
799 | Pathelement []*PropertyValue_ReferenceValue_PathElement `protobuf:"group,14,rep,name=PathElement,json=pathelement" json:"pathelement,omitempty"` | ||
800 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
801 | XXX_unrecognized []byte `json:"-"` | ||
802 | XXX_sizecache int32 `json:"-"` | ||
803 | } | ||
804 | |||
805 | func (m *PropertyValue_ReferenceValue) Reset() { *m = PropertyValue_ReferenceValue{} } | ||
806 | func (m *PropertyValue_ReferenceValue) String() string { return proto.CompactTextString(m) } | ||
807 | func (*PropertyValue_ReferenceValue) ProtoMessage() {} | ||
808 | func (*PropertyValue_ReferenceValue) Descriptor() ([]byte, []int) { | ||
809 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{1, 2} | ||
810 | } | ||
811 | func (m *PropertyValue_ReferenceValue) XXX_Unmarshal(b []byte) error { | ||
812 | return xxx_messageInfo_PropertyValue_ReferenceValue.Unmarshal(m, b) | ||
813 | } | ||
814 | func (m *PropertyValue_ReferenceValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
815 | return xxx_messageInfo_PropertyValue_ReferenceValue.Marshal(b, m, deterministic) | ||
816 | } | ||
817 | func (dst *PropertyValue_ReferenceValue) XXX_Merge(src proto.Message) { | ||
818 | xxx_messageInfo_PropertyValue_ReferenceValue.Merge(dst, src) | ||
819 | } | ||
820 | func (m *PropertyValue_ReferenceValue) XXX_Size() int { | ||
821 | return xxx_messageInfo_PropertyValue_ReferenceValue.Size(m) | ||
822 | } | ||
823 | func (m *PropertyValue_ReferenceValue) XXX_DiscardUnknown() { | ||
824 | xxx_messageInfo_PropertyValue_ReferenceValue.DiscardUnknown(m) | ||
825 | } | ||
826 | |||
827 | var xxx_messageInfo_PropertyValue_ReferenceValue proto.InternalMessageInfo | ||
828 | |||
829 | func (m *PropertyValue_ReferenceValue) GetApp() string { | ||
830 | if m != nil && m.App != nil { | ||
831 | return *m.App | ||
832 | } | ||
833 | return "" | ||
834 | } | ||
835 | |||
836 | func (m *PropertyValue_ReferenceValue) GetNameSpace() string { | ||
837 | if m != nil && m.NameSpace != nil { | ||
838 | return *m.NameSpace | ||
839 | } | ||
840 | return "" | ||
841 | } | ||
842 | |||
843 | func (m *PropertyValue_ReferenceValue) GetPathelement() []*PropertyValue_ReferenceValue_PathElement { | ||
844 | if m != nil { | ||
845 | return m.Pathelement | ||
846 | } | ||
847 | return nil | ||
848 | } | ||
849 | |||
850 | type PropertyValue_ReferenceValue_PathElement struct { | ||
851 | Type *string `protobuf:"bytes,15,req,name=type" json:"type,omitempty"` | ||
852 | Id *int64 `protobuf:"varint,16,opt,name=id" json:"id,omitempty"` | ||
853 | Name *string `protobuf:"bytes,17,opt,name=name" json:"name,omitempty"` | ||
854 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
855 | XXX_unrecognized []byte `json:"-"` | ||
856 | XXX_sizecache int32 `json:"-"` | ||
857 | } | ||
858 | |||
859 | func (m *PropertyValue_ReferenceValue_PathElement) Reset() { | ||
860 | *m = PropertyValue_ReferenceValue_PathElement{} | ||
861 | } | ||
862 | func (m *PropertyValue_ReferenceValue_PathElement) String() string { return proto.CompactTextString(m) } | ||
863 | func (*PropertyValue_ReferenceValue_PathElement) ProtoMessage() {} | ||
864 | func (*PropertyValue_ReferenceValue_PathElement) Descriptor() ([]byte, []int) { | ||
865 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{1, 2, 0} | ||
866 | } | ||
867 | func (m *PropertyValue_ReferenceValue_PathElement) XXX_Unmarshal(b []byte) error { | ||
868 | return xxx_messageInfo_PropertyValue_ReferenceValue_PathElement.Unmarshal(m, b) | ||
869 | } | ||
870 | func (m *PropertyValue_ReferenceValue_PathElement) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
871 | return xxx_messageInfo_PropertyValue_ReferenceValue_PathElement.Marshal(b, m, deterministic) | ||
872 | } | ||
873 | func (dst *PropertyValue_ReferenceValue_PathElement) XXX_Merge(src proto.Message) { | ||
874 | xxx_messageInfo_PropertyValue_ReferenceValue_PathElement.Merge(dst, src) | ||
875 | } | ||
876 | func (m *PropertyValue_ReferenceValue_PathElement) XXX_Size() int { | ||
877 | return xxx_messageInfo_PropertyValue_ReferenceValue_PathElement.Size(m) | ||
878 | } | ||
879 | func (m *PropertyValue_ReferenceValue_PathElement) XXX_DiscardUnknown() { | ||
880 | xxx_messageInfo_PropertyValue_ReferenceValue_PathElement.DiscardUnknown(m) | ||
881 | } | ||
882 | |||
883 | var xxx_messageInfo_PropertyValue_ReferenceValue_PathElement proto.InternalMessageInfo | ||
884 | |||
885 | func (m *PropertyValue_ReferenceValue_PathElement) GetType() string { | ||
886 | if m != nil && m.Type != nil { | ||
887 | return *m.Type | ||
888 | } | ||
889 | return "" | ||
890 | } | ||
891 | |||
892 | func (m *PropertyValue_ReferenceValue_PathElement) GetId() int64 { | ||
893 | if m != nil && m.Id != nil { | ||
894 | return *m.Id | ||
895 | } | ||
896 | return 0 | ||
897 | } | ||
898 | |||
899 | func (m *PropertyValue_ReferenceValue_PathElement) GetName() string { | ||
900 | if m != nil && m.Name != nil { | ||
901 | return *m.Name | ||
902 | } | ||
903 | return "" | ||
904 | } | ||
905 | |||
906 | type Property struct { | ||
907 | Meaning *Property_Meaning `protobuf:"varint,1,opt,name=meaning,enum=appengine.Property_Meaning,def=0" json:"meaning,omitempty"` | ||
908 | MeaningUri *string `protobuf:"bytes,2,opt,name=meaning_uri,json=meaningUri" json:"meaning_uri,omitempty"` | ||
909 | Name *string `protobuf:"bytes,3,req,name=name" json:"name,omitempty"` | ||
910 | Value *PropertyValue `protobuf:"bytes,5,req,name=value" json:"value,omitempty"` | ||
911 | Multiple *bool `protobuf:"varint,4,req,name=multiple" json:"multiple,omitempty"` | ||
912 | Searchable *bool `protobuf:"varint,6,opt,name=searchable,def=0" json:"searchable,omitempty"` | ||
913 | FtsTokenizationOption *Property_FtsTokenizationOption `protobuf:"varint,8,opt,name=fts_tokenization_option,json=ftsTokenizationOption,enum=appengine.Property_FtsTokenizationOption" json:"fts_tokenization_option,omitempty"` | ||
914 | Locale *string `protobuf:"bytes,9,opt,name=locale,def=en" json:"locale,omitempty"` | ||
915 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
916 | XXX_unrecognized []byte `json:"-"` | ||
917 | XXX_sizecache int32 `json:"-"` | ||
918 | } | ||
919 | |||
920 | func (m *Property) Reset() { *m = Property{} } | ||
921 | func (m *Property) String() string { return proto.CompactTextString(m) } | ||
922 | func (*Property) ProtoMessage() {} | ||
923 | func (*Property) Descriptor() ([]byte, []int) { | ||
924 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{2} | ||
925 | } | ||
926 | func (m *Property) XXX_Unmarshal(b []byte) error { | ||
927 | return xxx_messageInfo_Property.Unmarshal(m, b) | ||
928 | } | ||
929 | func (m *Property) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
930 | return xxx_messageInfo_Property.Marshal(b, m, deterministic) | ||
931 | } | ||
932 | func (dst *Property) XXX_Merge(src proto.Message) { | ||
933 | xxx_messageInfo_Property.Merge(dst, src) | ||
934 | } | ||
935 | func (m *Property) XXX_Size() int { | ||
936 | return xxx_messageInfo_Property.Size(m) | ||
937 | } | ||
938 | func (m *Property) XXX_DiscardUnknown() { | ||
939 | xxx_messageInfo_Property.DiscardUnknown(m) | ||
940 | } | ||
941 | |||
942 | var xxx_messageInfo_Property proto.InternalMessageInfo | ||
943 | |||
944 | const Default_Property_Meaning Property_Meaning = Property_NO_MEANING | ||
945 | const Default_Property_Searchable bool = false | ||
946 | const Default_Property_Locale string = "en" | ||
947 | |||
948 | func (m *Property) GetMeaning() Property_Meaning { | ||
949 | if m != nil && m.Meaning != nil { | ||
950 | return *m.Meaning | ||
951 | } | ||
952 | return Default_Property_Meaning | ||
953 | } | ||
954 | |||
955 | func (m *Property) GetMeaningUri() string { | ||
956 | if m != nil && m.MeaningUri != nil { | ||
957 | return *m.MeaningUri | ||
958 | } | ||
959 | return "" | ||
960 | } | ||
961 | |||
962 | func (m *Property) GetName() string { | ||
963 | if m != nil && m.Name != nil { | ||
964 | return *m.Name | ||
965 | } | ||
966 | return "" | ||
967 | } | ||
968 | |||
969 | func (m *Property) GetValue() *PropertyValue { | ||
970 | if m != nil { | ||
971 | return m.Value | ||
972 | } | ||
973 | return nil | ||
974 | } | ||
975 | |||
976 | func (m *Property) GetMultiple() bool { | ||
977 | if m != nil && m.Multiple != nil { | ||
978 | return *m.Multiple | ||
979 | } | ||
980 | return false | ||
981 | } | ||
982 | |||
983 | func (m *Property) GetSearchable() bool { | ||
984 | if m != nil && m.Searchable != nil { | ||
985 | return *m.Searchable | ||
986 | } | ||
987 | return Default_Property_Searchable | ||
988 | } | ||
989 | |||
990 | func (m *Property) GetFtsTokenizationOption() Property_FtsTokenizationOption { | ||
991 | if m != nil && m.FtsTokenizationOption != nil { | ||
992 | return *m.FtsTokenizationOption | ||
993 | } | ||
994 | return Property_HTML | ||
995 | } | ||
996 | |||
997 | func (m *Property) GetLocale() string { | ||
998 | if m != nil && m.Locale != nil { | ||
999 | return *m.Locale | ||
1000 | } | ||
1001 | return Default_Property_Locale | ||
1002 | } | ||
1003 | |||
1004 | type Path struct { | ||
1005 | Element []*Path_Element `protobuf:"group,1,rep,name=Element,json=element" json:"element,omitempty"` | ||
1006 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
1007 | XXX_unrecognized []byte `json:"-"` | ||
1008 | XXX_sizecache int32 `json:"-"` | ||
1009 | } | ||
1010 | |||
1011 | func (m *Path) Reset() { *m = Path{} } | ||
1012 | func (m *Path) String() string { return proto.CompactTextString(m) } | ||
1013 | func (*Path) ProtoMessage() {} | ||
1014 | func (*Path) Descriptor() ([]byte, []int) { | ||
1015 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{3} | ||
1016 | } | ||
1017 | func (m *Path) XXX_Unmarshal(b []byte) error { | ||
1018 | return xxx_messageInfo_Path.Unmarshal(m, b) | ||
1019 | } | ||
1020 | func (m *Path) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
1021 | return xxx_messageInfo_Path.Marshal(b, m, deterministic) | ||
1022 | } | ||
1023 | func (dst *Path) XXX_Merge(src proto.Message) { | ||
1024 | xxx_messageInfo_Path.Merge(dst, src) | ||
1025 | } | ||
1026 | func (m *Path) XXX_Size() int { | ||
1027 | return xxx_messageInfo_Path.Size(m) | ||
1028 | } | ||
1029 | func (m *Path) XXX_DiscardUnknown() { | ||
1030 | xxx_messageInfo_Path.DiscardUnknown(m) | ||
1031 | } | ||
1032 | |||
1033 | var xxx_messageInfo_Path proto.InternalMessageInfo | ||
1034 | |||
1035 | func (m *Path) GetElement() []*Path_Element { | ||
1036 | if m != nil { | ||
1037 | return m.Element | ||
1038 | } | ||
1039 | return nil | ||
1040 | } | ||
1041 | |||
1042 | type Path_Element struct { | ||
1043 | Type *string `protobuf:"bytes,2,req,name=type" json:"type,omitempty"` | ||
1044 | Id *int64 `protobuf:"varint,3,opt,name=id" json:"id,omitempty"` | ||
1045 | Name *string `protobuf:"bytes,4,opt,name=name" json:"name,omitempty"` | ||
1046 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
1047 | XXX_unrecognized []byte `json:"-"` | ||
1048 | XXX_sizecache int32 `json:"-"` | ||
1049 | } | ||
1050 | |||
1051 | func (m *Path_Element) Reset() { *m = Path_Element{} } | ||
1052 | func (m *Path_Element) String() string { return proto.CompactTextString(m) } | ||
1053 | func (*Path_Element) ProtoMessage() {} | ||
1054 | func (*Path_Element) Descriptor() ([]byte, []int) { | ||
1055 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{3, 0} | ||
1056 | } | ||
1057 | func (m *Path_Element) XXX_Unmarshal(b []byte) error { | ||
1058 | return xxx_messageInfo_Path_Element.Unmarshal(m, b) | ||
1059 | } | ||
1060 | func (m *Path_Element) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
1061 | return xxx_messageInfo_Path_Element.Marshal(b, m, deterministic) | ||
1062 | } | ||
1063 | func (dst *Path_Element) XXX_Merge(src proto.Message) { | ||
1064 | xxx_messageInfo_Path_Element.Merge(dst, src) | ||
1065 | } | ||
1066 | func (m *Path_Element) XXX_Size() int { | ||
1067 | return xxx_messageInfo_Path_Element.Size(m) | ||
1068 | } | ||
1069 | func (m *Path_Element) XXX_DiscardUnknown() { | ||
1070 | xxx_messageInfo_Path_Element.DiscardUnknown(m) | ||
1071 | } | ||
1072 | |||
1073 | var xxx_messageInfo_Path_Element proto.InternalMessageInfo | ||
1074 | |||
1075 | func (m *Path_Element) GetType() string { | ||
1076 | if m != nil && m.Type != nil { | ||
1077 | return *m.Type | ||
1078 | } | ||
1079 | return "" | ||
1080 | } | ||
1081 | |||
1082 | func (m *Path_Element) GetId() int64 { | ||
1083 | if m != nil && m.Id != nil { | ||
1084 | return *m.Id | ||
1085 | } | ||
1086 | return 0 | ||
1087 | } | ||
1088 | |||
1089 | func (m *Path_Element) GetName() string { | ||
1090 | if m != nil && m.Name != nil { | ||
1091 | return *m.Name | ||
1092 | } | ||
1093 | return "" | ||
1094 | } | ||
1095 | |||
1096 | type Reference struct { | ||
1097 | App *string `protobuf:"bytes,13,req,name=app" json:"app,omitempty"` | ||
1098 | NameSpace *string `protobuf:"bytes,20,opt,name=name_space,json=nameSpace" json:"name_space,omitempty"` | ||
1099 | Path *Path `protobuf:"bytes,14,req,name=path" json:"path,omitempty"` | ||
1100 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
1101 | XXX_unrecognized []byte `json:"-"` | ||
1102 | XXX_sizecache int32 `json:"-"` | ||
1103 | } | ||
1104 | |||
1105 | func (m *Reference) Reset() { *m = Reference{} } | ||
1106 | func (m *Reference) String() string { return proto.CompactTextString(m) } | ||
1107 | func (*Reference) ProtoMessage() {} | ||
1108 | func (*Reference) Descriptor() ([]byte, []int) { | ||
1109 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{4} | ||
1110 | } | ||
1111 | func (m *Reference) XXX_Unmarshal(b []byte) error { | ||
1112 | return xxx_messageInfo_Reference.Unmarshal(m, b) | ||
1113 | } | ||
1114 | func (m *Reference) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
1115 | return xxx_messageInfo_Reference.Marshal(b, m, deterministic) | ||
1116 | } | ||
1117 | func (dst *Reference) XXX_Merge(src proto.Message) { | ||
1118 | xxx_messageInfo_Reference.Merge(dst, src) | ||
1119 | } | ||
1120 | func (m *Reference) XXX_Size() int { | ||
1121 | return xxx_messageInfo_Reference.Size(m) | ||
1122 | } | ||
1123 | func (m *Reference) XXX_DiscardUnknown() { | ||
1124 | xxx_messageInfo_Reference.DiscardUnknown(m) | ||
1125 | } | ||
1126 | |||
1127 | var xxx_messageInfo_Reference proto.InternalMessageInfo | ||
1128 | |||
1129 | func (m *Reference) GetApp() string { | ||
1130 | if m != nil && m.App != nil { | ||
1131 | return *m.App | ||
1132 | } | ||
1133 | return "" | ||
1134 | } | ||
1135 | |||
1136 | func (m *Reference) GetNameSpace() string { | ||
1137 | if m != nil && m.NameSpace != nil { | ||
1138 | return *m.NameSpace | ||
1139 | } | ||
1140 | return "" | ||
1141 | } | ||
1142 | |||
1143 | func (m *Reference) GetPath() *Path { | ||
1144 | if m != nil { | ||
1145 | return m.Path | ||
1146 | } | ||
1147 | return nil | ||
1148 | } | ||
1149 | |||
1150 | type User struct { | ||
1151 | Email *string `protobuf:"bytes,1,req,name=email" json:"email,omitempty"` | ||
1152 | AuthDomain *string `protobuf:"bytes,2,req,name=auth_domain,json=authDomain" json:"auth_domain,omitempty"` | ||
1153 | Nickname *string `protobuf:"bytes,3,opt,name=nickname" json:"nickname,omitempty"` | ||
1154 | FederatedIdentity *string `protobuf:"bytes,6,opt,name=federated_identity,json=federatedIdentity" json:"federated_identity,omitempty"` | ||
1155 | FederatedProvider *string `protobuf:"bytes,7,opt,name=federated_provider,json=federatedProvider" json:"federated_provider,omitempty"` | ||
1156 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
1157 | XXX_unrecognized []byte `json:"-"` | ||
1158 | XXX_sizecache int32 `json:"-"` | ||
1159 | } | ||
1160 | |||
1161 | func (m *User) Reset() { *m = User{} } | ||
1162 | func (m *User) String() string { return proto.CompactTextString(m) } | ||
1163 | func (*User) ProtoMessage() {} | ||
1164 | func (*User) Descriptor() ([]byte, []int) { | ||
1165 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{5} | ||
1166 | } | ||
1167 | func (m *User) XXX_Unmarshal(b []byte) error { | ||
1168 | return xxx_messageInfo_User.Unmarshal(m, b) | ||
1169 | } | ||
1170 | func (m *User) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
1171 | return xxx_messageInfo_User.Marshal(b, m, deterministic) | ||
1172 | } | ||
1173 | func (dst *User) XXX_Merge(src proto.Message) { | ||
1174 | xxx_messageInfo_User.Merge(dst, src) | ||
1175 | } | ||
1176 | func (m *User) XXX_Size() int { | ||
1177 | return xxx_messageInfo_User.Size(m) | ||
1178 | } | ||
1179 | func (m *User) XXX_DiscardUnknown() { | ||
1180 | xxx_messageInfo_User.DiscardUnknown(m) | ||
1181 | } | ||
1182 | |||
1183 | var xxx_messageInfo_User proto.InternalMessageInfo | ||
1184 | |||
1185 | func (m *User) GetEmail() string { | ||
1186 | if m != nil && m.Email != nil { | ||
1187 | return *m.Email | ||
1188 | } | ||
1189 | return "" | ||
1190 | } | ||
1191 | |||
1192 | func (m *User) GetAuthDomain() string { | ||
1193 | if m != nil && m.AuthDomain != nil { | ||
1194 | return *m.AuthDomain | ||
1195 | } | ||
1196 | return "" | ||
1197 | } | ||
1198 | |||
1199 | func (m *User) GetNickname() string { | ||
1200 | if m != nil && m.Nickname != nil { | ||
1201 | return *m.Nickname | ||
1202 | } | ||
1203 | return "" | ||
1204 | } | ||
1205 | |||
1206 | func (m *User) GetFederatedIdentity() string { | ||
1207 | if m != nil && m.FederatedIdentity != nil { | ||
1208 | return *m.FederatedIdentity | ||
1209 | } | ||
1210 | return "" | ||
1211 | } | ||
1212 | |||
1213 | func (m *User) GetFederatedProvider() string { | ||
1214 | if m != nil && m.FederatedProvider != nil { | ||
1215 | return *m.FederatedProvider | ||
1216 | } | ||
1217 | return "" | ||
1218 | } | ||
1219 | |||
1220 | type EntityProto struct { | ||
1221 | Key *Reference `protobuf:"bytes,13,req,name=key" json:"key,omitempty"` | ||
1222 | EntityGroup *Path `protobuf:"bytes,16,req,name=entity_group,json=entityGroup" json:"entity_group,omitempty"` | ||
1223 | Owner *User `protobuf:"bytes,17,opt,name=owner" json:"owner,omitempty"` | ||
1224 | Kind *EntityProto_Kind `protobuf:"varint,4,opt,name=kind,enum=appengine.EntityProto_Kind" json:"kind,omitempty"` | ||
1225 | KindUri *string `protobuf:"bytes,5,opt,name=kind_uri,json=kindUri" json:"kind_uri,omitempty"` | ||
1226 | Property []*Property `protobuf:"bytes,14,rep,name=property" json:"property,omitempty"` | ||
1227 | RawProperty []*Property `protobuf:"bytes,15,rep,name=raw_property,json=rawProperty" json:"raw_property,omitempty"` | ||
1228 | Rank *int32 `protobuf:"varint,18,opt,name=rank" json:"rank,omitempty"` | ||
1229 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
1230 | XXX_unrecognized []byte `json:"-"` | ||
1231 | XXX_sizecache int32 `json:"-"` | ||
1232 | } | ||
1233 | |||
1234 | func (m *EntityProto) Reset() { *m = EntityProto{} } | ||
1235 | func (m *EntityProto) String() string { return proto.CompactTextString(m) } | ||
1236 | func (*EntityProto) ProtoMessage() {} | ||
1237 | func (*EntityProto) Descriptor() ([]byte, []int) { | ||
1238 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{6} | ||
1239 | } | ||
1240 | func (m *EntityProto) XXX_Unmarshal(b []byte) error { | ||
1241 | return xxx_messageInfo_EntityProto.Unmarshal(m, b) | ||
1242 | } | ||
1243 | func (m *EntityProto) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
1244 | return xxx_messageInfo_EntityProto.Marshal(b, m, deterministic) | ||
1245 | } | ||
1246 | func (dst *EntityProto) XXX_Merge(src proto.Message) { | ||
1247 | xxx_messageInfo_EntityProto.Merge(dst, src) | ||
1248 | } | ||
1249 | func (m *EntityProto) XXX_Size() int { | ||
1250 | return xxx_messageInfo_EntityProto.Size(m) | ||
1251 | } | ||
1252 | func (m *EntityProto) XXX_DiscardUnknown() { | ||
1253 | xxx_messageInfo_EntityProto.DiscardUnknown(m) | ||
1254 | } | ||
1255 | |||
1256 | var xxx_messageInfo_EntityProto proto.InternalMessageInfo | ||
1257 | |||
1258 | func (m *EntityProto) GetKey() *Reference { | ||
1259 | if m != nil { | ||
1260 | return m.Key | ||
1261 | } | ||
1262 | return nil | ||
1263 | } | ||
1264 | |||
1265 | func (m *EntityProto) GetEntityGroup() *Path { | ||
1266 | if m != nil { | ||
1267 | return m.EntityGroup | ||
1268 | } | ||
1269 | return nil | ||
1270 | } | ||
1271 | |||
1272 | func (m *EntityProto) GetOwner() *User { | ||
1273 | if m != nil { | ||
1274 | return m.Owner | ||
1275 | } | ||
1276 | return nil | ||
1277 | } | ||
1278 | |||
1279 | func (m *EntityProto) GetKind() EntityProto_Kind { | ||
1280 | if m != nil && m.Kind != nil { | ||
1281 | return *m.Kind | ||
1282 | } | ||
1283 | return EntityProto_GD_CONTACT | ||
1284 | } | ||
1285 | |||
1286 | func (m *EntityProto) GetKindUri() string { | ||
1287 | if m != nil && m.KindUri != nil { | ||
1288 | return *m.KindUri | ||
1289 | } | ||
1290 | return "" | ||
1291 | } | ||
1292 | |||
1293 | func (m *EntityProto) GetProperty() []*Property { | ||
1294 | if m != nil { | ||
1295 | return m.Property | ||
1296 | } | ||
1297 | return nil | ||
1298 | } | ||
1299 | |||
1300 | func (m *EntityProto) GetRawProperty() []*Property { | ||
1301 | if m != nil { | ||
1302 | return m.RawProperty | ||
1303 | } | ||
1304 | return nil | ||
1305 | } | ||
1306 | |||
1307 | func (m *EntityProto) GetRank() int32 { | ||
1308 | if m != nil && m.Rank != nil { | ||
1309 | return *m.Rank | ||
1310 | } | ||
1311 | return 0 | ||
1312 | } | ||
1313 | |||
1314 | type CompositeProperty struct { | ||
1315 | IndexId *int64 `protobuf:"varint,1,req,name=index_id,json=indexId" json:"index_id,omitempty"` | ||
1316 | Value []string `protobuf:"bytes,2,rep,name=value" json:"value,omitempty"` | ||
1317 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
1318 | XXX_unrecognized []byte `json:"-"` | ||
1319 | XXX_sizecache int32 `json:"-"` | ||
1320 | } | ||
1321 | |||
1322 | func (m *CompositeProperty) Reset() { *m = CompositeProperty{} } | ||
1323 | func (m *CompositeProperty) String() string { return proto.CompactTextString(m) } | ||
1324 | func (*CompositeProperty) ProtoMessage() {} | ||
1325 | func (*CompositeProperty) Descriptor() ([]byte, []int) { | ||
1326 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{7} | ||
1327 | } | ||
1328 | func (m *CompositeProperty) XXX_Unmarshal(b []byte) error { | ||
1329 | return xxx_messageInfo_CompositeProperty.Unmarshal(m, b) | ||
1330 | } | ||
1331 | func (m *CompositeProperty) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
1332 | return xxx_messageInfo_CompositeProperty.Marshal(b, m, deterministic) | ||
1333 | } | ||
1334 | func (dst *CompositeProperty) XXX_Merge(src proto.Message) { | ||
1335 | xxx_messageInfo_CompositeProperty.Merge(dst, src) | ||
1336 | } | ||
1337 | func (m *CompositeProperty) XXX_Size() int { | ||
1338 | return xxx_messageInfo_CompositeProperty.Size(m) | ||
1339 | } | ||
1340 | func (m *CompositeProperty) XXX_DiscardUnknown() { | ||
1341 | xxx_messageInfo_CompositeProperty.DiscardUnknown(m) | ||
1342 | } | ||
1343 | |||
1344 | var xxx_messageInfo_CompositeProperty proto.InternalMessageInfo | ||
1345 | |||
1346 | func (m *CompositeProperty) GetIndexId() int64 { | ||
1347 | if m != nil && m.IndexId != nil { | ||
1348 | return *m.IndexId | ||
1349 | } | ||
1350 | return 0 | ||
1351 | } | ||
1352 | |||
1353 | func (m *CompositeProperty) GetValue() []string { | ||
1354 | if m != nil { | ||
1355 | return m.Value | ||
1356 | } | ||
1357 | return nil | ||
1358 | } | ||
1359 | |||
1360 | type Index struct { | ||
1361 | EntityType *string `protobuf:"bytes,1,req,name=entity_type,json=entityType" json:"entity_type,omitempty"` | ||
1362 | Ancestor *bool `protobuf:"varint,5,req,name=ancestor" json:"ancestor,omitempty"` | ||
1363 | Property []*Index_Property `protobuf:"group,2,rep,name=Property,json=property" json:"property,omitempty"` | ||
1364 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
1365 | XXX_unrecognized []byte `json:"-"` | ||
1366 | XXX_sizecache int32 `json:"-"` | ||
1367 | } | ||
1368 | |||
1369 | func (m *Index) Reset() { *m = Index{} } | ||
1370 | func (m *Index) String() string { return proto.CompactTextString(m) } | ||
1371 | func (*Index) ProtoMessage() {} | ||
1372 | func (*Index) Descriptor() ([]byte, []int) { | ||
1373 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{8} | ||
1374 | } | ||
1375 | func (m *Index) XXX_Unmarshal(b []byte) error { | ||
1376 | return xxx_messageInfo_Index.Unmarshal(m, b) | ||
1377 | } | ||
1378 | func (m *Index) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
1379 | return xxx_messageInfo_Index.Marshal(b, m, deterministic) | ||
1380 | } | ||
1381 | func (dst *Index) XXX_Merge(src proto.Message) { | ||
1382 | xxx_messageInfo_Index.Merge(dst, src) | ||
1383 | } | ||
1384 | func (m *Index) XXX_Size() int { | ||
1385 | return xxx_messageInfo_Index.Size(m) | ||
1386 | } | ||
1387 | func (m *Index) XXX_DiscardUnknown() { | ||
1388 | xxx_messageInfo_Index.DiscardUnknown(m) | ||
1389 | } | ||
1390 | |||
1391 | var xxx_messageInfo_Index proto.InternalMessageInfo | ||
1392 | |||
1393 | func (m *Index) GetEntityType() string { | ||
1394 | if m != nil && m.EntityType != nil { | ||
1395 | return *m.EntityType | ||
1396 | } | ||
1397 | return "" | ||
1398 | } | ||
1399 | |||
1400 | func (m *Index) GetAncestor() bool { | ||
1401 | if m != nil && m.Ancestor != nil { | ||
1402 | return *m.Ancestor | ||
1403 | } | ||
1404 | return false | ||
1405 | } | ||
1406 | |||
1407 | func (m *Index) GetProperty() []*Index_Property { | ||
1408 | if m != nil { | ||
1409 | return m.Property | ||
1410 | } | ||
1411 | return nil | ||
1412 | } | ||
1413 | |||
1414 | type Index_Property struct { | ||
1415 | Name *string `protobuf:"bytes,3,req,name=name" json:"name,omitempty"` | ||
1416 | Direction *Index_Property_Direction `protobuf:"varint,4,opt,name=direction,enum=appengine.Index_Property_Direction,def=1" json:"direction,omitempty"` | ||
1417 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
1418 | XXX_unrecognized []byte `json:"-"` | ||
1419 | XXX_sizecache int32 `json:"-"` | ||
1420 | } | ||
1421 | |||
1422 | func (m *Index_Property) Reset() { *m = Index_Property{} } | ||
1423 | func (m *Index_Property) String() string { return proto.CompactTextString(m) } | ||
1424 | func (*Index_Property) ProtoMessage() {} | ||
1425 | func (*Index_Property) Descriptor() ([]byte, []int) { | ||
1426 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{8, 0} | ||
1427 | } | ||
1428 | func (m *Index_Property) XXX_Unmarshal(b []byte) error { | ||
1429 | return xxx_messageInfo_Index_Property.Unmarshal(m, b) | ||
1430 | } | ||
1431 | func (m *Index_Property) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
1432 | return xxx_messageInfo_Index_Property.Marshal(b, m, deterministic) | ||
1433 | } | ||
1434 | func (dst *Index_Property) XXX_Merge(src proto.Message) { | ||
1435 | xxx_messageInfo_Index_Property.Merge(dst, src) | ||
1436 | } | ||
1437 | func (m *Index_Property) XXX_Size() int { | ||
1438 | return xxx_messageInfo_Index_Property.Size(m) | ||
1439 | } | ||
1440 | func (m *Index_Property) XXX_DiscardUnknown() { | ||
1441 | xxx_messageInfo_Index_Property.DiscardUnknown(m) | ||
1442 | } | ||
1443 | |||
1444 | var xxx_messageInfo_Index_Property proto.InternalMessageInfo | ||
1445 | |||
1446 | const Default_Index_Property_Direction Index_Property_Direction = Index_Property_ASCENDING | ||
1447 | |||
1448 | func (m *Index_Property) GetName() string { | ||
1449 | if m != nil && m.Name != nil { | ||
1450 | return *m.Name | ||
1451 | } | ||
1452 | return "" | ||
1453 | } | ||
1454 | |||
1455 | func (m *Index_Property) GetDirection() Index_Property_Direction { | ||
1456 | if m != nil && m.Direction != nil { | ||
1457 | return *m.Direction | ||
1458 | } | ||
1459 | return Default_Index_Property_Direction | ||
1460 | } | ||
1461 | |||
1462 | type CompositeIndex struct { | ||
1463 | AppId *string `protobuf:"bytes,1,req,name=app_id,json=appId" json:"app_id,omitempty"` | ||
1464 | Id *int64 `protobuf:"varint,2,req,name=id" json:"id,omitempty"` | ||
1465 | Definition *Index `protobuf:"bytes,3,req,name=definition" json:"definition,omitempty"` | ||
1466 | State *CompositeIndex_State `protobuf:"varint,4,req,name=state,enum=appengine.CompositeIndex_State" json:"state,omitempty"` | ||
1467 | OnlyUseIfRequired *bool `protobuf:"varint,6,opt,name=only_use_if_required,json=onlyUseIfRequired,def=0" json:"only_use_if_required,omitempty"` | ||
1468 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
1469 | XXX_unrecognized []byte `json:"-"` | ||
1470 | XXX_sizecache int32 `json:"-"` | ||
1471 | } | ||
1472 | |||
1473 | func (m *CompositeIndex) Reset() { *m = CompositeIndex{} } | ||
1474 | func (m *CompositeIndex) String() string { return proto.CompactTextString(m) } | ||
1475 | func (*CompositeIndex) ProtoMessage() {} | ||
1476 | func (*CompositeIndex) Descriptor() ([]byte, []int) { | ||
1477 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{9} | ||
1478 | } | ||
1479 | func (m *CompositeIndex) XXX_Unmarshal(b []byte) error { | ||
1480 | return xxx_messageInfo_CompositeIndex.Unmarshal(m, b) | ||
1481 | } | ||
1482 | func (m *CompositeIndex) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
1483 | return xxx_messageInfo_CompositeIndex.Marshal(b, m, deterministic) | ||
1484 | } | ||
1485 | func (dst *CompositeIndex) XXX_Merge(src proto.Message) { | ||
1486 | xxx_messageInfo_CompositeIndex.Merge(dst, src) | ||
1487 | } | ||
1488 | func (m *CompositeIndex) XXX_Size() int { | ||
1489 | return xxx_messageInfo_CompositeIndex.Size(m) | ||
1490 | } | ||
1491 | func (m *CompositeIndex) XXX_DiscardUnknown() { | ||
1492 | xxx_messageInfo_CompositeIndex.DiscardUnknown(m) | ||
1493 | } | ||
1494 | |||
1495 | var xxx_messageInfo_CompositeIndex proto.InternalMessageInfo | ||
1496 | |||
1497 | const Default_CompositeIndex_OnlyUseIfRequired bool = false | ||
1498 | |||
1499 | func (m *CompositeIndex) GetAppId() string { | ||
1500 | if m != nil && m.AppId != nil { | ||
1501 | return *m.AppId | ||
1502 | } | ||
1503 | return "" | ||
1504 | } | ||
1505 | |||
1506 | func (m *CompositeIndex) GetId() int64 { | ||
1507 | if m != nil && m.Id != nil { | ||
1508 | return *m.Id | ||
1509 | } | ||
1510 | return 0 | ||
1511 | } | ||
1512 | |||
1513 | func (m *CompositeIndex) GetDefinition() *Index { | ||
1514 | if m != nil { | ||
1515 | return m.Definition | ||
1516 | } | ||
1517 | return nil | ||
1518 | } | ||
1519 | |||
1520 | func (m *CompositeIndex) GetState() CompositeIndex_State { | ||
1521 | if m != nil && m.State != nil { | ||
1522 | return *m.State | ||
1523 | } | ||
1524 | return CompositeIndex_WRITE_ONLY | ||
1525 | } | ||
1526 | |||
1527 | func (m *CompositeIndex) GetOnlyUseIfRequired() bool { | ||
1528 | if m != nil && m.OnlyUseIfRequired != nil { | ||
1529 | return *m.OnlyUseIfRequired | ||
1530 | } | ||
1531 | return Default_CompositeIndex_OnlyUseIfRequired | ||
1532 | } | ||
1533 | |||
1534 | type IndexPostfix struct { | ||
1535 | IndexValue []*IndexPostfix_IndexValue `protobuf:"bytes,1,rep,name=index_value,json=indexValue" json:"index_value,omitempty"` | ||
1536 | Key *Reference `protobuf:"bytes,2,opt,name=key" json:"key,omitempty"` | ||
1537 | Before *bool `protobuf:"varint,3,opt,name=before,def=1" json:"before,omitempty"` | ||
1538 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
1539 | XXX_unrecognized []byte `json:"-"` | ||
1540 | XXX_sizecache int32 `json:"-"` | ||
1541 | } | ||
1542 | |||
1543 | func (m *IndexPostfix) Reset() { *m = IndexPostfix{} } | ||
1544 | func (m *IndexPostfix) String() string { return proto.CompactTextString(m) } | ||
1545 | func (*IndexPostfix) ProtoMessage() {} | ||
1546 | func (*IndexPostfix) Descriptor() ([]byte, []int) { | ||
1547 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{10} | ||
1548 | } | ||
1549 | func (m *IndexPostfix) XXX_Unmarshal(b []byte) error { | ||
1550 | return xxx_messageInfo_IndexPostfix.Unmarshal(m, b) | ||
1551 | } | ||
1552 | func (m *IndexPostfix) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
1553 | return xxx_messageInfo_IndexPostfix.Marshal(b, m, deterministic) | ||
1554 | } | ||
1555 | func (dst *IndexPostfix) XXX_Merge(src proto.Message) { | ||
1556 | xxx_messageInfo_IndexPostfix.Merge(dst, src) | ||
1557 | } | ||
1558 | func (m *IndexPostfix) XXX_Size() int { | ||
1559 | return xxx_messageInfo_IndexPostfix.Size(m) | ||
1560 | } | ||
1561 | func (m *IndexPostfix) XXX_DiscardUnknown() { | ||
1562 | xxx_messageInfo_IndexPostfix.DiscardUnknown(m) | ||
1563 | } | ||
1564 | |||
1565 | var xxx_messageInfo_IndexPostfix proto.InternalMessageInfo | ||
1566 | |||
1567 | const Default_IndexPostfix_Before bool = true | ||
1568 | |||
1569 | func (m *IndexPostfix) GetIndexValue() []*IndexPostfix_IndexValue { | ||
1570 | if m != nil { | ||
1571 | return m.IndexValue | ||
1572 | } | ||
1573 | return nil | ||
1574 | } | ||
1575 | |||
1576 | func (m *IndexPostfix) GetKey() *Reference { | ||
1577 | if m != nil { | ||
1578 | return m.Key | ||
1579 | } | ||
1580 | return nil | ||
1581 | } | ||
1582 | |||
1583 | func (m *IndexPostfix) GetBefore() bool { | ||
1584 | if m != nil && m.Before != nil { | ||
1585 | return *m.Before | ||
1586 | } | ||
1587 | return Default_IndexPostfix_Before | ||
1588 | } | ||
1589 | |||
1590 | type IndexPostfix_IndexValue struct { | ||
1591 | PropertyName *string `protobuf:"bytes,1,req,name=property_name,json=propertyName" json:"property_name,omitempty"` | ||
1592 | Value *PropertyValue `protobuf:"bytes,2,req,name=value" json:"value,omitempty"` | ||
1593 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
1594 | XXX_unrecognized []byte `json:"-"` | ||
1595 | XXX_sizecache int32 `json:"-"` | ||
1596 | } | ||
1597 | |||
1598 | func (m *IndexPostfix_IndexValue) Reset() { *m = IndexPostfix_IndexValue{} } | ||
1599 | func (m *IndexPostfix_IndexValue) String() string { return proto.CompactTextString(m) } | ||
1600 | func (*IndexPostfix_IndexValue) ProtoMessage() {} | ||
1601 | func (*IndexPostfix_IndexValue) Descriptor() ([]byte, []int) { | ||
1602 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{10, 0} | ||
1603 | } | ||
1604 | func (m *IndexPostfix_IndexValue) XXX_Unmarshal(b []byte) error { | ||
1605 | return xxx_messageInfo_IndexPostfix_IndexValue.Unmarshal(m, b) | ||
1606 | } | ||
1607 | func (m *IndexPostfix_IndexValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
1608 | return xxx_messageInfo_IndexPostfix_IndexValue.Marshal(b, m, deterministic) | ||
1609 | } | ||
1610 | func (dst *IndexPostfix_IndexValue) XXX_Merge(src proto.Message) { | ||
1611 | xxx_messageInfo_IndexPostfix_IndexValue.Merge(dst, src) | ||
1612 | } | ||
1613 | func (m *IndexPostfix_IndexValue) XXX_Size() int { | ||
1614 | return xxx_messageInfo_IndexPostfix_IndexValue.Size(m) | ||
1615 | } | ||
1616 | func (m *IndexPostfix_IndexValue) XXX_DiscardUnknown() { | ||
1617 | xxx_messageInfo_IndexPostfix_IndexValue.DiscardUnknown(m) | ||
1618 | } | ||
1619 | |||
1620 | var xxx_messageInfo_IndexPostfix_IndexValue proto.InternalMessageInfo | ||
1621 | |||
1622 | func (m *IndexPostfix_IndexValue) GetPropertyName() string { | ||
1623 | if m != nil && m.PropertyName != nil { | ||
1624 | return *m.PropertyName | ||
1625 | } | ||
1626 | return "" | ||
1627 | } | ||
1628 | |||
1629 | func (m *IndexPostfix_IndexValue) GetValue() *PropertyValue { | ||
1630 | if m != nil { | ||
1631 | return m.Value | ||
1632 | } | ||
1633 | return nil | ||
1634 | } | ||
1635 | |||
1636 | type IndexPosition struct { | ||
1637 | Key *string `protobuf:"bytes,1,opt,name=key" json:"key,omitempty"` | ||
1638 | Before *bool `protobuf:"varint,2,opt,name=before,def=1" json:"before,omitempty"` | ||
1639 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
1640 | XXX_unrecognized []byte `json:"-"` | ||
1641 | XXX_sizecache int32 `json:"-"` | ||
1642 | } | ||
1643 | |||
1644 | func (m *IndexPosition) Reset() { *m = IndexPosition{} } | ||
1645 | func (m *IndexPosition) String() string { return proto.CompactTextString(m) } | ||
1646 | func (*IndexPosition) ProtoMessage() {} | ||
1647 | func (*IndexPosition) Descriptor() ([]byte, []int) { | ||
1648 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{11} | ||
1649 | } | ||
1650 | func (m *IndexPosition) XXX_Unmarshal(b []byte) error { | ||
1651 | return xxx_messageInfo_IndexPosition.Unmarshal(m, b) | ||
1652 | } | ||
1653 | func (m *IndexPosition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
1654 | return xxx_messageInfo_IndexPosition.Marshal(b, m, deterministic) | ||
1655 | } | ||
1656 | func (dst *IndexPosition) XXX_Merge(src proto.Message) { | ||
1657 | xxx_messageInfo_IndexPosition.Merge(dst, src) | ||
1658 | } | ||
1659 | func (m *IndexPosition) XXX_Size() int { | ||
1660 | return xxx_messageInfo_IndexPosition.Size(m) | ||
1661 | } | ||
1662 | func (m *IndexPosition) XXX_DiscardUnknown() { | ||
1663 | xxx_messageInfo_IndexPosition.DiscardUnknown(m) | ||
1664 | } | ||
1665 | |||
1666 | var xxx_messageInfo_IndexPosition proto.InternalMessageInfo | ||
1667 | |||
1668 | const Default_IndexPosition_Before bool = true | ||
1669 | |||
1670 | func (m *IndexPosition) GetKey() string { | ||
1671 | if m != nil && m.Key != nil { | ||
1672 | return *m.Key | ||
1673 | } | ||
1674 | return "" | ||
1675 | } | ||
1676 | |||
1677 | func (m *IndexPosition) GetBefore() bool { | ||
1678 | if m != nil && m.Before != nil { | ||
1679 | return *m.Before | ||
1680 | } | ||
1681 | return Default_IndexPosition_Before | ||
1682 | } | ||
1683 | |||
1684 | type Snapshot struct { | ||
1685 | Ts *int64 `protobuf:"varint,1,req,name=ts" json:"ts,omitempty"` | ||
1686 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
1687 | XXX_unrecognized []byte `json:"-"` | ||
1688 | XXX_sizecache int32 `json:"-"` | ||
1689 | } | ||
1690 | |||
1691 | func (m *Snapshot) Reset() { *m = Snapshot{} } | ||
1692 | func (m *Snapshot) String() string { return proto.CompactTextString(m) } | ||
1693 | func (*Snapshot) ProtoMessage() {} | ||
1694 | func (*Snapshot) Descriptor() ([]byte, []int) { | ||
1695 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{12} | ||
1696 | } | ||
1697 | func (m *Snapshot) XXX_Unmarshal(b []byte) error { | ||
1698 | return xxx_messageInfo_Snapshot.Unmarshal(m, b) | ||
1699 | } | ||
1700 | func (m *Snapshot) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
1701 | return xxx_messageInfo_Snapshot.Marshal(b, m, deterministic) | ||
1702 | } | ||
1703 | func (dst *Snapshot) XXX_Merge(src proto.Message) { | ||
1704 | xxx_messageInfo_Snapshot.Merge(dst, src) | ||
1705 | } | ||
1706 | func (m *Snapshot) XXX_Size() int { | ||
1707 | return xxx_messageInfo_Snapshot.Size(m) | ||
1708 | } | ||
1709 | func (m *Snapshot) XXX_DiscardUnknown() { | ||
1710 | xxx_messageInfo_Snapshot.DiscardUnknown(m) | ||
1711 | } | ||
1712 | |||
1713 | var xxx_messageInfo_Snapshot proto.InternalMessageInfo | ||
1714 | |||
1715 | func (m *Snapshot) GetTs() int64 { | ||
1716 | if m != nil && m.Ts != nil { | ||
1717 | return *m.Ts | ||
1718 | } | ||
1719 | return 0 | ||
1720 | } | ||
1721 | |||
1722 | type InternalHeader struct { | ||
1723 | Qos *string `protobuf:"bytes,1,opt,name=qos" json:"qos,omitempty"` | ||
1724 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
1725 | XXX_unrecognized []byte `json:"-"` | ||
1726 | XXX_sizecache int32 `json:"-"` | ||
1727 | } | ||
1728 | |||
1729 | func (m *InternalHeader) Reset() { *m = InternalHeader{} } | ||
1730 | func (m *InternalHeader) String() string { return proto.CompactTextString(m) } | ||
1731 | func (*InternalHeader) ProtoMessage() {} | ||
1732 | func (*InternalHeader) Descriptor() ([]byte, []int) { | ||
1733 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{13} | ||
1734 | } | ||
1735 | func (m *InternalHeader) XXX_Unmarshal(b []byte) error { | ||
1736 | return xxx_messageInfo_InternalHeader.Unmarshal(m, b) | ||
1737 | } | ||
1738 | func (m *InternalHeader) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
1739 | return xxx_messageInfo_InternalHeader.Marshal(b, m, deterministic) | ||
1740 | } | ||
1741 | func (dst *InternalHeader) XXX_Merge(src proto.Message) { | ||
1742 | xxx_messageInfo_InternalHeader.Merge(dst, src) | ||
1743 | } | ||
1744 | func (m *InternalHeader) XXX_Size() int { | ||
1745 | return xxx_messageInfo_InternalHeader.Size(m) | ||
1746 | } | ||
1747 | func (m *InternalHeader) XXX_DiscardUnknown() { | ||
1748 | xxx_messageInfo_InternalHeader.DiscardUnknown(m) | ||
1749 | } | ||
1750 | |||
1751 | var xxx_messageInfo_InternalHeader proto.InternalMessageInfo | ||
1752 | |||
1753 | func (m *InternalHeader) GetQos() string { | ||
1754 | if m != nil && m.Qos != nil { | ||
1755 | return *m.Qos | ||
1756 | } | ||
1757 | return "" | ||
1758 | } | ||
1759 | |||
1760 | type Transaction struct { | ||
1761 | Header *InternalHeader `protobuf:"bytes,4,opt,name=header" json:"header,omitempty"` | ||
1762 | Handle *uint64 `protobuf:"fixed64,1,req,name=handle" json:"handle,omitempty"` | ||
1763 | App *string `protobuf:"bytes,2,req,name=app" json:"app,omitempty"` | ||
1764 | MarkChanges *bool `protobuf:"varint,3,opt,name=mark_changes,json=markChanges,def=0" json:"mark_changes,omitempty"` | ||
1765 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
1766 | XXX_unrecognized []byte `json:"-"` | ||
1767 | XXX_sizecache int32 `json:"-"` | ||
1768 | } | ||
1769 | |||
1770 | func (m *Transaction) Reset() { *m = Transaction{} } | ||
1771 | func (m *Transaction) String() string { return proto.CompactTextString(m) } | ||
1772 | func (*Transaction) ProtoMessage() {} | ||
1773 | func (*Transaction) Descriptor() ([]byte, []int) { | ||
1774 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{14} | ||
1775 | } | ||
1776 | func (m *Transaction) XXX_Unmarshal(b []byte) error { | ||
1777 | return xxx_messageInfo_Transaction.Unmarshal(m, b) | ||
1778 | } | ||
1779 | func (m *Transaction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
1780 | return xxx_messageInfo_Transaction.Marshal(b, m, deterministic) | ||
1781 | } | ||
1782 | func (dst *Transaction) XXX_Merge(src proto.Message) { | ||
1783 | xxx_messageInfo_Transaction.Merge(dst, src) | ||
1784 | } | ||
1785 | func (m *Transaction) XXX_Size() int { | ||
1786 | return xxx_messageInfo_Transaction.Size(m) | ||
1787 | } | ||
1788 | func (m *Transaction) XXX_DiscardUnknown() { | ||
1789 | xxx_messageInfo_Transaction.DiscardUnknown(m) | ||
1790 | } | ||
1791 | |||
1792 | var xxx_messageInfo_Transaction proto.InternalMessageInfo | ||
1793 | |||
1794 | const Default_Transaction_MarkChanges bool = false | ||
1795 | |||
1796 | func (m *Transaction) GetHeader() *InternalHeader { | ||
1797 | if m != nil { | ||
1798 | return m.Header | ||
1799 | } | ||
1800 | return nil | ||
1801 | } | ||
1802 | |||
1803 | func (m *Transaction) GetHandle() uint64 { | ||
1804 | if m != nil && m.Handle != nil { | ||
1805 | return *m.Handle | ||
1806 | } | ||
1807 | return 0 | ||
1808 | } | ||
1809 | |||
1810 | func (m *Transaction) GetApp() string { | ||
1811 | if m != nil && m.App != nil { | ||
1812 | return *m.App | ||
1813 | } | ||
1814 | return "" | ||
1815 | } | ||
1816 | |||
1817 | func (m *Transaction) GetMarkChanges() bool { | ||
1818 | if m != nil && m.MarkChanges != nil { | ||
1819 | return *m.MarkChanges | ||
1820 | } | ||
1821 | return Default_Transaction_MarkChanges | ||
1822 | } | ||
1823 | |||
1824 | type Query struct { | ||
1825 | Header *InternalHeader `protobuf:"bytes,39,opt,name=header" json:"header,omitempty"` | ||
1826 | App *string `protobuf:"bytes,1,req,name=app" json:"app,omitempty"` | ||
1827 | NameSpace *string `protobuf:"bytes,29,opt,name=name_space,json=nameSpace" json:"name_space,omitempty"` | ||
1828 | Kind *string `protobuf:"bytes,3,opt,name=kind" json:"kind,omitempty"` | ||
1829 | Ancestor *Reference `protobuf:"bytes,17,opt,name=ancestor" json:"ancestor,omitempty"` | ||
1830 | Filter []*Query_Filter `protobuf:"group,4,rep,name=Filter,json=filter" json:"filter,omitempty"` | ||
1831 | SearchQuery *string `protobuf:"bytes,8,opt,name=search_query,json=searchQuery" json:"search_query,omitempty"` | ||
1832 | Order []*Query_Order `protobuf:"group,9,rep,name=Order,json=order" json:"order,omitempty"` | ||
1833 | Hint *Query_Hint `protobuf:"varint,18,opt,name=hint,enum=appengine.Query_Hint" json:"hint,omitempty"` | ||
1834 | Count *int32 `protobuf:"varint,23,opt,name=count" json:"count,omitempty"` | ||
1835 | Offset *int32 `protobuf:"varint,12,opt,name=offset,def=0" json:"offset,omitempty"` | ||
1836 | Limit *int32 `protobuf:"varint,16,opt,name=limit" json:"limit,omitempty"` | ||
1837 | CompiledCursor *CompiledCursor `protobuf:"bytes,30,opt,name=compiled_cursor,json=compiledCursor" json:"compiled_cursor,omitempty"` | ||
1838 | EndCompiledCursor *CompiledCursor `protobuf:"bytes,31,opt,name=end_compiled_cursor,json=endCompiledCursor" json:"end_compiled_cursor,omitempty"` | ||
1839 | CompositeIndex []*CompositeIndex `protobuf:"bytes,19,rep,name=composite_index,json=compositeIndex" json:"composite_index,omitempty"` | ||
1840 | RequirePerfectPlan *bool `protobuf:"varint,20,opt,name=require_perfect_plan,json=requirePerfectPlan,def=0" json:"require_perfect_plan,omitempty"` | ||
1841 | KeysOnly *bool `protobuf:"varint,21,opt,name=keys_only,json=keysOnly,def=0" json:"keys_only,omitempty"` | ||
1842 | Transaction *Transaction `protobuf:"bytes,22,opt,name=transaction" json:"transaction,omitempty"` | ||
1843 | Compile *bool `protobuf:"varint,25,opt,name=compile,def=0" json:"compile,omitempty"` | ||
1844 | FailoverMs *int64 `protobuf:"varint,26,opt,name=failover_ms,json=failoverMs" json:"failover_ms,omitempty"` | ||
1845 | Strong *bool `protobuf:"varint,32,opt,name=strong" json:"strong,omitempty"` | ||
1846 | PropertyName []string `protobuf:"bytes,33,rep,name=property_name,json=propertyName" json:"property_name,omitempty"` | ||
1847 | GroupByPropertyName []string `protobuf:"bytes,34,rep,name=group_by_property_name,json=groupByPropertyName" json:"group_by_property_name,omitempty"` | ||
1848 | Distinct *bool `protobuf:"varint,24,opt,name=distinct" json:"distinct,omitempty"` | ||
1849 | MinSafeTimeSeconds *int64 `protobuf:"varint,35,opt,name=min_safe_time_seconds,json=minSafeTimeSeconds" json:"min_safe_time_seconds,omitempty"` | ||
1850 | SafeReplicaName []string `protobuf:"bytes,36,rep,name=safe_replica_name,json=safeReplicaName" json:"safe_replica_name,omitempty"` | ||
1851 | PersistOffset *bool `protobuf:"varint,37,opt,name=persist_offset,json=persistOffset,def=0" json:"persist_offset,omitempty"` | ||
1852 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
1853 | XXX_unrecognized []byte `json:"-"` | ||
1854 | XXX_sizecache int32 `json:"-"` | ||
1855 | } | ||
1856 | |||
1857 | func (m *Query) Reset() { *m = Query{} } | ||
1858 | func (m *Query) String() string { return proto.CompactTextString(m) } | ||
1859 | func (*Query) ProtoMessage() {} | ||
1860 | func (*Query) Descriptor() ([]byte, []int) { | ||
1861 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{15} | ||
1862 | } | ||
1863 | func (m *Query) XXX_Unmarshal(b []byte) error { | ||
1864 | return xxx_messageInfo_Query.Unmarshal(m, b) | ||
1865 | } | ||
1866 | func (m *Query) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
1867 | return xxx_messageInfo_Query.Marshal(b, m, deterministic) | ||
1868 | } | ||
1869 | func (dst *Query) XXX_Merge(src proto.Message) { | ||
1870 | xxx_messageInfo_Query.Merge(dst, src) | ||
1871 | } | ||
1872 | func (m *Query) XXX_Size() int { | ||
1873 | return xxx_messageInfo_Query.Size(m) | ||
1874 | } | ||
1875 | func (m *Query) XXX_DiscardUnknown() { | ||
1876 | xxx_messageInfo_Query.DiscardUnknown(m) | ||
1877 | } | ||
1878 | |||
1879 | var xxx_messageInfo_Query proto.InternalMessageInfo | ||
1880 | |||
1881 | const Default_Query_Offset int32 = 0 | ||
1882 | const Default_Query_RequirePerfectPlan bool = false | ||
1883 | const Default_Query_KeysOnly bool = false | ||
1884 | const Default_Query_Compile bool = false | ||
1885 | const Default_Query_PersistOffset bool = false | ||
1886 | |||
1887 | func (m *Query) GetHeader() *InternalHeader { | ||
1888 | if m != nil { | ||
1889 | return m.Header | ||
1890 | } | ||
1891 | return nil | ||
1892 | } | ||
1893 | |||
1894 | func (m *Query) GetApp() string { | ||
1895 | if m != nil && m.App != nil { | ||
1896 | return *m.App | ||
1897 | } | ||
1898 | return "" | ||
1899 | } | ||
1900 | |||
1901 | func (m *Query) GetNameSpace() string { | ||
1902 | if m != nil && m.NameSpace != nil { | ||
1903 | return *m.NameSpace | ||
1904 | } | ||
1905 | return "" | ||
1906 | } | ||
1907 | |||
1908 | func (m *Query) GetKind() string { | ||
1909 | if m != nil && m.Kind != nil { | ||
1910 | return *m.Kind | ||
1911 | } | ||
1912 | return "" | ||
1913 | } | ||
1914 | |||
1915 | func (m *Query) GetAncestor() *Reference { | ||
1916 | if m != nil { | ||
1917 | return m.Ancestor | ||
1918 | } | ||
1919 | return nil | ||
1920 | } | ||
1921 | |||
1922 | func (m *Query) GetFilter() []*Query_Filter { | ||
1923 | if m != nil { | ||
1924 | return m.Filter | ||
1925 | } | ||
1926 | return nil | ||
1927 | } | ||
1928 | |||
1929 | func (m *Query) GetSearchQuery() string { | ||
1930 | if m != nil && m.SearchQuery != nil { | ||
1931 | return *m.SearchQuery | ||
1932 | } | ||
1933 | return "" | ||
1934 | } | ||
1935 | |||
1936 | func (m *Query) GetOrder() []*Query_Order { | ||
1937 | if m != nil { | ||
1938 | return m.Order | ||
1939 | } | ||
1940 | return nil | ||
1941 | } | ||
1942 | |||
1943 | func (m *Query) GetHint() Query_Hint { | ||
1944 | if m != nil && m.Hint != nil { | ||
1945 | return *m.Hint | ||
1946 | } | ||
1947 | return Query_ORDER_FIRST | ||
1948 | } | ||
1949 | |||
1950 | func (m *Query) GetCount() int32 { | ||
1951 | if m != nil && m.Count != nil { | ||
1952 | return *m.Count | ||
1953 | } | ||
1954 | return 0 | ||
1955 | } | ||
1956 | |||
1957 | func (m *Query) GetOffset() int32 { | ||
1958 | if m != nil && m.Offset != nil { | ||
1959 | return *m.Offset | ||
1960 | } | ||
1961 | return Default_Query_Offset | ||
1962 | } | ||
1963 | |||
1964 | func (m *Query) GetLimit() int32 { | ||
1965 | if m != nil && m.Limit != nil { | ||
1966 | return *m.Limit | ||
1967 | } | ||
1968 | return 0 | ||
1969 | } | ||
1970 | |||
1971 | func (m *Query) GetCompiledCursor() *CompiledCursor { | ||
1972 | if m != nil { | ||
1973 | return m.CompiledCursor | ||
1974 | } | ||
1975 | return nil | ||
1976 | } | ||
1977 | |||
1978 | func (m *Query) GetEndCompiledCursor() *CompiledCursor { | ||
1979 | if m != nil { | ||
1980 | return m.EndCompiledCursor | ||
1981 | } | ||
1982 | return nil | ||
1983 | } | ||
1984 | |||
1985 | func (m *Query) GetCompositeIndex() []*CompositeIndex { | ||
1986 | if m != nil { | ||
1987 | return m.CompositeIndex | ||
1988 | } | ||
1989 | return nil | ||
1990 | } | ||
1991 | |||
1992 | func (m *Query) GetRequirePerfectPlan() bool { | ||
1993 | if m != nil && m.RequirePerfectPlan != nil { | ||
1994 | return *m.RequirePerfectPlan | ||
1995 | } | ||
1996 | return Default_Query_RequirePerfectPlan | ||
1997 | } | ||
1998 | |||
1999 | func (m *Query) GetKeysOnly() bool { | ||
2000 | if m != nil && m.KeysOnly != nil { | ||
2001 | return *m.KeysOnly | ||
2002 | } | ||
2003 | return Default_Query_KeysOnly | ||
2004 | } | ||
2005 | |||
2006 | func (m *Query) GetTransaction() *Transaction { | ||
2007 | if m != nil { | ||
2008 | return m.Transaction | ||
2009 | } | ||
2010 | return nil | ||
2011 | } | ||
2012 | |||
2013 | func (m *Query) GetCompile() bool { | ||
2014 | if m != nil && m.Compile != nil { | ||
2015 | return *m.Compile | ||
2016 | } | ||
2017 | return Default_Query_Compile | ||
2018 | } | ||
2019 | |||
2020 | func (m *Query) GetFailoverMs() int64 { | ||
2021 | if m != nil && m.FailoverMs != nil { | ||
2022 | return *m.FailoverMs | ||
2023 | } | ||
2024 | return 0 | ||
2025 | } | ||
2026 | |||
2027 | func (m *Query) GetStrong() bool { | ||
2028 | if m != nil && m.Strong != nil { | ||
2029 | return *m.Strong | ||
2030 | } | ||
2031 | return false | ||
2032 | } | ||
2033 | |||
2034 | func (m *Query) GetPropertyName() []string { | ||
2035 | if m != nil { | ||
2036 | return m.PropertyName | ||
2037 | } | ||
2038 | return nil | ||
2039 | } | ||
2040 | |||
2041 | func (m *Query) GetGroupByPropertyName() []string { | ||
2042 | if m != nil { | ||
2043 | return m.GroupByPropertyName | ||
2044 | } | ||
2045 | return nil | ||
2046 | } | ||
2047 | |||
2048 | func (m *Query) GetDistinct() bool { | ||
2049 | if m != nil && m.Distinct != nil { | ||
2050 | return *m.Distinct | ||
2051 | } | ||
2052 | return false | ||
2053 | } | ||
2054 | |||
2055 | func (m *Query) GetMinSafeTimeSeconds() int64 { | ||
2056 | if m != nil && m.MinSafeTimeSeconds != nil { | ||
2057 | return *m.MinSafeTimeSeconds | ||
2058 | } | ||
2059 | return 0 | ||
2060 | } | ||
2061 | |||
2062 | func (m *Query) GetSafeReplicaName() []string { | ||
2063 | if m != nil { | ||
2064 | return m.SafeReplicaName | ||
2065 | } | ||
2066 | return nil | ||
2067 | } | ||
2068 | |||
2069 | func (m *Query) GetPersistOffset() bool { | ||
2070 | if m != nil && m.PersistOffset != nil { | ||
2071 | return *m.PersistOffset | ||
2072 | } | ||
2073 | return Default_Query_PersistOffset | ||
2074 | } | ||
2075 | |||
2076 | type Query_Filter struct { | ||
2077 | Op *Query_Filter_Operator `protobuf:"varint,6,req,name=op,enum=appengine.Query_Filter_Operator" json:"op,omitempty"` | ||
2078 | Property []*Property `protobuf:"bytes,14,rep,name=property" json:"property,omitempty"` | ||
2079 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
2080 | XXX_unrecognized []byte `json:"-"` | ||
2081 | XXX_sizecache int32 `json:"-"` | ||
2082 | } | ||
2083 | |||
2084 | func (m *Query_Filter) Reset() { *m = Query_Filter{} } | ||
2085 | func (m *Query_Filter) String() string { return proto.CompactTextString(m) } | ||
2086 | func (*Query_Filter) ProtoMessage() {} | ||
2087 | func (*Query_Filter) Descriptor() ([]byte, []int) { | ||
2088 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{15, 0} | ||
2089 | } | ||
2090 | func (m *Query_Filter) XXX_Unmarshal(b []byte) error { | ||
2091 | return xxx_messageInfo_Query_Filter.Unmarshal(m, b) | ||
2092 | } | ||
2093 | func (m *Query_Filter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
2094 | return xxx_messageInfo_Query_Filter.Marshal(b, m, deterministic) | ||
2095 | } | ||
2096 | func (dst *Query_Filter) XXX_Merge(src proto.Message) { | ||
2097 | xxx_messageInfo_Query_Filter.Merge(dst, src) | ||
2098 | } | ||
2099 | func (m *Query_Filter) XXX_Size() int { | ||
2100 | return xxx_messageInfo_Query_Filter.Size(m) | ||
2101 | } | ||
2102 | func (m *Query_Filter) XXX_DiscardUnknown() { | ||
2103 | xxx_messageInfo_Query_Filter.DiscardUnknown(m) | ||
2104 | } | ||
2105 | |||
2106 | var xxx_messageInfo_Query_Filter proto.InternalMessageInfo | ||
2107 | |||
2108 | func (m *Query_Filter) GetOp() Query_Filter_Operator { | ||
2109 | if m != nil && m.Op != nil { | ||
2110 | return *m.Op | ||
2111 | } | ||
2112 | return Query_Filter_LESS_THAN | ||
2113 | } | ||
2114 | |||
2115 | func (m *Query_Filter) GetProperty() []*Property { | ||
2116 | if m != nil { | ||
2117 | return m.Property | ||
2118 | } | ||
2119 | return nil | ||
2120 | } | ||
2121 | |||
2122 | type Query_Order struct { | ||
2123 | Property *string `protobuf:"bytes,10,req,name=property" json:"property,omitempty"` | ||
2124 | Direction *Query_Order_Direction `protobuf:"varint,11,opt,name=direction,enum=appengine.Query_Order_Direction,def=1" json:"direction,omitempty"` | ||
2125 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
2126 | XXX_unrecognized []byte `json:"-"` | ||
2127 | XXX_sizecache int32 `json:"-"` | ||
2128 | } | ||
2129 | |||
2130 | func (m *Query_Order) Reset() { *m = Query_Order{} } | ||
2131 | func (m *Query_Order) String() string { return proto.CompactTextString(m) } | ||
2132 | func (*Query_Order) ProtoMessage() {} | ||
2133 | func (*Query_Order) Descriptor() ([]byte, []int) { | ||
2134 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{15, 1} | ||
2135 | } | ||
2136 | func (m *Query_Order) XXX_Unmarshal(b []byte) error { | ||
2137 | return xxx_messageInfo_Query_Order.Unmarshal(m, b) | ||
2138 | } | ||
2139 | func (m *Query_Order) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
2140 | return xxx_messageInfo_Query_Order.Marshal(b, m, deterministic) | ||
2141 | } | ||
2142 | func (dst *Query_Order) XXX_Merge(src proto.Message) { | ||
2143 | xxx_messageInfo_Query_Order.Merge(dst, src) | ||
2144 | } | ||
2145 | func (m *Query_Order) XXX_Size() int { | ||
2146 | return xxx_messageInfo_Query_Order.Size(m) | ||
2147 | } | ||
2148 | func (m *Query_Order) XXX_DiscardUnknown() { | ||
2149 | xxx_messageInfo_Query_Order.DiscardUnknown(m) | ||
2150 | } | ||
2151 | |||
2152 | var xxx_messageInfo_Query_Order proto.InternalMessageInfo | ||
2153 | |||
2154 | const Default_Query_Order_Direction Query_Order_Direction = Query_Order_ASCENDING | ||
2155 | |||
2156 | func (m *Query_Order) GetProperty() string { | ||
2157 | if m != nil && m.Property != nil { | ||
2158 | return *m.Property | ||
2159 | } | ||
2160 | return "" | ||
2161 | } | ||
2162 | |||
2163 | func (m *Query_Order) GetDirection() Query_Order_Direction { | ||
2164 | if m != nil && m.Direction != nil { | ||
2165 | return *m.Direction | ||
2166 | } | ||
2167 | return Default_Query_Order_Direction | ||
2168 | } | ||
2169 | |||
2170 | type CompiledQuery struct { | ||
2171 | Primaryscan *CompiledQuery_PrimaryScan `protobuf:"group,1,req,name=PrimaryScan,json=primaryscan" json:"primaryscan,omitempty"` | ||
2172 | Mergejoinscan []*CompiledQuery_MergeJoinScan `protobuf:"group,7,rep,name=MergeJoinScan,json=mergejoinscan" json:"mergejoinscan,omitempty"` | ||
2173 | IndexDef *Index `protobuf:"bytes,21,opt,name=index_def,json=indexDef" json:"index_def,omitempty"` | ||
2174 | Offset *int32 `protobuf:"varint,10,opt,name=offset,def=0" json:"offset,omitempty"` | ||
2175 | Limit *int32 `protobuf:"varint,11,opt,name=limit" json:"limit,omitempty"` | ||
2176 | KeysOnly *bool `protobuf:"varint,12,req,name=keys_only,json=keysOnly" json:"keys_only,omitempty"` | ||
2177 | PropertyName []string `protobuf:"bytes,24,rep,name=property_name,json=propertyName" json:"property_name,omitempty"` | ||
2178 | DistinctInfixSize *int32 `protobuf:"varint,25,opt,name=distinct_infix_size,json=distinctInfixSize" json:"distinct_infix_size,omitempty"` | ||
2179 | Entityfilter *CompiledQuery_EntityFilter `protobuf:"group,13,opt,name=EntityFilter,json=entityfilter" json:"entityfilter,omitempty"` | ||
2180 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
2181 | XXX_unrecognized []byte `json:"-"` | ||
2182 | XXX_sizecache int32 `json:"-"` | ||
2183 | } | ||
2184 | |||
2185 | func (m *CompiledQuery) Reset() { *m = CompiledQuery{} } | ||
2186 | func (m *CompiledQuery) String() string { return proto.CompactTextString(m) } | ||
2187 | func (*CompiledQuery) ProtoMessage() {} | ||
2188 | func (*CompiledQuery) Descriptor() ([]byte, []int) { | ||
2189 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{16} | ||
2190 | } | ||
2191 | func (m *CompiledQuery) XXX_Unmarshal(b []byte) error { | ||
2192 | return xxx_messageInfo_CompiledQuery.Unmarshal(m, b) | ||
2193 | } | ||
2194 | func (m *CompiledQuery) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
2195 | return xxx_messageInfo_CompiledQuery.Marshal(b, m, deterministic) | ||
2196 | } | ||
2197 | func (dst *CompiledQuery) XXX_Merge(src proto.Message) { | ||
2198 | xxx_messageInfo_CompiledQuery.Merge(dst, src) | ||
2199 | } | ||
2200 | func (m *CompiledQuery) XXX_Size() int { | ||
2201 | return xxx_messageInfo_CompiledQuery.Size(m) | ||
2202 | } | ||
2203 | func (m *CompiledQuery) XXX_DiscardUnknown() { | ||
2204 | xxx_messageInfo_CompiledQuery.DiscardUnknown(m) | ||
2205 | } | ||
2206 | |||
2207 | var xxx_messageInfo_CompiledQuery proto.InternalMessageInfo | ||
2208 | |||
2209 | const Default_CompiledQuery_Offset int32 = 0 | ||
2210 | |||
2211 | func (m *CompiledQuery) GetPrimaryscan() *CompiledQuery_PrimaryScan { | ||
2212 | if m != nil { | ||
2213 | return m.Primaryscan | ||
2214 | } | ||
2215 | return nil | ||
2216 | } | ||
2217 | |||
2218 | func (m *CompiledQuery) GetMergejoinscan() []*CompiledQuery_MergeJoinScan { | ||
2219 | if m != nil { | ||
2220 | return m.Mergejoinscan | ||
2221 | } | ||
2222 | return nil | ||
2223 | } | ||
2224 | |||
2225 | func (m *CompiledQuery) GetIndexDef() *Index { | ||
2226 | if m != nil { | ||
2227 | return m.IndexDef | ||
2228 | } | ||
2229 | return nil | ||
2230 | } | ||
2231 | |||
2232 | func (m *CompiledQuery) GetOffset() int32 { | ||
2233 | if m != nil && m.Offset != nil { | ||
2234 | return *m.Offset | ||
2235 | } | ||
2236 | return Default_CompiledQuery_Offset | ||
2237 | } | ||
2238 | |||
2239 | func (m *CompiledQuery) GetLimit() int32 { | ||
2240 | if m != nil && m.Limit != nil { | ||
2241 | return *m.Limit | ||
2242 | } | ||
2243 | return 0 | ||
2244 | } | ||
2245 | |||
2246 | func (m *CompiledQuery) GetKeysOnly() bool { | ||
2247 | if m != nil && m.KeysOnly != nil { | ||
2248 | return *m.KeysOnly | ||
2249 | } | ||
2250 | return false | ||
2251 | } | ||
2252 | |||
2253 | func (m *CompiledQuery) GetPropertyName() []string { | ||
2254 | if m != nil { | ||
2255 | return m.PropertyName | ||
2256 | } | ||
2257 | return nil | ||
2258 | } | ||
2259 | |||
2260 | func (m *CompiledQuery) GetDistinctInfixSize() int32 { | ||
2261 | if m != nil && m.DistinctInfixSize != nil { | ||
2262 | return *m.DistinctInfixSize | ||
2263 | } | ||
2264 | return 0 | ||
2265 | } | ||
2266 | |||
2267 | func (m *CompiledQuery) GetEntityfilter() *CompiledQuery_EntityFilter { | ||
2268 | if m != nil { | ||
2269 | return m.Entityfilter | ||
2270 | } | ||
2271 | return nil | ||
2272 | } | ||
2273 | |||
2274 | type CompiledQuery_PrimaryScan struct { | ||
2275 | IndexName *string `protobuf:"bytes,2,opt,name=index_name,json=indexName" json:"index_name,omitempty"` | ||
2276 | StartKey *string `protobuf:"bytes,3,opt,name=start_key,json=startKey" json:"start_key,omitempty"` | ||
2277 | StartInclusive *bool `protobuf:"varint,4,opt,name=start_inclusive,json=startInclusive" json:"start_inclusive,omitempty"` | ||
2278 | EndKey *string `protobuf:"bytes,5,opt,name=end_key,json=endKey" json:"end_key,omitempty"` | ||
2279 | EndInclusive *bool `protobuf:"varint,6,opt,name=end_inclusive,json=endInclusive" json:"end_inclusive,omitempty"` | ||
2280 | StartPostfixValue []string `protobuf:"bytes,22,rep,name=start_postfix_value,json=startPostfixValue" json:"start_postfix_value,omitempty"` | ||
2281 | EndPostfixValue []string `protobuf:"bytes,23,rep,name=end_postfix_value,json=endPostfixValue" json:"end_postfix_value,omitempty"` | ||
2282 | EndUnappliedLogTimestampUs *int64 `protobuf:"varint,19,opt,name=end_unapplied_log_timestamp_us,json=endUnappliedLogTimestampUs" json:"end_unapplied_log_timestamp_us,omitempty"` | ||
2283 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
2284 | XXX_unrecognized []byte `json:"-"` | ||
2285 | XXX_sizecache int32 `json:"-"` | ||
2286 | } | ||
2287 | |||
2288 | func (m *CompiledQuery_PrimaryScan) Reset() { *m = CompiledQuery_PrimaryScan{} } | ||
2289 | func (m *CompiledQuery_PrimaryScan) String() string { return proto.CompactTextString(m) } | ||
2290 | func (*CompiledQuery_PrimaryScan) ProtoMessage() {} | ||
2291 | func (*CompiledQuery_PrimaryScan) Descriptor() ([]byte, []int) { | ||
2292 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{16, 0} | ||
2293 | } | ||
2294 | func (m *CompiledQuery_PrimaryScan) XXX_Unmarshal(b []byte) error { | ||
2295 | return xxx_messageInfo_CompiledQuery_PrimaryScan.Unmarshal(m, b) | ||
2296 | } | ||
2297 | func (m *CompiledQuery_PrimaryScan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
2298 | return xxx_messageInfo_CompiledQuery_PrimaryScan.Marshal(b, m, deterministic) | ||
2299 | } | ||
2300 | func (dst *CompiledQuery_PrimaryScan) XXX_Merge(src proto.Message) { | ||
2301 | xxx_messageInfo_CompiledQuery_PrimaryScan.Merge(dst, src) | ||
2302 | } | ||
2303 | func (m *CompiledQuery_PrimaryScan) XXX_Size() int { | ||
2304 | return xxx_messageInfo_CompiledQuery_PrimaryScan.Size(m) | ||
2305 | } | ||
2306 | func (m *CompiledQuery_PrimaryScan) XXX_DiscardUnknown() { | ||
2307 | xxx_messageInfo_CompiledQuery_PrimaryScan.DiscardUnknown(m) | ||
2308 | } | ||
2309 | |||
2310 | var xxx_messageInfo_CompiledQuery_PrimaryScan proto.InternalMessageInfo | ||
2311 | |||
2312 | func (m *CompiledQuery_PrimaryScan) GetIndexName() string { | ||
2313 | if m != nil && m.IndexName != nil { | ||
2314 | return *m.IndexName | ||
2315 | } | ||
2316 | return "" | ||
2317 | } | ||
2318 | |||
2319 | func (m *CompiledQuery_PrimaryScan) GetStartKey() string { | ||
2320 | if m != nil && m.StartKey != nil { | ||
2321 | return *m.StartKey | ||
2322 | } | ||
2323 | return "" | ||
2324 | } | ||
2325 | |||
2326 | func (m *CompiledQuery_PrimaryScan) GetStartInclusive() bool { | ||
2327 | if m != nil && m.StartInclusive != nil { | ||
2328 | return *m.StartInclusive | ||
2329 | } | ||
2330 | return false | ||
2331 | } | ||
2332 | |||
2333 | func (m *CompiledQuery_PrimaryScan) GetEndKey() string { | ||
2334 | if m != nil && m.EndKey != nil { | ||
2335 | return *m.EndKey | ||
2336 | } | ||
2337 | return "" | ||
2338 | } | ||
2339 | |||
2340 | func (m *CompiledQuery_PrimaryScan) GetEndInclusive() bool { | ||
2341 | if m != nil && m.EndInclusive != nil { | ||
2342 | return *m.EndInclusive | ||
2343 | } | ||
2344 | return false | ||
2345 | } | ||
2346 | |||
2347 | func (m *CompiledQuery_PrimaryScan) GetStartPostfixValue() []string { | ||
2348 | if m != nil { | ||
2349 | return m.StartPostfixValue | ||
2350 | } | ||
2351 | return nil | ||
2352 | } | ||
2353 | |||
2354 | func (m *CompiledQuery_PrimaryScan) GetEndPostfixValue() []string { | ||
2355 | if m != nil { | ||
2356 | return m.EndPostfixValue | ||
2357 | } | ||
2358 | return nil | ||
2359 | } | ||
2360 | |||
2361 | func (m *CompiledQuery_PrimaryScan) GetEndUnappliedLogTimestampUs() int64 { | ||
2362 | if m != nil && m.EndUnappliedLogTimestampUs != nil { | ||
2363 | return *m.EndUnappliedLogTimestampUs | ||
2364 | } | ||
2365 | return 0 | ||
2366 | } | ||
2367 | |||
2368 | type CompiledQuery_MergeJoinScan struct { | ||
2369 | IndexName *string `protobuf:"bytes,8,req,name=index_name,json=indexName" json:"index_name,omitempty"` | ||
2370 | PrefixValue []string `protobuf:"bytes,9,rep,name=prefix_value,json=prefixValue" json:"prefix_value,omitempty"` | ||
2371 | ValuePrefix *bool `protobuf:"varint,20,opt,name=value_prefix,json=valuePrefix,def=0" json:"value_prefix,omitempty"` | ||
2372 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
2373 | XXX_unrecognized []byte `json:"-"` | ||
2374 | XXX_sizecache int32 `json:"-"` | ||
2375 | } | ||
2376 | |||
2377 | func (m *CompiledQuery_MergeJoinScan) Reset() { *m = CompiledQuery_MergeJoinScan{} } | ||
2378 | func (m *CompiledQuery_MergeJoinScan) String() string { return proto.CompactTextString(m) } | ||
2379 | func (*CompiledQuery_MergeJoinScan) ProtoMessage() {} | ||
2380 | func (*CompiledQuery_MergeJoinScan) Descriptor() ([]byte, []int) { | ||
2381 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{16, 1} | ||
2382 | } | ||
2383 | func (m *CompiledQuery_MergeJoinScan) XXX_Unmarshal(b []byte) error { | ||
2384 | return xxx_messageInfo_CompiledQuery_MergeJoinScan.Unmarshal(m, b) | ||
2385 | } | ||
2386 | func (m *CompiledQuery_MergeJoinScan) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
2387 | return xxx_messageInfo_CompiledQuery_MergeJoinScan.Marshal(b, m, deterministic) | ||
2388 | } | ||
2389 | func (dst *CompiledQuery_MergeJoinScan) XXX_Merge(src proto.Message) { | ||
2390 | xxx_messageInfo_CompiledQuery_MergeJoinScan.Merge(dst, src) | ||
2391 | } | ||
2392 | func (m *CompiledQuery_MergeJoinScan) XXX_Size() int { | ||
2393 | return xxx_messageInfo_CompiledQuery_MergeJoinScan.Size(m) | ||
2394 | } | ||
2395 | func (m *CompiledQuery_MergeJoinScan) XXX_DiscardUnknown() { | ||
2396 | xxx_messageInfo_CompiledQuery_MergeJoinScan.DiscardUnknown(m) | ||
2397 | } | ||
2398 | |||
2399 | var xxx_messageInfo_CompiledQuery_MergeJoinScan proto.InternalMessageInfo | ||
2400 | |||
2401 | const Default_CompiledQuery_MergeJoinScan_ValuePrefix bool = false | ||
2402 | |||
2403 | func (m *CompiledQuery_MergeJoinScan) GetIndexName() string { | ||
2404 | if m != nil && m.IndexName != nil { | ||
2405 | return *m.IndexName | ||
2406 | } | ||
2407 | return "" | ||
2408 | } | ||
2409 | |||
2410 | func (m *CompiledQuery_MergeJoinScan) GetPrefixValue() []string { | ||
2411 | if m != nil { | ||
2412 | return m.PrefixValue | ||
2413 | } | ||
2414 | return nil | ||
2415 | } | ||
2416 | |||
2417 | func (m *CompiledQuery_MergeJoinScan) GetValuePrefix() bool { | ||
2418 | if m != nil && m.ValuePrefix != nil { | ||
2419 | return *m.ValuePrefix | ||
2420 | } | ||
2421 | return Default_CompiledQuery_MergeJoinScan_ValuePrefix | ||
2422 | } | ||
2423 | |||
2424 | type CompiledQuery_EntityFilter struct { | ||
2425 | Distinct *bool `protobuf:"varint,14,opt,name=distinct,def=0" json:"distinct,omitempty"` | ||
2426 | Kind *string `protobuf:"bytes,17,opt,name=kind" json:"kind,omitempty"` | ||
2427 | Ancestor *Reference `protobuf:"bytes,18,opt,name=ancestor" json:"ancestor,omitempty"` | ||
2428 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
2429 | XXX_unrecognized []byte `json:"-"` | ||
2430 | XXX_sizecache int32 `json:"-"` | ||
2431 | } | ||
2432 | |||
2433 | func (m *CompiledQuery_EntityFilter) Reset() { *m = CompiledQuery_EntityFilter{} } | ||
2434 | func (m *CompiledQuery_EntityFilter) String() string { return proto.CompactTextString(m) } | ||
2435 | func (*CompiledQuery_EntityFilter) ProtoMessage() {} | ||
2436 | func (*CompiledQuery_EntityFilter) Descriptor() ([]byte, []int) { | ||
2437 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{16, 2} | ||
2438 | } | ||
2439 | func (m *CompiledQuery_EntityFilter) XXX_Unmarshal(b []byte) error { | ||
2440 | return xxx_messageInfo_CompiledQuery_EntityFilter.Unmarshal(m, b) | ||
2441 | } | ||
2442 | func (m *CompiledQuery_EntityFilter) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
2443 | return xxx_messageInfo_CompiledQuery_EntityFilter.Marshal(b, m, deterministic) | ||
2444 | } | ||
2445 | func (dst *CompiledQuery_EntityFilter) XXX_Merge(src proto.Message) { | ||
2446 | xxx_messageInfo_CompiledQuery_EntityFilter.Merge(dst, src) | ||
2447 | } | ||
2448 | func (m *CompiledQuery_EntityFilter) XXX_Size() int { | ||
2449 | return xxx_messageInfo_CompiledQuery_EntityFilter.Size(m) | ||
2450 | } | ||
2451 | func (m *CompiledQuery_EntityFilter) XXX_DiscardUnknown() { | ||
2452 | xxx_messageInfo_CompiledQuery_EntityFilter.DiscardUnknown(m) | ||
2453 | } | ||
2454 | |||
2455 | var xxx_messageInfo_CompiledQuery_EntityFilter proto.InternalMessageInfo | ||
2456 | |||
2457 | const Default_CompiledQuery_EntityFilter_Distinct bool = false | ||
2458 | |||
2459 | func (m *CompiledQuery_EntityFilter) GetDistinct() bool { | ||
2460 | if m != nil && m.Distinct != nil { | ||
2461 | return *m.Distinct | ||
2462 | } | ||
2463 | return Default_CompiledQuery_EntityFilter_Distinct | ||
2464 | } | ||
2465 | |||
2466 | func (m *CompiledQuery_EntityFilter) GetKind() string { | ||
2467 | if m != nil && m.Kind != nil { | ||
2468 | return *m.Kind | ||
2469 | } | ||
2470 | return "" | ||
2471 | } | ||
2472 | |||
2473 | func (m *CompiledQuery_EntityFilter) GetAncestor() *Reference { | ||
2474 | if m != nil { | ||
2475 | return m.Ancestor | ||
2476 | } | ||
2477 | return nil | ||
2478 | } | ||
2479 | |||
2480 | type CompiledCursor struct { | ||
2481 | Position *CompiledCursor_Position `protobuf:"group,2,opt,name=Position,json=position" json:"position,omitempty"` | ||
2482 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
2483 | XXX_unrecognized []byte `json:"-"` | ||
2484 | XXX_sizecache int32 `json:"-"` | ||
2485 | } | ||
2486 | |||
2487 | func (m *CompiledCursor) Reset() { *m = CompiledCursor{} } | ||
2488 | func (m *CompiledCursor) String() string { return proto.CompactTextString(m) } | ||
2489 | func (*CompiledCursor) ProtoMessage() {} | ||
2490 | func (*CompiledCursor) Descriptor() ([]byte, []int) { | ||
2491 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{17} | ||
2492 | } | ||
2493 | func (m *CompiledCursor) XXX_Unmarshal(b []byte) error { | ||
2494 | return xxx_messageInfo_CompiledCursor.Unmarshal(m, b) | ||
2495 | } | ||
2496 | func (m *CompiledCursor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
2497 | return xxx_messageInfo_CompiledCursor.Marshal(b, m, deterministic) | ||
2498 | } | ||
2499 | func (dst *CompiledCursor) XXX_Merge(src proto.Message) { | ||
2500 | xxx_messageInfo_CompiledCursor.Merge(dst, src) | ||
2501 | } | ||
2502 | func (m *CompiledCursor) XXX_Size() int { | ||
2503 | return xxx_messageInfo_CompiledCursor.Size(m) | ||
2504 | } | ||
2505 | func (m *CompiledCursor) XXX_DiscardUnknown() { | ||
2506 | xxx_messageInfo_CompiledCursor.DiscardUnknown(m) | ||
2507 | } | ||
2508 | |||
2509 | var xxx_messageInfo_CompiledCursor proto.InternalMessageInfo | ||
2510 | |||
2511 | func (m *CompiledCursor) GetPosition() *CompiledCursor_Position { | ||
2512 | if m != nil { | ||
2513 | return m.Position | ||
2514 | } | ||
2515 | return nil | ||
2516 | } | ||
2517 | |||
2518 | type CompiledCursor_Position struct { | ||
2519 | StartKey *string `protobuf:"bytes,27,opt,name=start_key,json=startKey" json:"start_key,omitempty"` | ||
2520 | Indexvalue []*CompiledCursor_Position_IndexValue `protobuf:"group,29,rep,name=IndexValue,json=indexvalue" json:"indexvalue,omitempty"` | ||
2521 | Key *Reference `protobuf:"bytes,32,opt,name=key" json:"key,omitempty"` | ||
2522 | StartInclusive *bool `protobuf:"varint,28,opt,name=start_inclusive,json=startInclusive,def=1" json:"start_inclusive,omitempty"` | ||
2523 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
2524 | XXX_unrecognized []byte `json:"-"` | ||
2525 | XXX_sizecache int32 `json:"-"` | ||
2526 | } | ||
2527 | |||
2528 | func (m *CompiledCursor_Position) Reset() { *m = CompiledCursor_Position{} } | ||
2529 | func (m *CompiledCursor_Position) String() string { return proto.CompactTextString(m) } | ||
2530 | func (*CompiledCursor_Position) ProtoMessage() {} | ||
2531 | func (*CompiledCursor_Position) Descriptor() ([]byte, []int) { | ||
2532 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{17, 0} | ||
2533 | } | ||
2534 | func (m *CompiledCursor_Position) XXX_Unmarshal(b []byte) error { | ||
2535 | return xxx_messageInfo_CompiledCursor_Position.Unmarshal(m, b) | ||
2536 | } | ||
2537 | func (m *CompiledCursor_Position) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
2538 | return xxx_messageInfo_CompiledCursor_Position.Marshal(b, m, deterministic) | ||
2539 | } | ||
2540 | func (dst *CompiledCursor_Position) XXX_Merge(src proto.Message) { | ||
2541 | xxx_messageInfo_CompiledCursor_Position.Merge(dst, src) | ||
2542 | } | ||
2543 | func (m *CompiledCursor_Position) XXX_Size() int { | ||
2544 | return xxx_messageInfo_CompiledCursor_Position.Size(m) | ||
2545 | } | ||
2546 | func (m *CompiledCursor_Position) XXX_DiscardUnknown() { | ||
2547 | xxx_messageInfo_CompiledCursor_Position.DiscardUnknown(m) | ||
2548 | } | ||
2549 | |||
2550 | var xxx_messageInfo_CompiledCursor_Position proto.InternalMessageInfo | ||
2551 | |||
2552 | const Default_CompiledCursor_Position_StartInclusive bool = true | ||
2553 | |||
2554 | func (m *CompiledCursor_Position) GetStartKey() string { | ||
2555 | if m != nil && m.StartKey != nil { | ||
2556 | return *m.StartKey | ||
2557 | } | ||
2558 | return "" | ||
2559 | } | ||
2560 | |||
2561 | func (m *CompiledCursor_Position) GetIndexvalue() []*CompiledCursor_Position_IndexValue { | ||
2562 | if m != nil { | ||
2563 | return m.Indexvalue | ||
2564 | } | ||
2565 | return nil | ||
2566 | } | ||
2567 | |||
2568 | func (m *CompiledCursor_Position) GetKey() *Reference { | ||
2569 | if m != nil { | ||
2570 | return m.Key | ||
2571 | } | ||
2572 | return nil | ||
2573 | } | ||
2574 | |||
2575 | func (m *CompiledCursor_Position) GetStartInclusive() bool { | ||
2576 | if m != nil && m.StartInclusive != nil { | ||
2577 | return *m.StartInclusive | ||
2578 | } | ||
2579 | return Default_CompiledCursor_Position_StartInclusive | ||
2580 | } | ||
2581 | |||
2582 | type CompiledCursor_Position_IndexValue struct { | ||
2583 | Property *string `protobuf:"bytes,30,opt,name=property" json:"property,omitempty"` | ||
2584 | Value *PropertyValue `protobuf:"bytes,31,req,name=value" json:"value,omitempty"` | ||
2585 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
2586 | XXX_unrecognized []byte `json:"-"` | ||
2587 | XXX_sizecache int32 `json:"-"` | ||
2588 | } | ||
2589 | |||
2590 | func (m *CompiledCursor_Position_IndexValue) Reset() { *m = CompiledCursor_Position_IndexValue{} } | ||
2591 | func (m *CompiledCursor_Position_IndexValue) String() string { return proto.CompactTextString(m) } | ||
2592 | func (*CompiledCursor_Position_IndexValue) ProtoMessage() {} | ||
2593 | func (*CompiledCursor_Position_IndexValue) Descriptor() ([]byte, []int) { | ||
2594 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{17, 0, 0} | ||
2595 | } | ||
2596 | func (m *CompiledCursor_Position_IndexValue) XXX_Unmarshal(b []byte) error { | ||
2597 | return xxx_messageInfo_CompiledCursor_Position_IndexValue.Unmarshal(m, b) | ||
2598 | } | ||
2599 | func (m *CompiledCursor_Position_IndexValue) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
2600 | return xxx_messageInfo_CompiledCursor_Position_IndexValue.Marshal(b, m, deterministic) | ||
2601 | } | ||
2602 | func (dst *CompiledCursor_Position_IndexValue) XXX_Merge(src proto.Message) { | ||
2603 | xxx_messageInfo_CompiledCursor_Position_IndexValue.Merge(dst, src) | ||
2604 | } | ||
2605 | func (m *CompiledCursor_Position_IndexValue) XXX_Size() int { | ||
2606 | return xxx_messageInfo_CompiledCursor_Position_IndexValue.Size(m) | ||
2607 | } | ||
2608 | func (m *CompiledCursor_Position_IndexValue) XXX_DiscardUnknown() { | ||
2609 | xxx_messageInfo_CompiledCursor_Position_IndexValue.DiscardUnknown(m) | ||
2610 | } | ||
2611 | |||
2612 | var xxx_messageInfo_CompiledCursor_Position_IndexValue proto.InternalMessageInfo | ||
2613 | |||
2614 | func (m *CompiledCursor_Position_IndexValue) GetProperty() string { | ||
2615 | if m != nil && m.Property != nil { | ||
2616 | return *m.Property | ||
2617 | } | ||
2618 | return "" | ||
2619 | } | ||
2620 | |||
2621 | func (m *CompiledCursor_Position_IndexValue) GetValue() *PropertyValue { | ||
2622 | if m != nil { | ||
2623 | return m.Value | ||
2624 | } | ||
2625 | return nil | ||
2626 | } | ||
2627 | |||
2628 | type Cursor struct { | ||
2629 | Cursor *uint64 `protobuf:"fixed64,1,req,name=cursor" json:"cursor,omitempty"` | ||
2630 | App *string `protobuf:"bytes,2,opt,name=app" json:"app,omitempty"` | ||
2631 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
2632 | XXX_unrecognized []byte `json:"-"` | ||
2633 | XXX_sizecache int32 `json:"-"` | ||
2634 | } | ||
2635 | |||
2636 | func (m *Cursor) Reset() { *m = Cursor{} } | ||
2637 | func (m *Cursor) String() string { return proto.CompactTextString(m) } | ||
2638 | func (*Cursor) ProtoMessage() {} | ||
2639 | func (*Cursor) Descriptor() ([]byte, []int) { | ||
2640 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{18} | ||
2641 | } | ||
2642 | func (m *Cursor) XXX_Unmarshal(b []byte) error { | ||
2643 | return xxx_messageInfo_Cursor.Unmarshal(m, b) | ||
2644 | } | ||
2645 | func (m *Cursor) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
2646 | return xxx_messageInfo_Cursor.Marshal(b, m, deterministic) | ||
2647 | } | ||
2648 | func (dst *Cursor) XXX_Merge(src proto.Message) { | ||
2649 | xxx_messageInfo_Cursor.Merge(dst, src) | ||
2650 | } | ||
2651 | func (m *Cursor) XXX_Size() int { | ||
2652 | return xxx_messageInfo_Cursor.Size(m) | ||
2653 | } | ||
2654 | func (m *Cursor) XXX_DiscardUnknown() { | ||
2655 | xxx_messageInfo_Cursor.DiscardUnknown(m) | ||
2656 | } | ||
2657 | |||
2658 | var xxx_messageInfo_Cursor proto.InternalMessageInfo | ||
2659 | |||
2660 | func (m *Cursor) GetCursor() uint64 { | ||
2661 | if m != nil && m.Cursor != nil { | ||
2662 | return *m.Cursor | ||
2663 | } | ||
2664 | return 0 | ||
2665 | } | ||
2666 | |||
2667 | func (m *Cursor) GetApp() string { | ||
2668 | if m != nil && m.App != nil { | ||
2669 | return *m.App | ||
2670 | } | ||
2671 | return "" | ||
2672 | } | ||
2673 | |||
2674 | type Error struct { | ||
2675 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
2676 | XXX_unrecognized []byte `json:"-"` | ||
2677 | XXX_sizecache int32 `json:"-"` | ||
2678 | } | ||
2679 | |||
2680 | func (m *Error) Reset() { *m = Error{} } | ||
2681 | func (m *Error) String() string { return proto.CompactTextString(m) } | ||
2682 | func (*Error) ProtoMessage() {} | ||
2683 | func (*Error) Descriptor() ([]byte, []int) { | ||
2684 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{19} | ||
2685 | } | ||
2686 | func (m *Error) XXX_Unmarshal(b []byte) error { | ||
2687 | return xxx_messageInfo_Error.Unmarshal(m, b) | ||
2688 | } | ||
2689 | func (m *Error) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
2690 | return xxx_messageInfo_Error.Marshal(b, m, deterministic) | ||
2691 | } | ||
2692 | func (dst *Error) XXX_Merge(src proto.Message) { | ||
2693 | xxx_messageInfo_Error.Merge(dst, src) | ||
2694 | } | ||
2695 | func (m *Error) XXX_Size() int { | ||
2696 | return xxx_messageInfo_Error.Size(m) | ||
2697 | } | ||
2698 | func (m *Error) XXX_DiscardUnknown() { | ||
2699 | xxx_messageInfo_Error.DiscardUnknown(m) | ||
2700 | } | ||
2701 | |||
2702 | var xxx_messageInfo_Error proto.InternalMessageInfo | ||
2703 | |||
2704 | type Cost struct { | ||
2705 | IndexWrites *int32 `protobuf:"varint,1,opt,name=index_writes,json=indexWrites" json:"index_writes,omitempty"` | ||
2706 | IndexWriteBytes *int32 `protobuf:"varint,2,opt,name=index_write_bytes,json=indexWriteBytes" json:"index_write_bytes,omitempty"` | ||
2707 | EntityWrites *int32 `protobuf:"varint,3,opt,name=entity_writes,json=entityWrites" json:"entity_writes,omitempty"` | ||
2708 | EntityWriteBytes *int32 `protobuf:"varint,4,opt,name=entity_write_bytes,json=entityWriteBytes" json:"entity_write_bytes,omitempty"` | ||
2709 | Commitcost *Cost_CommitCost `protobuf:"group,5,opt,name=CommitCost,json=commitcost" json:"commitcost,omitempty"` | ||
2710 | ApproximateStorageDelta *int32 `protobuf:"varint,8,opt,name=approximate_storage_delta,json=approximateStorageDelta" json:"approximate_storage_delta,omitempty"` | ||
2711 | IdSequenceUpdates *int32 `protobuf:"varint,9,opt,name=id_sequence_updates,json=idSequenceUpdates" json:"id_sequence_updates,omitempty"` | ||
2712 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
2713 | XXX_unrecognized []byte `json:"-"` | ||
2714 | XXX_sizecache int32 `json:"-"` | ||
2715 | } | ||
2716 | |||
2717 | func (m *Cost) Reset() { *m = Cost{} } | ||
2718 | func (m *Cost) String() string { return proto.CompactTextString(m) } | ||
2719 | func (*Cost) ProtoMessage() {} | ||
2720 | func (*Cost) Descriptor() ([]byte, []int) { | ||
2721 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{20} | ||
2722 | } | ||
2723 | func (m *Cost) XXX_Unmarshal(b []byte) error { | ||
2724 | return xxx_messageInfo_Cost.Unmarshal(m, b) | ||
2725 | } | ||
2726 | func (m *Cost) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
2727 | return xxx_messageInfo_Cost.Marshal(b, m, deterministic) | ||
2728 | } | ||
2729 | func (dst *Cost) XXX_Merge(src proto.Message) { | ||
2730 | xxx_messageInfo_Cost.Merge(dst, src) | ||
2731 | } | ||
2732 | func (m *Cost) XXX_Size() int { | ||
2733 | return xxx_messageInfo_Cost.Size(m) | ||
2734 | } | ||
2735 | func (m *Cost) XXX_DiscardUnknown() { | ||
2736 | xxx_messageInfo_Cost.DiscardUnknown(m) | ||
2737 | } | ||
2738 | |||
2739 | var xxx_messageInfo_Cost proto.InternalMessageInfo | ||
2740 | |||
2741 | func (m *Cost) GetIndexWrites() int32 { | ||
2742 | if m != nil && m.IndexWrites != nil { | ||
2743 | return *m.IndexWrites | ||
2744 | } | ||
2745 | return 0 | ||
2746 | } | ||
2747 | |||
2748 | func (m *Cost) GetIndexWriteBytes() int32 { | ||
2749 | if m != nil && m.IndexWriteBytes != nil { | ||
2750 | return *m.IndexWriteBytes | ||
2751 | } | ||
2752 | return 0 | ||
2753 | } | ||
2754 | |||
2755 | func (m *Cost) GetEntityWrites() int32 { | ||
2756 | if m != nil && m.EntityWrites != nil { | ||
2757 | return *m.EntityWrites | ||
2758 | } | ||
2759 | return 0 | ||
2760 | } | ||
2761 | |||
2762 | func (m *Cost) GetEntityWriteBytes() int32 { | ||
2763 | if m != nil && m.EntityWriteBytes != nil { | ||
2764 | return *m.EntityWriteBytes | ||
2765 | } | ||
2766 | return 0 | ||
2767 | } | ||
2768 | |||
2769 | func (m *Cost) GetCommitcost() *Cost_CommitCost { | ||
2770 | if m != nil { | ||
2771 | return m.Commitcost | ||
2772 | } | ||
2773 | return nil | ||
2774 | } | ||
2775 | |||
2776 | func (m *Cost) GetApproximateStorageDelta() int32 { | ||
2777 | if m != nil && m.ApproximateStorageDelta != nil { | ||
2778 | return *m.ApproximateStorageDelta | ||
2779 | } | ||
2780 | return 0 | ||
2781 | } | ||
2782 | |||
2783 | func (m *Cost) GetIdSequenceUpdates() int32 { | ||
2784 | if m != nil && m.IdSequenceUpdates != nil { | ||
2785 | return *m.IdSequenceUpdates | ||
2786 | } | ||
2787 | return 0 | ||
2788 | } | ||
2789 | |||
2790 | type Cost_CommitCost struct { | ||
2791 | RequestedEntityPuts *int32 `protobuf:"varint,6,opt,name=requested_entity_puts,json=requestedEntityPuts" json:"requested_entity_puts,omitempty"` | ||
2792 | RequestedEntityDeletes *int32 `protobuf:"varint,7,opt,name=requested_entity_deletes,json=requestedEntityDeletes" json:"requested_entity_deletes,omitempty"` | ||
2793 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
2794 | XXX_unrecognized []byte `json:"-"` | ||
2795 | XXX_sizecache int32 `json:"-"` | ||
2796 | } | ||
2797 | |||
2798 | func (m *Cost_CommitCost) Reset() { *m = Cost_CommitCost{} } | ||
2799 | func (m *Cost_CommitCost) String() string { return proto.CompactTextString(m) } | ||
2800 | func (*Cost_CommitCost) ProtoMessage() {} | ||
2801 | func (*Cost_CommitCost) Descriptor() ([]byte, []int) { | ||
2802 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{20, 0} | ||
2803 | } | ||
2804 | func (m *Cost_CommitCost) XXX_Unmarshal(b []byte) error { | ||
2805 | return xxx_messageInfo_Cost_CommitCost.Unmarshal(m, b) | ||
2806 | } | ||
2807 | func (m *Cost_CommitCost) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
2808 | return xxx_messageInfo_Cost_CommitCost.Marshal(b, m, deterministic) | ||
2809 | } | ||
2810 | func (dst *Cost_CommitCost) XXX_Merge(src proto.Message) { | ||
2811 | xxx_messageInfo_Cost_CommitCost.Merge(dst, src) | ||
2812 | } | ||
2813 | func (m *Cost_CommitCost) XXX_Size() int { | ||
2814 | return xxx_messageInfo_Cost_CommitCost.Size(m) | ||
2815 | } | ||
2816 | func (m *Cost_CommitCost) XXX_DiscardUnknown() { | ||
2817 | xxx_messageInfo_Cost_CommitCost.DiscardUnknown(m) | ||
2818 | } | ||
2819 | |||
2820 | var xxx_messageInfo_Cost_CommitCost proto.InternalMessageInfo | ||
2821 | |||
2822 | func (m *Cost_CommitCost) GetRequestedEntityPuts() int32 { | ||
2823 | if m != nil && m.RequestedEntityPuts != nil { | ||
2824 | return *m.RequestedEntityPuts | ||
2825 | } | ||
2826 | return 0 | ||
2827 | } | ||
2828 | |||
2829 | func (m *Cost_CommitCost) GetRequestedEntityDeletes() int32 { | ||
2830 | if m != nil && m.RequestedEntityDeletes != nil { | ||
2831 | return *m.RequestedEntityDeletes | ||
2832 | } | ||
2833 | return 0 | ||
2834 | } | ||
2835 | |||
2836 | type GetRequest struct { | ||
2837 | Header *InternalHeader `protobuf:"bytes,6,opt,name=header" json:"header,omitempty"` | ||
2838 | Key []*Reference `protobuf:"bytes,1,rep,name=key" json:"key,omitempty"` | ||
2839 | Transaction *Transaction `protobuf:"bytes,2,opt,name=transaction" json:"transaction,omitempty"` | ||
2840 | FailoverMs *int64 `protobuf:"varint,3,opt,name=failover_ms,json=failoverMs" json:"failover_ms,omitempty"` | ||
2841 | Strong *bool `protobuf:"varint,4,opt,name=strong" json:"strong,omitempty"` | ||
2842 | AllowDeferred *bool `protobuf:"varint,5,opt,name=allow_deferred,json=allowDeferred,def=0" json:"allow_deferred,omitempty"` | ||
2843 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
2844 | XXX_unrecognized []byte `json:"-"` | ||
2845 | XXX_sizecache int32 `json:"-"` | ||
2846 | } | ||
2847 | |||
2848 | func (m *GetRequest) Reset() { *m = GetRequest{} } | ||
2849 | func (m *GetRequest) String() string { return proto.CompactTextString(m) } | ||
2850 | func (*GetRequest) ProtoMessage() {} | ||
2851 | func (*GetRequest) Descriptor() ([]byte, []int) { | ||
2852 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{21} | ||
2853 | } | ||
2854 | func (m *GetRequest) XXX_Unmarshal(b []byte) error { | ||
2855 | return xxx_messageInfo_GetRequest.Unmarshal(m, b) | ||
2856 | } | ||
2857 | func (m *GetRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
2858 | return xxx_messageInfo_GetRequest.Marshal(b, m, deterministic) | ||
2859 | } | ||
2860 | func (dst *GetRequest) XXX_Merge(src proto.Message) { | ||
2861 | xxx_messageInfo_GetRequest.Merge(dst, src) | ||
2862 | } | ||
2863 | func (m *GetRequest) XXX_Size() int { | ||
2864 | return xxx_messageInfo_GetRequest.Size(m) | ||
2865 | } | ||
2866 | func (m *GetRequest) XXX_DiscardUnknown() { | ||
2867 | xxx_messageInfo_GetRequest.DiscardUnknown(m) | ||
2868 | } | ||
2869 | |||
2870 | var xxx_messageInfo_GetRequest proto.InternalMessageInfo | ||
2871 | |||
2872 | const Default_GetRequest_AllowDeferred bool = false | ||
2873 | |||
2874 | func (m *GetRequest) GetHeader() *InternalHeader { | ||
2875 | if m != nil { | ||
2876 | return m.Header | ||
2877 | } | ||
2878 | return nil | ||
2879 | } | ||
2880 | |||
2881 | func (m *GetRequest) GetKey() []*Reference { | ||
2882 | if m != nil { | ||
2883 | return m.Key | ||
2884 | } | ||
2885 | return nil | ||
2886 | } | ||
2887 | |||
2888 | func (m *GetRequest) GetTransaction() *Transaction { | ||
2889 | if m != nil { | ||
2890 | return m.Transaction | ||
2891 | } | ||
2892 | return nil | ||
2893 | } | ||
2894 | |||
2895 | func (m *GetRequest) GetFailoverMs() int64 { | ||
2896 | if m != nil && m.FailoverMs != nil { | ||
2897 | return *m.FailoverMs | ||
2898 | } | ||
2899 | return 0 | ||
2900 | } | ||
2901 | |||
2902 | func (m *GetRequest) GetStrong() bool { | ||
2903 | if m != nil && m.Strong != nil { | ||
2904 | return *m.Strong | ||
2905 | } | ||
2906 | return false | ||
2907 | } | ||
2908 | |||
2909 | func (m *GetRequest) GetAllowDeferred() bool { | ||
2910 | if m != nil && m.AllowDeferred != nil { | ||
2911 | return *m.AllowDeferred | ||
2912 | } | ||
2913 | return Default_GetRequest_AllowDeferred | ||
2914 | } | ||
2915 | |||
2916 | type GetResponse struct { | ||
2917 | Entity []*GetResponse_Entity `protobuf:"group,1,rep,name=Entity,json=entity" json:"entity,omitempty"` | ||
2918 | Deferred []*Reference `protobuf:"bytes,5,rep,name=deferred" json:"deferred,omitempty"` | ||
2919 | InOrder *bool `protobuf:"varint,6,opt,name=in_order,json=inOrder,def=1" json:"in_order,omitempty"` | ||
2920 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
2921 | XXX_unrecognized []byte `json:"-"` | ||
2922 | XXX_sizecache int32 `json:"-"` | ||
2923 | } | ||
2924 | |||
2925 | func (m *GetResponse) Reset() { *m = GetResponse{} } | ||
2926 | func (m *GetResponse) String() string { return proto.CompactTextString(m) } | ||
2927 | func (*GetResponse) ProtoMessage() {} | ||
2928 | func (*GetResponse) Descriptor() ([]byte, []int) { | ||
2929 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{22} | ||
2930 | } | ||
2931 | func (m *GetResponse) XXX_Unmarshal(b []byte) error { | ||
2932 | return xxx_messageInfo_GetResponse.Unmarshal(m, b) | ||
2933 | } | ||
2934 | func (m *GetResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
2935 | return xxx_messageInfo_GetResponse.Marshal(b, m, deterministic) | ||
2936 | } | ||
2937 | func (dst *GetResponse) XXX_Merge(src proto.Message) { | ||
2938 | xxx_messageInfo_GetResponse.Merge(dst, src) | ||
2939 | } | ||
2940 | func (m *GetResponse) XXX_Size() int { | ||
2941 | return xxx_messageInfo_GetResponse.Size(m) | ||
2942 | } | ||
2943 | func (m *GetResponse) XXX_DiscardUnknown() { | ||
2944 | xxx_messageInfo_GetResponse.DiscardUnknown(m) | ||
2945 | } | ||
2946 | |||
2947 | var xxx_messageInfo_GetResponse proto.InternalMessageInfo | ||
2948 | |||
2949 | const Default_GetResponse_InOrder bool = true | ||
2950 | |||
2951 | func (m *GetResponse) GetEntity() []*GetResponse_Entity { | ||
2952 | if m != nil { | ||
2953 | return m.Entity | ||
2954 | } | ||
2955 | return nil | ||
2956 | } | ||
2957 | |||
2958 | func (m *GetResponse) GetDeferred() []*Reference { | ||
2959 | if m != nil { | ||
2960 | return m.Deferred | ||
2961 | } | ||
2962 | return nil | ||
2963 | } | ||
2964 | |||
2965 | func (m *GetResponse) GetInOrder() bool { | ||
2966 | if m != nil && m.InOrder != nil { | ||
2967 | return *m.InOrder | ||
2968 | } | ||
2969 | return Default_GetResponse_InOrder | ||
2970 | } | ||
2971 | |||
2972 | type GetResponse_Entity struct { | ||
2973 | Entity *EntityProto `protobuf:"bytes,2,opt,name=entity" json:"entity,omitempty"` | ||
2974 | Key *Reference `protobuf:"bytes,4,opt,name=key" json:"key,omitempty"` | ||
2975 | Version *int64 `protobuf:"varint,3,opt,name=version" json:"version,omitempty"` | ||
2976 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
2977 | XXX_unrecognized []byte `json:"-"` | ||
2978 | XXX_sizecache int32 `json:"-"` | ||
2979 | } | ||
2980 | |||
2981 | func (m *GetResponse_Entity) Reset() { *m = GetResponse_Entity{} } | ||
2982 | func (m *GetResponse_Entity) String() string { return proto.CompactTextString(m) } | ||
2983 | func (*GetResponse_Entity) ProtoMessage() {} | ||
2984 | func (*GetResponse_Entity) Descriptor() ([]byte, []int) { | ||
2985 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{22, 0} | ||
2986 | } | ||
2987 | func (m *GetResponse_Entity) XXX_Unmarshal(b []byte) error { | ||
2988 | return xxx_messageInfo_GetResponse_Entity.Unmarshal(m, b) | ||
2989 | } | ||
2990 | func (m *GetResponse_Entity) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
2991 | return xxx_messageInfo_GetResponse_Entity.Marshal(b, m, deterministic) | ||
2992 | } | ||
2993 | func (dst *GetResponse_Entity) XXX_Merge(src proto.Message) { | ||
2994 | xxx_messageInfo_GetResponse_Entity.Merge(dst, src) | ||
2995 | } | ||
2996 | func (m *GetResponse_Entity) XXX_Size() int { | ||
2997 | return xxx_messageInfo_GetResponse_Entity.Size(m) | ||
2998 | } | ||
2999 | func (m *GetResponse_Entity) XXX_DiscardUnknown() { | ||
3000 | xxx_messageInfo_GetResponse_Entity.DiscardUnknown(m) | ||
3001 | } | ||
3002 | |||
3003 | var xxx_messageInfo_GetResponse_Entity proto.InternalMessageInfo | ||
3004 | |||
3005 | func (m *GetResponse_Entity) GetEntity() *EntityProto { | ||
3006 | if m != nil { | ||
3007 | return m.Entity | ||
3008 | } | ||
3009 | return nil | ||
3010 | } | ||
3011 | |||
3012 | func (m *GetResponse_Entity) GetKey() *Reference { | ||
3013 | if m != nil { | ||
3014 | return m.Key | ||
3015 | } | ||
3016 | return nil | ||
3017 | } | ||
3018 | |||
3019 | func (m *GetResponse_Entity) GetVersion() int64 { | ||
3020 | if m != nil && m.Version != nil { | ||
3021 | return *m.Version | ||
3022 | } | ||
3023 | return 0 | ||
3024 | } | ||
3025 | |||
3026 | type PutRequest struct { | ||
3027 | Header *InternalHeader `protobuf:"bytes,11,opt,name=header" json:"header,omitempty"` | ||
3028 | Entity []*EntityProto `protobuf:"bytes,1,rep,name=entity" json:"entity,omitempty"` | ||
3029 | Transaction *Transaction `protobuf:"bytes,2,opt,name=transaction" json:"transaction,omitempty"` | ||
3030 | CompositeIndex []*CompositeIndex `protobuf:"bytes,3,rep,name=composite_index,json=compositeIndex" json:"composite_index,omitempty"` | ||
3031 | Trusted *bool `protobuf:"varint,4,opt,name=trusted,def=0" json:"trusted,omitempty"` | ||
3032 | Force *bool `protobuf:"varint,7,opt,name=force,def=0" json:"force,omitempty"` | ||
3033 | MarkChanges *bool `protobuf:"varint,8,opt,name=mark_changes,json=markChanges,def=0" json:"mark_changes,omitempty"` | ||
3034 | Snapshot []*Snapshot `protobuf:"bytes,9,rep,name=snapshot" json:"snapshot,omitempty"` | ||
3035 | AutoIdPolicy *PutRequest_AutoIdPolicy `protobuf:"varint,10,opt,name=auto_id_policy,json=autoIdPolicy,enum=appengine.PutRequest_AutoIdPolicy,def=0" json:"auto_id_policy,omitempty"` | ||
3036 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
3037 | XXX_unrecognized []byte `json:"-"` | ||
3038 | XXX_sizecache int32 `json:"-"` | ||
3039 | } | ||
3040 | |||
3041 | func (m *PutRequest) Reset() { *m = PutRequest{} } | ||
3042 | func (m *PutRequest) String() string { return proto.CompactTextString(m) } | ||
3043 | func (*PutRequest) ProtoMessage() {} | ||
3044 | func (*PutRequest) Descriptor() ([]byte, []int) { | ||
3045 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{23} | ||
3046 | } | ||
3047 | func (m *PutRequest) XXX_Unmarshal(b []byte) error { | ||
3048 | return xxx_messageInfo_PutRequest.Unmarshal(m, b) | ||
3049 | } | ||
3050 | func (m *PutRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
3051 | return xxx_messageInfo_PutRequest.Marshal(b, m, deterministic) | ||
3052 | } | ||
3053 | func (dst *PutRequest) XXX_Merge(src proto.Message) { | ||
3054 | xxx_messageInfo_PutRequest.Merge(dst, src) | ||
3055 | } | ||
3056 | func (m *PutRequest) XXX_Size() int { | ||
3057 | return xxx_messageInfo_PutRequest.Size(m) | ||
3058 | } | ||
3059 | func (m *PutRequest) XXX_DiscardUnknown() { | ||
3060 | xxx_messageInfo_PutRequest.DiscardUnknown(m) | ||
3061 | } | ||
3062 | |||
3063 | var xxx_messageInfo_PutRequest proto.InternalMessageInfo | ||
3064 | |||
3065 | const Default_PutRequest_Trusted bool = false | ||
3066 | const Default_PutRequest_Force bool = false | ||
3067 | const Default_PutRequest_MarkChanges bool = false | ||
3068 | const Default_PutRequest_AutoIdPolicy PutRequest_AutoIdPolicy = PutRequest_CURRENT | ||
3069 | |||
3070 | func (m *PutRequest) GetHeader() *InternalHeader { | ||
3071 | if m != nil { | ||
3072 | return m.Header | ||
3073 | } | ||
3074 | return nil | ||
3075 | } | ||
3076 | |||
3077 | func (m *PutRequest) GetEntity() []*EntityProto { | ||
3078 | if m != nil { | ||
3079 | return m.Entity | ||
3080 | } | ||
3081 | return nil | ||
3082 | } | ||
3083 | |||
3084 | func (m *PutRequest) GetTransaction() *Transaction { | ||
3085 | if m != nil { | ||
3086 | return m.Transaction | ||
3087 | } | ||
3088 | return nil | ||
3089 | } | ||
3090 | |||
3091 | func (m *PutRequest) GetCompositeIndex() []*CompositeIndex { | ||
3092 | if m != nil { | ||
3093 | return m.CompositeIndex | ||
3094 | } | ||
3095 | return nil | ||
3096 | } | ||
3097 | |||
3098 | func (m *PutRequest) GetTrusted() bool { | ||
3099 | if m != nil && m.Trusted != nil { | ||
3100 | return *m.Trusted | ||
3101 | } | ||
3102 | return Default_PutRequest_Trusted | ||
3103 | } | ||
3104 | |||
3105 | func (m *PutRequest) GetForce() bool { | ||
3106 | if m != nil && m.Force != nil { | ||
3107 | return *m.Force | ||
3108 | } | ||
3109 | return Default_PutRequest_Force | ||
3110 | } | ||
3111 | |||
3112 | func (m *PutRequest) GetMarkChanges() bool { | ||
3113 | if m != nil && m.MarkChanges != nil { | ||
3114 | return *m.MarkChanges | ||
3115 | } | ||
3116 | return Default_PutRequest_MarkChanges | ||
3117 | } | ||
3118 | |||
3119 | func (m *PutRequest) GetSnapshot() []*Snapshot { | ||
3120 | if m != nil { | ||
3121 | return m.Snapshot | ||
3122 | } | ||
3123 | return nil | ||
3124 | } | ||
3125 | |||
3126 | func (m *PutRequest) GetAutoIdPolicy() PutRequest_AutoIdPolicy { | ||
3127 | if m != nil && m.AutoIdPolicy != nil { | ||
3128 | return *m.AutoIdPolicy | ||
3129 | } | ||
3130 | return Default_PutRequest_AutoIdPolicy | ||
3131 | } | ||
3132 | |||
3133 | type PutResponse struct { | ||
3134 | Key []*Reference `protobuf:"bytes,1,rep,name=key" json:"key,omitempty"` | ||
3135 | Cost *Cost `protobuf:"bytes,2,opt,name=cost" json:"cost,omitempty"` | ||
3136 | Version []int64 `protobuf:"varint,3,rep,name=version" json:"version,omitempty"` | ||
3137 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
3138 | XXX_unrecognized []byte `json:"-"` | ||
3139 | XXX_sizecache int32 `json:"-"` | ||
3140 | } | ||
3141 | |||
3142 | func (m *PutResponse) Reset() { *m = PutResponse{} } | ||
3143 | func (m *PutResponse) String() string { return proto.CompactTextString(m) } | ||
3144 | func (*PutResponse) ProtoMessage() {} | ||
3145 | func (*PutResponse) Descriptor() ([]byte, []int) { | ||
3146 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{24} | ||
3147 | } | ||
3148 | func (m *PutResponse) XXX_Unmarshal(b []byte) error { | ||
3149 | return xxx_messageInfo_PutResponse.Unmarshal(m, b) | ||
3150 | } | ||
3151 | func (m *PutResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
3152 | return xxx_messageInfo_PutResponse.Marshal(b, m, deterministic) | ||
3153 | } | ||
3154 | func (dst *PutResponse) XXX_Merge(src proto.Message) { | ||
3155 | xxx_messageInfo_PutResponse.Merge(dst, src) | ||
3156 | } | ||
3157 | func (m *PutResponse) XXX_Size() int { | ||
3158 | return xxx_messageInfo_PutResponse.Size(m) | ||
3159 | } | ||
3160 | func (m *PutResponse) XXX_DiscardUnknown() { | ||
3161 | xxx_messageInfo_PutResponse.DiscardUnknown(m) | ||
3162 | } | ||
3163 | |||
3164 | var xxx_messageInfo_PutResponse proto.InternalMessageInfo | ||
3165 | |||
3166 | func (m *PutResponse) GetKey() []*Reference { | ||
3167 | if m != nil { | ||
3168 | return m.Key | ||
3169 | } | ||
3170 | return nil | ||
3171 | } | ||
3172 | |||
3173 | func (m *PutResponse) GetCost() *Cost { | ||
3174 | if m != nil { | ||
3175 | return m.Cost | ||
3176 | } | ||
3177 | return nil | ||
3178 | } | ||
3179 | |||
3180 | func (m *PutResponse) GetVersion() []int64 { | ||
3181 | if m != nil { | ||
3182 | return m.Version | ||
3183 | } | ||
3184 | return nil | ||
3185 | } | ||
3186 | |||
3187 | type TouchRequest struct { | ||
3188 | Header *InternalHeader `protobuf:"bytes,10,opt,name=header" json:"header,omitempty"` | ||
3189 | Key []*Reference `protobuf:"bytes,1,rep,name=key" json:"key,omitempty"` | ||
3190 | CompositeIndex []*CompositeIndex `protobuf:"bytes,2,rep,name=composite_index,json=compositeIndex" json:"composite_index,omitempty"` | ||
3191 | Force *bool `protobuf:"varint,3,opt,name=force,def=0" json:"force,omitempty"` | ||
3192 | Snapshot []*Snapshot `protobuf:"bytes,9,rep,name=snapshot" json:"snapshot,omitempty"` | ||
3193 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
3194 | XXX_unrecognized []byte `json:"-"` | ||
3195 | XXX_sizecache int32 `json:"-"` | ||
3196 | } | ||
3197 | |||
3198 | func (m *TouchRequest) Reset() { *m = TouchRequest{} } | ||
3199 | func (m *TouchRequest) String() string { return proto.CompactTextString(m) } | ||
3200 | func (*TouchRequest) ProtoMessage() {} | ||
3201 | func (*TouchRequest) Descriptor() ([]byte, []int) { | ||
3202 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{25} | ||
3203 | } | ||
3204 | func (m *TouchRequest) XXX_Unmarshal(b []byte) error { | ||
3205 | return xxx_messageInfo_TouchRequest.Unmarshal(m, b) | ||
3206 | } | ||
3207 | func (m *TouchRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
3208 | return xxx_messageInfo_TouchRequest.Marshal(b, m, deterministic) | ||
3209 | } | ||
3210 | func (dst *TouchRequest) XXX_Merge(src proto.Message) { | ||
3211 | xxx_messageInfo_TouchRequest.Merge(dst, src) | ||
3212 | } | ||
3213 | func (m *TouchRequest) XXX_Size() int { | ||
3214 | return xxx_messageInfo_TouchRequest.Size(m) | ||
3215 | } | ||
3216 | func (m *TouchRequest) XXX_DiscardUnknown() { | ||
3217 | xxx_messageInfo_TouchRequest.DiscardUnknown(m) | ||
3218 | } | ||
3219 | |||
3220 | var xxx_messageInfo_TouchRequest proto.InternalMessageInfo | ||
3221 | |||
3222 | const Default_TouchRequest_Force bool = false | ||
3223 | |||
3224 | func (m *TouchRequest) GetHeader() *InternalHeader { | ||
3225 | if m != nil { | ||
3226 | return m.Header | ||
3227 | } | ||
3228 | return nil | ||
3229 | } | ||
3230 | |||
3231 | func (m *TouchRequest) GetKey() []*Reference { | ||
3232 | if m != nil { | ||
3233 | return m.Key | ||
3234 | } | ||
3235 | return nil | ||
3236 | } | ||
3237 | |||
3238 | func (m *TouchRequest) GetCompositeIndex() []*CompositeIndex { | ||
3239 | if m != nil { | ||
3240 | return m.CompositeIndex | ||
3241 | } | ||
3242 | return nil | ||
3243 | } | ||
3244 | |||
3245 | func (m *TouchRequest) GetForce() bool { | ||
3246 | if m != nil && m.Force != nil { | ||
3247 | return *m.Force | ||
3248 | } | ||
3249 | return Default_TouchRequest_Force | ||
3250 | } | ||
3251 | |||
3252 | func (m *TouchRequest) GetSnapshot() []*Snapshot { | ||
3253 | if m != nil { | ||
3254 | return m.Snapshot | ||
3255 | } | ||
3256 | return nil | ||
3257 | } | ||
3258 | |||
3259 | type TouchResponse struct { | ||
3260 | Cost *Cost `protobuf:"bytes,1,opt,name=cost" json:"cost,omitempty"` | ||
3261 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
3262 | XXX_unrecognized []byte `json:"-"` | ||
3263 | XXX_sizecache int32 `json:"-"` | ||
3264 | } | ||
3265 | |||
3266 | func (m *TouchResponse) Reset() { *m = TouchResponse{} } | ||
3267 | func (m *TouchResponse) String() string { return proto.CompactTextString(m) } | ||
3268 | func (*TouchResponse) ProtoMessage() {} | ||
3269 | func (*TouchResponse) Descriptor() ([]byte, []int) { | ||
3270 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{26} | ||
3271 | } | ||
3272 | func (m *TouchResponse) XXX_Unmarshal(b []byte) error { | ||
3273 | return xxx_messageInfo_TouchResponse.Unmarshal(m, b) | ||
3274 | } | ||
3275 | func (m *TouchResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
3276 | return xxx_messageInfo_TouchResponse.Marshal(b, m, deterministic) | ||
3277 | } | ||
3278 | func (dst *TouchResponse) XXX_Merge(src proto.Message) { | ||
3279 | xxx_messageInfo_TouchResponse.Merge(dst, src) | ||
3280 | } | ||
3281 | func (m *TouchResponse) XXX_Size() int { | ||
3282 | return xxx_messageInfo_TouchResponse.Size(m) | ||
3283 | } | ||
3284 | func (m *TouchResponse) XXX_DiscardUnknown() { | ||
3285 | xxx_messageInfo_TouchResponse.DiscardUnknown(m) | ||
3286 | } | ||
3287 | |||
3288 | var xxx_messageInfo_TouchResponse proto.InternalMessageInfo | ||
3289 | |||
3290 | func (m *TouchResponse) GetCost() *Cost { | ||
3291 | if m != nil { | ||
3292 | return m.Cost | ||
3293 | } | ||
3294 | return nil | ||
3295 | } | ||
3296 | |||
3297 | type DeleteRequest struct { | ||
3298 | Header *InternalHeader `protobuf:"bytes,10,opt,name=header" json:"header,omitempty"` | ||
3299 | Key []*Reference `protobuf:"bytes,6,rep,name=key" json:"key,omitempty"` | ||
3300 | Transaction *Transaction `protobuf:"bytes,5,opt,name=transaction" json:"transaction,omitempty"` | ||
3301 | Trusted *bool `protobuf:"varint,4,opt,name=trusted,def=0" json:"trusted,omitempty"` | ||
3302 | Force *bool `protobuf:"varint,7,opt,name=force,def=0" json:"force,omitempty"` | ||
3303 | MarkChanges *bool `protobuf:"varint,8,opt,name=mark_changes,json=markChanges,def=0" json:"mark_changes,omitempty"` | ||
3304 | Snapshot []*Snapshot `protobuf:"bytes,9,rep,name=snapshot" json:"snapshot,omitempty"` | ||
3305 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
3306 | XXX_unrecognized []byte `json:"-"` | ||
3307 | XXX_sizecache int32 `json:"-"` | ||
3308 | } | ||
3309 | |||
3310 | func (m *DeleteRequest) Reset() { *m = DeleteRequest{} } | ||
3311 | func (m *DeleteRequest) String() string { return proto.CompactTextString(m) } | ||
3312 | func (*DeleteRequest) ProtoMessage() {} | ||
3313 | func (*DeleteRequest) Descriptor() ([]byte, []int) { | ||
3314 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{27} | ||
3315 | } | ||
3316 | func (m *DeleteRequest) XXX_Unmarshal(b []byte) error { | ||
3317 | return xxx_messageInfo_DeleteRequest.Unmarshal(m, b) | ||
3318 | } | ||
3319 | func (m *DeleteRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
3320 | return xxx_messageInfo_DeleteRequest.Marshal(b, m, deterministic) | ||
3321 | } | ||
3322 | func (dst *DeleteRequest) XXX_Merge(src proto.Message) { | ||
3323 | xxx_messageInfo_DeleteRequest.Merge(dst, src) | ||
3324 | } | ||
3325 | func (m *DeleteRequest) XXX_Size() int { | ||
3326 | return xxx_messageInfo_DeleteRequest.Size(m) | ||
3327 | } | ||
3328 | func (m *DeleteRequest) XXX_DiscardUnknown() { | ||
3329 | xxx_messageInfo_DeleteRequest.DiscardUnknown(m) | ||
3330 | } | ||
3331 | |||
3332 | var xxx_messageInfo_DeleteRequest proto.InternalMessageInfo | ||
3333 | |||
3334 | const Default_DeleteRequest_Trusted bool = false | ||
3335 | const Default_DeleteRequest_Force bool = false | ||
3336 | const Default_DeleteRequest_MarkChanges bool = false | ||
3337 | |||
3338 | func (m *DeleteRequest) GetHeader() *InternalHeader { | ||
3339 | if m != nil { | ||
3340 | return m.Header | ||
3341 | } | ||
3342 | return nil | ||
3343 | } | ||
3344 | |||
3345 | func (m *DeleteRequest) GetKey() []*Reference { | ||
3346 | if m != nil { | ||
3347 | return m.Key | ||
3348 | } | ||
3349 | return nil | ||
3350 | } | ||
3351 | |||
3352 | func (m *DeleteRequest) GetTransaction() *Transaction { | ||
3353 | if m != nil { | ||
3354 | return m.Transaction | ||
3355 | } | ||
3356 | return nil | ||
3357 | } | ||
3358 | |||
3359 | func (m *DeleteRequest) GetTrusted() bool { | ||
3360 | if m != nil && m.Trusted != nil { | ||
3361 | return *m.Trusted | ||
3362 | } | ||
3363 | return Default_DeleteRequest_Trusted | ||
3364 | } | ||
3365 | |||
3366 | func (m *DeleteRequest) GetForce() bool { | ||
3367 | if m != nil && m.Force != nil { | ||
3368 | return *m.Force | ||
3369 | } | ||
3370 | return Default_DeleteRequest_Force | ||
3371 | } | ||
3372 | |||
3373 | func (m *DeleteRequest) GetMarkChanges() bool { | ||
3374 | if m != nil && m.MarkChanges != nil { | ||
3375 | return *m.MarkChanges | ||
3376 | } | ||
3377 | return Default_DeleteRequest_MarkChanges | ||
3378 | } | ||
3379 | |||
3380 | func (m *DeleteRequest) GetSnapshot() []*Snapshot { | ||
3381 | if m != nil { | ||
3382 | return m.Snapshot | ||
3383 | } | ||
3384 | return nil | ||
3385 | } | ||
3386 | |||
3387 | type DeleteResponse struct { | ||
3388 | Cost *Cost `protobuf:"bytes,1,opt,name=cost" json:"cost,omitempty"` | ||
3389 | Version []int64 `protobuf:"varint,3,rep,name=version" json:"version,omitempty"` | ||
3390 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
3391 | XXX_unrecognized []byte `json:"-"` | ||
3392 | XXX_sizecache int32 `json:"-"` | ||
3393 | } | ||
3394 | |||
3395 | func (m *DeleteResponse) Reset() { *m = DeleteResponse{} } | ||
3396 | func (m *DeleteResponse) String() string { return proto.CompactTextString(m) } | ||
3397 | func (*DeleteResponse) ProtoMessage() {} | ||
3398 | func (*DeleteResponse) Descriptor() ([]byte, []int) { | ||
3399 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{28} | ||
3400 | } | ||
3401 | func (m *DeleteResponse) XXX_Unmarshal(b []byte) error { | ||
3402 | return xxx_messageInfo_DeleteResponse.Unmarshal(m, b) | ||
3403 | } | ||
3404 | func (m *DeleteResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
3405 | return xxx_messageInfo_DeleteResponse.Marshal(b, m, deterministic) | ||
3406 | } | ||
3407 | func (dst *DeleteResponse) XXX_Merge(src proto.Message) { | ||
3408 | xxx_messageInfo_DeleteResponse.Merge(dst, src) | ||
3409 | } | ||
3410 | func (m *DeleteResponse) XXX_Size() int { | ||
3411 | return xxx_messageInfo_DeleteResponse.Size(m) | ||
3412 | } | ||
3413 | func (m *DeleteResponse) XXX_DiscardUnknown() { | ||
3414 | xxx_messageInfo_DeleteResponse.DiscardUnknown(m) | ||
3415 | } | ||
3416 | |||
3417 | var xxx_messageInfo_DeleteResponse proto.InternalMessageInfo | ||
3418 | |||
3419 | func (m *DeleteResponse) GetCost() *Cost { | ||
3420 | if m != nil { | ||
3421 | return m.Cost | ||
3422 | } | ||
3423 | return nil | ||
3424 | } | ||
3425 | |||
3426 | func (m *DeleteResponse) GetVersion() []int64 { | ||
3427 | if m != nil { | ||
3428 | return m.Version | ||
3429 | } | ||
3430 | return nil | ||
3431 | } | ||
3432 | |||
3433 | type NextRequest struct { | ||
3434 | Header *InternalHeader `protobuf:"bytes,5,opt,name=header" json:"header,omitempty"` | ||
3435 | Cursor *Cursor `protobuf:"bytes,1,req,name=cursor" json:"cursor,omitempty"` | ||
3436 | Count *int32 `protobuf:"varint,2,opt,name=count" json:"count,omitempty"` | ||
3437 | Offset *int32 `protobuf:"varint,4,opt,name=offset,def=0" json:"offset,omitempty"` | ||
3438 | Compile *bool `protobuf:"varint,3,opt,name=compile,def=0" json:"compile,omitempty"` | ||
3439 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
3440 | XXX_unrecognized []byte `json:"-"` | ||
3441 | XXX_sizecache int32 `json:"-"` | ||
3442 | } | ||
3443 | |||
3444 | func (m *NextRequest) Reset() { *m = NextRequest{} } | ||
3445 | func (m *NextRequest) String() string { return proto.CompactTextString(m) } | ||
3446 | func (*NextRequest) ProtoMessage() {} | ||
3447 | func (*NextRequest) Descriptor() ([]byte, []int) { | ||
3448 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{29} | ||
3449 | } | ||
3450 | func (m *NextRequest) XXX_Unmarshal(b []byte) error { | ||
3451 | return xxx_messageInfo_NextRequest.Unmarshal(m, b) | ||
3452 | } | ||
3453 | func (m *NextRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
3454 | return xxx_messageInfo_NextRequest.Marshal(b, m, deterministic) | ||
3455 | } | ||
3456 | func (dst *NextRequest) XXX_Merge(src proto.Message) { | ||
3457 | xxx_messageInfo_NextRequest.Merge(dst, src) | ||
3458 | } | ||
3459 | func (m *NextRequest) XXX_Size() int { | ||
3460 | return xxx_messageInfo_NextRequest.Size(m) | ||
3461 | } | ||
3462 | func (m *NextRequest) XXX_DiscardUnknown() { | ||
3463 | xxx_messageInfo_NextRequest.DiscardUnknown(m) | ||
3464 | } | ||
3465 | |||
3466 | var xxx_messageInfo_NextRequest proto.InternalMessageInfo | ||
3467 | |||
3468 | const Default_NextRequest_Offset int32 = 0 | ||
3469 | const Default_NextRequest_Compile bool = false | ||
3470 | |||
3471 | func (m *NextRequest) GetHeader() *InternalHeader { | ||
3472 | if m != nil { | ||
3473 | return m.Header | ||
3474 | } | ||
3475 | return nil | ||
3476 | } | ||
3477 | |||
3478 | func (m *NextRequest) GetCursor() *Cursor { | ||
3479 | if m != nil { | ||
3480 | return m.Cursor | ||
3481 | } | ||
3482 | return nil | ||
3483 | } | ||
3484 | |||
3485 | func (m *NextRequest) GetCount() int32 { | ||
3486 | if m != nil && m.Count != nil { | ||
3487 | return *m.Count | ||
3488 | } | ||
3489 | return 0 | ||
3490 | } | ||
3491 | |||
3492 | func (m *NextRequest) GetOffset() int32 { | ||
3493 | if m != nil && m.Offset != nil { | ||
3494 | return *m.Offset | ||
3495 | } | ||
3496 | return Default_NextRequest_Offset | ||
3497 | } | ||
3498 | |||
3499 | func (m *NextRequest) GetCompile() bool { | ||
3500 | if m != nil && m.Compile != nil { | ||
3501 | return *m.Compile | ||
3502 | } | ||
3503 | return Default_NextRequest_Compile | ||
3504 | } | ||
3505 | |||
3506 | type QueryResult struct { | ||
3507 | Cursor *Cursor `protobuf:"bytes,1,opt,name=cursor" json:"cursor,omitempty"` | ||
3508 | Result []*EntityProto `protobuf:"bytes,2,rep,name=result" json:"result,omitempty"` | ||
3509 | SkippedResults *int32 `protobuf:"varint,7,opt,name=skipped_results,json=skippedResults" json:"skipped_results,omitempty"` | ||
3510 | MoreResults *bool `protobuf:"varint,3,req,name=more_results,json=moreResults" json:"more_results,omitempty"` | ||
3511 | KeysOnly *bool `protobuf:"varint,4,opt,name=keys_only,json=keysOnly" json:"keys_only,omitempty"` | ||
3512 | IndexOnly *bool `protobuf:"varint,9,opt,name=index_only,json=indexOnly" json:"index_only,omitempty"` | ||
3513 | SmallOps *bool `protobuf:"varint,10,opt,name=small_ops,json=smallOps" json:"small_ops,omitempty"` | ||
3514 | CompiledQuery *CompiledQuery `protobuf:"bytes,5,opt,name=compiled_query,json=compiledQuery" json:"compiled_query,omitempty"` | ||
3515 | CompiledCursor *CompiledCursor `protobuf:"bytes,6,opt,name=compiled_cursor,json=compiledCursor" json:"compiled_cursor,omitempty"` | ||
3516 | Index []*CompositeIndex `protobuf:"bytes,8,rep,name=index" json:"index,omitempty"` | ||
3517 | Version []int64 `protobuf:"varint,11,rep,name=version" json:"version,omitempty"` | ||
3518 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
3519 | XXX_unrecognized []byte `json:"-"` | ||
3520 | XXX_sizecache int32 `json:"-"` | ||
3521 | } | ||
3522 | |||
3523 | func (m *QueryResult) Reset() { *m = QueryResult{} } | ||
3524 | func (m *QueryResult) String() string { return proto.CompactTextString(m) } | ||
3525 | func (*QueryResult) ProtoMessage() {} | ||
3526 | func (*QueryResult) Descriptor() ([]byte, []int) { | ||
3527 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{30} | ||
3528 | } | ||
3529 | func (m *QueryResult) XXX_Unmarshal(b []byte) error { | ||
3530 | return xxx_messageInfo_QueryResult.Unmarshal(m, b) | ||
3531 | } | ||
3532 | func (m *QueryResult) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
3533 | return xxx_messageInfo_QueryResult.Marshal(b, m, deterministic) | ||
3534 | } | ||
3535 | func (dst *QueryResult) XXX_Merge(src proto.Message) { | ||
3536 | xxx_messageInfo_QueryResult.Merge(dst, src) | ||
3537 | } | ||
3538 | func (m *QueryResult) XXX_Size() int { | ||
3539 | return xxx_messageInfo_QueryResult.Size(m) | ||
3540 | } | ||
3541 | func (m *QueryResult) XXX_DiscardUnknown() { | ||
3542 | xxx_messageInfo_QueryResult.DiscardUnknown(m) | ||
3543 | } | ||
3544 | |||
3545 | var xxx_messageInfo_QueryResult proto.InternalMessageInfo | ||
3546 | |||
3547 | func (m *QueryResult) GetCursor() *Cursor { | ||
3548 | if m != nil { | ||
3549 | return m.Cursor | ||
3550 | } | ||
3551 | return nil | ||
3552 | } | ||
3553 | |||
3554 | func (m *QueryResult) GetResult() []*EntityProto { | ||
3555 | if m != nil { | ||
3556 | return m.Result | ||
3557 | } | ||
3558 | return nil | ||
3559 | } | ||
3560 | |||
3561 | func (m *QueryResult) GetSkippedResults() int32 { | ||
3562 | if m != nil && m.SkippedResults != nil { | ||
3563 | return *m.SkippedResults | ||
3564 | } | ||
3565 | return 0 | ||
3566 | } | ||
3567 | |||
3568 | func (m *QueryResult) GetMoreResults() bool { | ||
3569 | if m != nil && m.MoreResults != nil { | ||
3570 | return *m.MoreResults | ||
3571 | } | ||
3572 | return false | ||
3573 | } | ||
3574 | |||
3575 | func (m *QueryResult) GetKeysOnly() bool { | ||
3576 | if m != nil && m.KeysOnly != nil { | ||
3577 | return *m.KeysOnly | ||
3578 | } | ||
3579 | return false | ||
3580 | } | ||
3581 | |||
3582 | func (m *QueryResult) GetIndexOnly() bool { | ||
3583 | if m != nil && m.IndexOnly != nil { | ||
3584 | return *m.IndexOnly | ||
3585 | } | ||
3586 | return false | ||
3587 | } | ||
3588 | |||
3589 | func (m *QueryResult) GetSmallOps() bool { | ||
3590 | if m != nil && m.SmallOps != nil { | ||
3591 | return *m.SmallOps | ||
3592 | } | ||
3593 | return false | ||
3594 | } | ||
3595 | |||
3596 | func (m *QueryResult) GetCompiledQuery() *CompiledQuery { | ||
3597 | if m != nil { | ||
3598 | return m.CompiledQuery | ||
3599 | } | ||
3600 | return nil | ||
3601 | } | ||
3602 | |||
3603 | func (m *QueryResult) GetCompiledCursor() *CompiledCursor { | ||
3604 | if m != nil { | ||
3605 | return m.CompiledCursor | ||
3606 | } | ||
3607 | return nil | ||
3608 | } | ||
3609 | |||
3610 | func (m *QueryResult) GetIndex() []*CompositeIndex { | ||
3611 | if m != nil { | ||
3612 | return m.Index | ||
3613 | } | ||
3614 | return nil | ||
3615 | } | ||
3616 | |||
3617 | func (m *QueryResult) GetVersion() []int64 { | ||
3618 | if m != nil { | ||
3619 | return m.Version | ||
3620 | } | ||
3621 | return nil | ||
3622 | } | ||
3623 | |||
3624 | type AllocateIdsRequest struct { | ||
3625 | Header *InternalHeader `protobuf:"bytes,4,opt,name=header" json:"header,omitempty"` | ||
3626 | ModelKey *Reference `protobuf:"bytes,1,opt,name=model_key,json=modelKey" json:"model_key,omitempty"` | ||
3627 | Size *int64 `protobuf:"varint,2,opt,name=size" json:"size,omitempty"` | ||
3628 | Max *int64 `protobuf:"varint,3,opt,name=max" json:"max,omitempty"` | ||
3629 | Reserve []*Reference `protobuf:"bytes,5,rep,name=reserve" json:"reserve,omitempty"` | ||
3630 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
3631 | XXX_unrecognized []byte `json:"-"` | ||
3632 | XXX_sizecache int32 `json:"-"` | ||
3633 | } | ||
3634 | |||
3635 | func (m *AllocateIdsRequest) Reset() { *m = AllocateIdsRequest{} } | ||
3636 | func (m *AllocateIdsRequest) String() string { return proto.CompactTextString(m) } | ||
3637 | func (*AllocateIdsRequest) ProtoMessage() {} | ||
3638 | func (*AllocateIdsRequest) Descriptor() ([]byte, []int) { | ||
3639 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{31} | ||
3640 | } | ||
3641 | func (m *AllocateIdsRequest) XXX_Unmarshal(b []byte) error { | ||
3642 | return xxx_messageInfo_AllocateIdsRequest.Unmarshal(m, b) | ||
3643 | } | ||
3644 | func (m *AllocateIdsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
3645 | return xxx_messageInfo_AllocateIdsRequest.Marshal(b, m, deterministic) | ||
3646 | } | ||
3647 | func (dst *AllocateIdsRequest) XXX_Merge(src proto.Message) { | ||
3648 | xxx_messageInfo_AllocateIdsRequest.Merge(dst, src) | ||
3649 | } | ||
3650 | func (m *AllocateIdsRequest) XXX_Size() int { | ||
3651 | return xxx_messageInfo_AllocateIdsRequest.Size(m) | ||
3652 | } | ||
3653 | func (m *AllocateIdsRequest) XXX_DiscardUnknown() { | ||
3654 | xxx_messageInfo_AllocateIdsRequest.DiscardUnknown(m) | ||
3655 | } | ||
3656 | |||
3657 | var xxx_messageInfo_AllocateIdsRequest proto.InternalMessageInfo | ||
3658 | |||
3659 | func (m *AllocateIdsRequest) GetHeader() *InternalHeader { | ||
3660 | if m != nil { | ||
3661 | return m.Header | ||
3662 | } | ||
3663 | return nil | ||
3664 | } | ||
3665 | |||
3666 | func (m *AllocateIdsRequest) GetModelKey() *Reference { | ||
3667 | if m != nil { | ||
3668 | return m.ModelKey | ||
3669 | } | ||
3670 | return nil | ||
3671 | } | ||
3672 | |||
3673 | func (m *AllocateIdsRequest) GetSize() int64 { | ||
3674 | if m != nil && m.Size != nil { | ||
3675 | return *m.Size | ||
3676 | } | ||
3677 | return 0 | ||
3678 | } | ||
3679 | |||
3680 | func (m *AllocateIdsRequest) GetMax() int64 { | ||
3681 | if m != nil && m.Max != nil { | ||
3682 | return *m.Max | ||
3683 | } | ||
3684 | return 0 | ||
3685 | } | ||
3686 | |||
3687 | func (m *AllocateIdsRequest) GetReserve() []*Reference { | ||
3688 | if m != nil { | ||
3689 | return m.Reserve | ||
3690 | } | ||
3691 | return nil | ||
3692 | } | ||
3693 | |||
3694 | type AllocateIdsResponse struct { | ||
3695 | Start *int64 `protobuf:"varint,1,req,name=start" json:"start,omitempty"` | ||
3696 | End *int64 `protobuf:"varint,2,req,name=end" json:"end,omitempty"` | ||
3697 | Cost *Cost `protobuf:"bytes,3,opt,name=cost" json:"cost,omitempty"` | ||
3698 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
3699 | XXX_unrecognized []byte `json:"-"` | ||
3700 | XXX_sizecache int32 `json:"-"` | ||
3701 | } | ||
3702 | |||
3703 | func (m *AllocateIdsResponse) Reset() { *m = AllocateIdsResponse{} } | ||
3704 | func (m *AllocateIdsResponse) String() string { return proto.CompactTextString(m) } | ||
3705 | func (*AllocateIdsResponse) ProtoMessage() {} | ||
3706 | func (*AllocateIdsResponse) Descriptor() ([]byte, []int) { | ||
3707 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{32} | ||
3708 | } | ||
3709 | func (m *AllocateIdsResponse) XXX_Unmarshal(b []byte) error { | ||
3710 | return xxx_messageInfo_AllocateIdsResponse.Unmarshal(m, b) | ||
3711 | } | ||
3712 | func (m *AllocateIdsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
3713 | return xxx_messageInfo_AllocateIdsResponse.Marshal(b, m, deterministic) | ||
3714 | } | ||
3715 | func (dst *AllocateIdsResponse) XXX_Merge(src proto.Message) { | ||
3716 | xxx_messageInfo_AllocateIdsResponse.Merge(dst, src) | ||
3717 | } | ||
3718 | func (m *AllocateIdsResponse) XXX_Size() int { | ||
3719 | return xxx_messageInfo_AllocateIdsResponse.Size(m) | ||
3720 | } | ||
3721 | func (m *AllocateIdsResponse) XXX_DiscardUnknown() { | ||
3722 | xxx_messageInfo_AllocateIdsResponse.DiscardUnknown(m) | ||
3723 | } | ||
3724 | |||
3725 | var xxx_messageInfo_AllocateIdsResponse proto.InternalMessageInfo | ||
3726 | |||
3727 | func (m *AllocateIdsResponse) GetStart() int64 { | ||
3728 | if m != nil && m.Start != nil { | ||
3729 | return *m.Start | ||
3730 | } | ||
3731 | return 0 | ||
3732 | } | ||
3733 | |||
3734 | func (m *AllocateIdsResponse) GetEnd() int64 { | ||
3735 | if m != nil && m.End != nil { | ||
3736 | return *m.End | ||
3737 | } | ||
3738 | return 0 | ||
3739 | } | ||
3740 | |||
3741 | func (m *AllocateIdsResponse) GetCost() *Cost { | ||
3742 | if m != nil { | ||
3743 | return m.Cost | ||
3744 | } | ||
3745 | return nil | ||
3746 | } | ||
3747 | |||
3748 | type CompositeIndices struct { | ||
3749 | Index []*CompositeIndex `protobuf:"bytes,1,rep,name=index" json:"index,omitempty"` | ||
3750 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
3751 | XXX_unrecognized []byte `json:"-"` | ||
3752 | XXX_sizecache int32 `json:"-"` | ||
3753 | } | ||
3754 | |||
3755 | func (m *CompositeIndices) Reset() { *m = CompositeIndices{} } | ||
3756 | func (m *CompositeIndices) String() string { return proto.CompactTextString(m) } | ||
3757 | func (*CompositeIndices) ProtoMessage() {} | ||
3758 | func (*CompositeIndices) Descriptor() ([]byte, []int) { | ||
3759 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{33} | ||
3760 | } | ||
3761 | func (m *CompositeIndices) XXX_Unmarshal(b []byte) error { | ||
3762 | return xxx_messageInfo_CompositeIndices.Unmarshal(m, b) | ||
3763 | } | ||
3764 | func (m *CompositeIndices) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
3765 | return xxx_messageInfo_CompositeIndices.Marshal(b, m, deterministic) | ||
3766 | } | ||
3767 | func (dst *CompositeIndices) XXX_Merge(src proto.Message) { | ||
3768 | xxx_messageInfo_CompositeIndices.Merge(dst, src) | ||
3769 | } | ||
3770 | func (m *CompositeIndices) XXX_Size() int { | ||
3771 | return xxx_messageInfo_CompositeIndices.Size(m) | ||
3772 | } | ||
3773 | func (m *CompositeIndices) XXX_DiscardUnknown() { | ||
3774 | xxx_messageInfo_CompositeIndices.DiscardUnknown(m) | ||
3775 | } | ||
3776 | |||
3777 | var xxx_messageInfo_CompositeIndices proto.InternalMessageInfo | ||
3778 | |||
3779 | func (m *CompositeIndices) GetIndex() []*CompositeIndex { | ||
3780 | if m != nil { | ||
3781 | return m.Index | ||
3782 | } | ||
3783 | return nil | ||
3784 | } | ||
3785 | |||
3786 | type AddActionsRequest struct { | ||
3787 | Header *InternalHeader `protobuf:"bytes,3,opt,name=header" json:"header,omitempty"` | ||
3788 | Transaction *Transaction `protobuf:"bytes,1,req,name=transaction" json:"transaction,omitempty"` | ||
3789 | Action []*Action `protobuf:"bytes,2,rep,name=action" json:"action,omitempty"` | ||
3790 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
3791 | XXX_unrecognized []byte `json:"-"` | ||
3792 | XXX_sizecache int32 `json:"-"` | ||
3793 | } | ||
3794 | |||
3795 | func (m *AddActionsRequest) Reset() { *m = AddActionsRequest{} } | ||
3796 | func (m *AddActionsRequest) String() string { return proto.CompactTextString(m) } | ||
3797 | func (*AddActionsRequest) ProtoMessage() {} | ||
3798 | func (*AddActionsRequest) Descriptor() ([]byte, []int) { | ||
3799 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{34} | ||
3800 | } | ||
3801 | func (m *AddActionsRequest) XXX_Unmarshal(b []byte) error { | ||
3802 | return xxx_messageInfo_AddActionsRequest.Unmarshal(m, b) | ||
3803 | } | ||
3804 | func (m *AddActionsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
3805 | return xxx_messageInfo_AddActionsRequest.Marshal(b, m, deterministic) | ||
3806 | } | ||
3807 | func (dst *AddActionsRequest) XXX_Merge(src proto.Message) { | ||
3808 | xxx_messageInfo_AddActionsRequest.Merge(dst, src) | ||
3809 | } | ||
3810 | func (m *AddActionsRequest) XXX_Size() int { | ||
3811 | return xxx_messageInfo_AddActionsRequest.Size(m) | ||
3812 | } | ||
3813 | func (m *AddActionsRequest) XXX_DiscardUnknown() { | ||
3814 | xxx_messageInfo_AddActionsRequest.DiscardUnknown(m) | ||
3815 | } | ||
3816 | |||
3817 | var xxx_messageInfo_AddActionsRequest proto.InternalMessageInfo | ||
3818 | |||
3819 | func (m *AddActionsRequest) GetHeader() *InternalHeader { | ||
3820 | if m != nil { | ||
3821 | return m.Header | ||
3822 | } | ||
3823 | return nil | ||
3824 | } | ||
3825 | |||
3826 | func (m *AddActionsRequest) GetTransaction() *Transaction { | ||
3827 | if m != nil { | ||
3828 | return m.Transaction | ||
3829 | } | ||
3830 | return nil | ||
3831 | } | ||
3832 | |||
3833 | func (m *AddActionsRequest) GetAction() []*Action { | ||
3834 | if m != nil { | ||
3835 | return m.Action | ||
3836 | } | ||
3837 | return nil | ||
3838 | } | ||
3839 | |||
3840 | type AddActionsResponse struct { | ||
3841 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
3842 | XXX_unrecognized []byte `json:"-"` | ||
3843 | XXX_sizecache int32 `json:"-"` | ||
3844 | } | ||
3845 | |||
3846 | func (m *AddActionsResponse) Reset() { *m = AddActionsResponse{} } | ||
3847 | func (m *AddActionsResponse) String() string { return proto.CompactTextString(m) } | ||
3848 | func (*AddActionsResponse) ProtoMessage() {} | ||
3849 | func (*AddActionsResponse) Descriptor() ([]byte, []int) { | ||
3850 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{35} | ||
3851 | } | ||
3852 | func (m *AddActionsResponse) XXX_Unmarshal(b []byte) error { | ||
3853 | return xxx_messageInfo_AddActionsResponse.Unmarshal(m, b) | ||
3854 | } | ||
3855 | func (m *AddActionsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
3856 | return xxx_messageInfo_AddActionsResponse.Marshal(b, m, deterministic) | ||
3857 | } | ||
3858 | func (dst *AddActionsResponse) XXX_Merge(src proto.Message) { | ||
3859 | xxx_messageInfo_AddActionsResponse.Merge(dst, src) | ||
3860 | } | ||
3861 | func (m *AddActionsResponse) XXX_Size() int { | ||
3862 | return xxx_messageInfo_AddActionsResponse.Size(m) | ||
3863 | } | ||
3864 | func (m *AddActionsResponse) XXX_DiscardUnknown() { | ||
3865 | xxx_messageInfo_AddActionsResponse.DiscardUnknown(m) | ||
3866 | } | ||
3867 | |||
3868 | var xxx_messageInfo_AddActionsResponse proto.InternalMessageInfo | ||
3869 | |||
3870 | type BeginTransactionRequest struct { | ||
3871 | Header *InternalHeader `protobuf:"bytes,3,opt,name=header" json:"header,omitempty"` | ||
3872 | App *string `protobuf:"bytes,1,req,name=app" json:"app,omitempty"` | ||
3873 | AllowMultipleEg *bool `protobuf:"varint,2,opt,name=allow_multiple_eg,json=allowMultipleEg,def=0" json:"allow_multiple_eg,omitempty"` | ||
3874 | DatabaseId *string `protobuf:"bytes,4,opt,name=database_id,json=databaseId" json:"database_id,omitempty"` | ||
3875 | Mode *BeginTransactionRequest_TransactionMode `protobuf:"varint,5,opt,name=mode,enum=appengine.BeginTransactionRequest_TransactionMode,def=0" json:"mode,omitempty"` | ||
3876 | PreviousTransaction *Transaction `protobuf:"bytes,7,opt,name=previous_transaction,json=previousTransaction" json:"previous_transaction,omitempty"` | ||
3877 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
3878 | XXX_unrecognized []byte `json:"-"` | ||
3879 | XXX_sizecache int32 `json:"-"` | ||
3880 | } | ||
3881 | |||
3882 | func (m *BeginTransactionRequest) Reset() { *m = BeginTransactionRequest{} } | ||
3883 | func (m *BeginTransactionRequest) String() string { return proto.CompactTextString(m) } | ||
3884 | func (*BeginTransactionRequest) ProtoMessage() {} | ||
3885 | func (*BeginTransactionRequest) Descriptor() ([]byte, []int) { | ||
3886 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{36} | ||
3887 | } | ||
3888 | func (m *BeginTransactionRequest) XXX_Unmarshal(b []byte) error { | ||
3889 | return xxx_messageInfo_BeginTransactionRequest.Unmarshal(m, b) | ||
3890 | } | ||
3891 | func (m *BeginTransactionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
3892 | return xxx_messageInfo_BeginTransactionRequest.Marshal(b, m, deterministic) | ||
3893 | } | ||
3894 | func (dst *BeginTransactionRequest) XXX_Merge(src proto.Message) { | ||
3895 | xxx_messageInfo_BeginTransactionRequest.Merge(dst, src) | ||
3896 | } | ||
3897 | func (m *BeginTransactionRequest) XXX_Size() int { | ||
3898 | return xxx_messageInfo_BeginTransactionRequest.Size(m) | ||
3899 | } | ||
3900 | func (m *BeginTransactionRequest) XXX_DiscardUnknown() { | ||
3901 | xxx_messageInfo_BeginTransactionRequest.DiscardUnknown(m) | ||
3902 | } | ||
3903 | |||
3904 | var xxx_messageInfo_BeginTransactionRequest proto.InternalMessageInfo | ||
3905 | |||
3906 | const Default_BeginTransactionRequest_AllowMultipleEg bool = false | ||
3907 | const Default_BeginTransactionRequest_Mode BeginTransactionRequest_TransactionMode = BeginTransactionRequest_UNKNOWN | ||
3908 | |||
3909 | func (m *BeginTransactionRequest) GetHeader() *InternalHeader { | ||
3910 | if m != nil { | ||
3911 | return m.Header | ||
3912 | } | ||
3913 | return nil | ||
3914 | } | ||
3915 | |||
3916 | func (m *BeginTransactionRequest) GetApp() string { | ||
3917 | if m != nil && m.App != nil { | ||
3918 | return *m.App | ||
3919 | } | ||
3920 | return "" | ||
3921 | } | ||
3922 | |||
3923 | func (m *BeginTransactionRequest) GetAllowMultipleEg() bool { | ||
3924 | if m != nil && m.AllowMultipleEg != nil { | ||
3925 | return *m.AllowMultipleEg | ||
3926 | } | ||
3927 | return Default_BeginTransactionRequest_AllowMultipleEg | ||
3928 | } | ||
3929 | |||
3930 | func (m *BeginTransactionRequest) GetDatabaseId() string { | ||
3931 | if m != nil && m.DatabaseId != nil { | ||
3932 | return *m.DatabaseId | ||
3933 | } | ||
3934 | return "" | ||
3935 | } | ||
3936 | |||
3937 | func (m *BeginTransactionRequest) GetMode() BeginTransactionRequest_TransactionMode { | ||
3938 | if m != nil && m.Mode != nil { | ||
3939 | return *m.Mode | ||
3940 | } | ||
3941 | return Default_BeginTransactionRequest_Mode | ||
3942 | } | ||
3943 | |||
3944 | func (m *BeginTransactionRequest) GetPreviousTransaction() *Transaction { | ||
3945 | if m != nil { | ||
3946 | return m.PreviousTransaction | ||
3947 | } | ||
3948 | return nil | ||
3949 | } | ||
3950 | |||
3951 | type CommitResponse struct { | ||
3952 | Cost *Cost `protobuf:"bytes,1,opt,name=cost" json:"cost,omitempty"` | ||
3953 | Version []*CommitResponse_Version `protobuf:"group,3,rep,name=Version,json=version" json:"version,omitempty"` | ||
3954 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
3955 | XXX_unrecognized []byte `json:"-"` | ||
3956 | XXX_sizecache int32 `json:"-"` | ||
3957 | } | ||
3958 | |||
3959 | func (m *CommitResponse) Reset() { *m = CommitResponse{} } | ||
3960 | func (m *CommitResponse) String() string { return proto.CompactTextString(m) } | ||
3961 | func (*CommitResponse) ProtoMessage() {} | ||
3962 | func (*CommitResponse) Descriptor() ([]byte, []int) { | ||
3963 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{37} | ||
3964 | } | ||
3965 | func (m *CommitResponse) XXX_Unmarshal(b []byte) error { | ||
3966 | return xxx_messageInfo_CommitResponse.Unmarshal(m, b) | ||
3967 | } | ||
3968 | func (m *CommitResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
3969 | return xxx_messageInfo_CommitResponse.Marshal(b, m, deterministic) | ||
3970 | } | ||
3971 | func (dst *CommitResponse) XXX_Merge(src proto.Message) { | ||
3972 | xxx_messageInfo_CommitResponse.Merge(dst, src) | ||
3973 | } | ||
3974 | func (m *CommitResponse) XXX_Size() int { | ||
3975 | return xxx_messageInfo_CommitResponse.Size(m) | ||
3976 | } | ||
3977 | func (m *CommitResponse) XXX_DiscardUnknown() { | ||
3978 | xxx_messageInfo_CommitResponse.DiscardUnknown(m) | ||
3979 | } | ||
3980 | |||
3981 | var xxx_messageInfo_CommitResponse proto.InternalMessageInfo | ||
3982 | |||
3983 | func (m *CommitResponse) GetCost() *Cost { | ||
3984 | if m != nil { | ||
3985 | return m.Cost | ||
3986 | } | ||
3987 | return nil | ||
3988 | } | ||
3989 | |||
3990 | func (m *CommitResponse) GetVersion() []*CommitResponse_Version { | ||
3991 | if m != nil { | ||
3992 | return m.Version | ||
3993 | } | ||
3994 | return nil | ||
3995 | } | ||
3996 | |||
3997 | type CommitResponse_Version struct { | ||
3998 | RootEntityKey *Reference `protobuf:"bytes,4,req,name=root_entity_key,json=rootEntityKey" json:"root_entity_key,omitempty"` | ||
3999 | Version *int64 `protobuf:"varint,5,req,name=version" json:"version,omitempty"` | ||
4000 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
4001 | XXX_unrecognized []byte `json:"-"` | ||
4002 | XXX_sizecache int32 `json:"-"` | ||
4003 | } | ||
4004 | |||
4005 | func (m *CommitResponse_Version) Reset() { *m = CommitResponse_Version{} } | ||
4006 | func (m *CommitResponse_Version) String() string { return proto.CompactTextString(m) } | ||
4007 | func (*CommitResponse_Version) ProtoMessage() {} | ||
4008 | func (*CommitResponse_Version) Descriptor() ([]byte, []int) { | ||
4009 | return fileDescriptor_datastore_v3_83b17b80c34f6179, []int{37, 0} | ||
4010 | } | ||
4011 | func (m *CommitResponse_Version) XXX_Unmarshal(b []byte) error { | ||
4012 | return xxx_messageInfo_CommitResponse_Version.Unmarshal(m, b) | ||
4013 | } | ||
4014 | func (m *CommitResponse_Version) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
4015 | return xxx_messageInfo_CommitResponse_Version.Marshal(b, m, deterministic) | ||
4016 | } | ||
4017 | func (dst *CommitResponse_Version) XXX_Merge(src proto.Message) { | ||
4018 | xxx_messageInfo_CommitResponse_Version.Merge(dst, src) | ||
4019 | } | ||
4020 | func (m *CommitResponse_Version) XXX_Size() int { | ||
4021 | return xxx_messageInfo_CommitResponse_Version.Size(m) | ||
4022 | } | ||
4023 | func (m *CommitResponse_Version) XXX_DiscardUnknown() { | ||
4024 | xxx_messageInfo_CommitResponse_Version.DiscardUnknown(m) | ||
4025 | } | ||
4026 | |||
4027 | var xxx_messageInfo_CommitResponse_Version proto.InternalMessageInfo | ||
4028 | |||
4029 | func (m *CommitResponse_Version) GetRootEntityKey() *Reference { | ||
4030 | if m != nil { | ||
4031 | return m.RootEntityKey | ||
4032 | } | ||
4033 | return nil | ||
4034 | } | ||
4035 | |||
4036 | func (m *CommitResponse_Version) GetVersion() int64 { | ||
4037 | if m != nil && m.Version != nil { | ||
4038 | return *m.Version | ||
4039 | } | ||
4040 | return 0 | ||
4041 | } | ||
4042 | |||
4043 | func init() { | ||
4044 | proto.RegisterType((*Action)(nil), "appengine.Action") | ||
4045 | proto.RegisterType((*PropertyValue)(nil), "appengine.PropertyValue") | ||
4046 | proto.RegisterType((*PropertyValue_PointValue)(nil), "appengine.PropertyValue.PointValue") | ||
4047 | proto.RegisterType((*PropertyValue_UserValue)(nil), "appengine.PropertyValue.UserValue") | ||
4048 | proto.RegisterType((*PropertyValue_ReferenceValue)(nil), "appengine.PropertyValue.ReferenceValue") | ||
4049 | proto.RegisterType((*PropertyValue_ReferenceValue_PathElement)(nil), "appengine.PropertyValue.ReferenceValue.PathElement") | ||
4050 | proto.RegisterType((*Property)(nil), "appengine.Property") | ||
4051 | proto.RegisterType((*Path)(nil), "appengine.Path") | ||
4052 | proto.RegisterType((*Path_Element)(nil), "appengine.Path.Element") | ||
4053 | proto.RegisterType((*Reference)(nil), "appengine.Reference") | ||
4054 | proto.RegisterType((*User)(nil), "appengine.User") | ||
4055 | proto.RegisterType((*EntityProto)(nil), "appengine.EntityProto") | ||
4056 | proto.RegisterType((*CompositeProperty)(nil), "appengine.CompositeProperty") | ||
4057 | proto.RegisterType((*Index)(nil), "appengine.Index") | ||
4058 | proto.RegisterType((*Index_Property)(nil), "appengine.Index.Property") | ||
4059 | proto.RegisterType((*CompositeIndex)(nil), "appengine.CompositeIndex") | ||
4060 | proto.RegisterType((*IndexPostfix)(nil), "appengine.IndexPostfix") | ||
4061 | proto.RegisterType((*IndexPostfix_IndexValue)(nil), "appengine.IndexPostfix.IndexValue") | ||
4062 | proto.RegisterType((*IndexPosition)(nil), "appengine.IndexPosition") | ||
4063 | proto.RegisterType((*Snapshot)(nil), "appengine.Snapshot") | ||
4064 | proto.RegisterType((*InternalHeader)(nil), "appengine.InternalHeader") | ||
4065 | proto.RegisterType((*Transaction)(nil), "appengine.Transaction") | ||
4066 | proto.RegisterType((*Query)(nil), "appengine.Query") | ||
4067 | proto.RegisterType((*Query_Filter)(nil), "appengine.Query.Filter") | ||
4068 | proto.RegisterType((*Query_Order)(nil), "appengine.Query.Order") | ||
4069 | proto.RegisterType((*CompiledQuery)(nil), "appengine.CompiledQuery") | ||
4070 | proto.RegisterType((*CompiledQuery_PrimaryScan)(nil), "appengine.CompiledQuery.PrimaryScan") | ||
4071 | proto.RegisterType((*CompiledQuery_MergeJoinScan)(nil), "appengine.CompiledQuery.MergeJoinScan") | ||
4072 | proto.RegisterType((*CompiledQuery_EntityFilter)(nil), "appengine.CompiledQuery.EntityFilter") | ||
4073 | proto.RegisterType((*CompiledCursor)(nil), "appengine.CompiledCursor") | ||
4074 | proto.RegisterType((*CompiledCursor_Position)(nil), "appengine.CompiledCursor.Position") | ||
4075 | proto.RegisterType((*CompiledCursor_Position_IndexValue)(nil), "appengine.CompiledCursor.Position.IndexValue") | ||
4076 | proto.RegisterType((*Cursor)(nil), "appengine.Cursor") | ||
4077 | proto.RegisterType((*Error)(nil), "appengine.Error") | ||
4078 | proto.RegisterType((*Cost)(nil), "appengine.Cost") | ||
4079 | proto.RegisterType((*Cost_CommitCost)(nil), "appengine.Cost.CommitCost") | ||
4080 | proto.RegisterType((*GetRequest)(nil), "appengine.GetRequest") | ||
4081 | proto.RegisterType((*GetResponse)(nil), "appengine.GetResponse") | ||
4082 | proto.RegisterType((*GetResponse_Entity)(nil), "appengine.GetResponse.Entity") | ||
4083 | proto.RegisterType((*PutRequest)(nil), "appengine.PutRequest") | ||
4084 | proto.RegisterType((*PutResponse)(nil), "appengine.PutResponse") | ||
4085 | proto.RegisterType((*TouchRequest)(nil), "appengine.TouchRequest") | ||
4086 | proto.RegisterType((*TouchResponse)(nil), "appengine.TouchResponse") | ||
4087 | proto.RegisterType((*DeleteRequest)(nil), "appengine.DeleteRequest") | ||
4088 | proto.RegisterType((*DeleteResponse)(nil), "appengine.DeleteResponse") | ||
4089 | proto.RegisterType((*NextRequest)(nil), "appengine.NextRequest") | ||
4090 | proto.RegisterType((*QueryResult)(nil), "appengine.QueryResult") | ||
4091 | proto.RegisterType((*AllocateIdsRequest)(nil), "appengine.AllocateIdsRequest") | ||
4092 | proto.RegisterType((*AllocateIdsResponse)(nil), "appengine.AllocateIdsResponse") | ||
4093 | proto.RegisterType((*CompositeIndices)(nil), "appengine.CompositeIndices") | ||
4094 | proto.RegisterType((*AddActionsRequest)(nil), "appengine.AddActionsRequest") | ||
4095 | proto.RegisterType((*AddActionsResponse)(nil), "appengine.AddActionsResponse") | ||
4096 | proto.RegisterType((*BeginTransactionRequest)(nil), "appengine.BeginTransactionRequest") | ||
4097 | proto.RegisterType((*CommitResponse)(nil), "appengine.CommitResponse") | ||
4098 | proto.RegisterType((*CommitResponse_Version)(nil), "appengine.CommitResponse.Version") | ||
4099 | } | ||
4100 | |||
4101 | func init() { | ||
4102 | proto.RegisterFile("google.golang.org/appengine/internal/datastore/datastore_v3.proto", fileDescriptor_datastore_v3_83b17b80c34f6179) | ||
4103 | } | ||
4104 | |||
4105 | var fileDescriptor_datastore_v3_83b17b80c34f6179 = []byte{ | ||
4106 | // 4156 bytes of a gzipped FileDescriptorProto | ||
4107 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0xcd, 0x73, 0xe3, 0x46, | ||
4108 | 0x76, 0x37, 0xc1, 0xef, 0x47, 0x89, 0x82, 0x5a, 0xf3, 0xc1, 0xa1, 0x3f, 0x46, 0xc6, 0xac, 0x6d, | ||
4109 | 0xd9, 0x6b, 0x73, 0x6c, 0xf9, 0x23, 0x5b, 0x4a, 0x76, 0x1d, 0x4a, 0xc4, 0x68, 0x90, 0xa1, 0x48, | ||
4110 | 0xb9, 0x09, 0xd9, 0x9e, 0x5c, 0x50, 0x18, 0xa2, 0x29, 0x21, 0x43, 0x02, 0x30, 0x00, 0x6a, 0x46, | ||
4111 | 0x93, 0xe4, 0x90, 0x4b, 0x2a, 0x55, 0x5b, 0xa9, 0x1c, 0x92, 0x4a, 0x25, 0xf9, 0x07, 0x72, 0xc8, | ||
4112 | 0x39, 0x95, 0xaa, 0x54, 0xf6, 0x98, 0x5b, 0x0e, 0x7b, 0xc9, 0x31, 0x95, 0x73, 0xf2, 0x27, 0x24, | ||
4113 | 0x39, 0xa4, 0xfa, 0x75, 0x03, 0x02, 0x28, 0x4a, 0x23, 0x6d, 0xf6, 0x90, 0x13, 0xd1, 0xef, 0xfd, | ||
4114 | 0xba, 0xf1, 0xfa, 0xf5, 0xfb, 0x6c, 0x10, 0xba, 0xc7, 0xbe, 0x7f, 0x3c, 0x65, 0x9d, 0x63, 0x7f, | ||
4115 | 0x6a, 0x7b, 0xc7, 0x1d, 0x3f, 0x3c, 0x7e, 0x68, 0x07, 0x01, 0xf3, 0x8e, 0x5d, 0x8f, 0x3d, 0x74, | ||
4116 | 0xbd, 0x98, 0x85, 0x9e, 0x3d, 0x7d, 0xe8, 0xd8, 0xb1, 0x1d, 0xc5, 0x7e, 0xc8, 0xce, 0x9f, 0xac, | ||
4117 | 0xd3, 0xcf, 0x3b, 0x41, 0xe8, 0xc7, 0x3e, 0xa9, 0xa7, 0x13, 0xb4, 0x1a, 0x54, 0xba, 0xe3, 0xd8, | ||
4118 | 0xf5, 0x3d, 0xed, 0x1f, 0x2b, 0xb0, 0x7a, 0x18, 0xfa, 0x01, 0x0b, 0xe3, 0xb3, 0x6f, 0xed, 0xe9, | ||
4119 | 0x9c, 0x91, 0x77, 0x00, 0x5c, 0x2f, 0xfe, 0xea, 0x0b, 0x1c, 0xb5, 0x0a, 0x9b, 0x85, 0xad, 0x22, | ||
4120 | 0xcd, 0x50, 0x88, 0x06, 0x2b, 0xcf, 0x7c, 0x7f, 0xca, 0x6c, 0x4f, 0x20, 0x94, 0xcd, 0xc2, 0x56, | ||
4121 | 0x8d, 0xe6, 0x68, 0x64, 0x13, 0x1a, 0x51, 0x1c, 0xba, 0xde, 0xb1, 0x80, 0x14, 0x37, 0x0b, 0x5b, | ||
4122 | 0x75, 0x9a, 0x25, 0x71, 0x84, 0xe3, 0xcf, 0x9f, 0x4d, 0x99, 0x40, 0x94, 0x36, 0x0b, 0x5b, 0x05, | ||
4123 | 0x9a, 0x25, 0x91, 0x3d, 0x80, 0xc0, 0x77, 0xbd, 0xf8, 0x14, 0x01, 0xe5, 0xcd, 0xc2, 0x16, 0x6c, | ||
4124 | 0x3f, 0xe8, 0xa4, 0x7b, 0xe8, 0xe4, 0xa4, 0xee, 0x1c, 0x72, 0x28, 0x3e, 0xd2, 0xcc, 0x34, 0xf2, | ||
4125 | 0xdb, 0x50, 0x9f, 0x47, 0x2c, 0x14, 0x6b, 0xd4, 0x70, 0x0d, 0xed, 0xd2, 0x35, 0x8e, 0x22, 0x16, | ||
4126 | 0x8a, 0x25, 0xce, 0x27, 0x91, 0x21, 0x34, 0x43, 0x36, 0x61, 0x21, 0xf3, 0xc6, 0x4c, 0x2c, 0xb3, | ||
4127 | 0x82, 0xcb, 0x7c, 0x70, 0xe9, 0x32, 0x34, 0x81, 0x8b, 0xb5, 0x16, 0xa6, 0xb7, 0xb7, 0x00, 0xce, | ||
4128 | 0x85, 0x25, 0x2b, 0x50, 0x78, 0xd9, 0xaa, 0x6c, 0x2a, 0x5b, 0x05, 0x5a, 0x78, 0xc9, 0x47, 0x67, | ||
4129 | 0xad, 0xaa, 0x18, 0x9d, 0xb5, 0xff, 0xa9, 0x00, 0xf5, 0x54, 0x26, 0x72, 0x0b, 0xca, 0x6c, 0x66, | ||
4130 | 0xbb, 0xd3, 0x56, 0x7d, 0x53, 0xd9, 0xaa, 0x53, 0x31, 0x20, 0xf7, 0xa1, 0x61, 0xcf, 0xe3, 0x13, | ||
4131 | 0xcb, 0xf1, 0x67, 0xb6, 0xeb, 0xb5, 0x00, 0x79, 0xc0, 0x49, 0x3d, 0xa4, 0x90, 0x36, 0xd4, 0x3c, | ||
4132 | 0x77, 0xfc, 0xdc, 0xb3, 0x67, 0xac, 0xd5, 0xc0, 0x73, 0x48, 0xc7, 0xe4, 0x13, 0x20, 0x13, 0xe6, | ||
4133 | 0xb0, 0xd0, 0x8e, 0x99, 0x63, 0xb9, 0x0e, 0xf3, 0x62, 0x37, 0x3e, 0x6b, 0xdd, 0x46, 0xd4, 0x7a, | ||
4134 | 0xca, 0x31, 0x24, 0x23, 0x0f, 0x0f, 0x42, 0xff, 0xd4, 0x75, 0x58, 0xd8, 0xba, 0xb3, 0x00, 0x3f, | ||
4135 | 0x94, 0x8c, 0xf6, 0xbf, 0x17, 0xa0, 0x99, 0xd7, 0x05, 0x51, 0xa1, 0x68, 0x07, 0x41, 0x6b, 0x15, | ||
4136 | 0xa5, 0xe4, 0x8f, 0xe4, 0x6d, 0x00, 0x2e, 0x8a, 0x15, 0x05, 0xf6, 0x98, 0xb5, 0x6e, 0xe1, 0x5a, | ||
4137 | 0x75, 0x4e, 0x19, 0x71, 0x02, 0x39, 0x82, 0x46, 0x60, 0xc7, 0x27, 0x6c, 0xca, 0x66, 0xcc, 0x8b, | ||
4138 | 0x5b, 0xcd, 0xcd, 0xe2, 0x16, 0x6c, 0x7f, 0x7e, 0x4d, 0xd5, 0x77, 0x0e, 0xed, 0xf8, 0x44, 0x17, | ||
4139 | 0x53, 0x69, 0x76, 0x9d, 0xb6, 0x0e, 0x8d, 0x0c, 0x8f, 0x10, 0x28, 0xc5, 0x67, 0x01, 0x6b, 0xad, | ||
4140 | 0xa1, 0x5c, 0xf8, 0x4c, 0x9a, 0xa0, 0xb8, 0x4e, 0x4b, 0x45, 0xf3, 0x57, 0x5c, 0x87, 0x63, 0x50, | ||
4141 | 0x87, 0xeb, 0x28, 0x22, 0x3e, 0x6b, 0xff, 0x51, 0x86, 0x5a, 0x22, 0x00, 0xe9, 0x42, 0x75, 0xc6, | ||
4142 | 0x6c, 0xcf, 0xf5, 0x8e, 0xd1, 0x69, 0x9a, 0xdb, 0x6f, 0x2e, 0x11, 0xb3, 0x73, 0x20, 0x20, 0x3b, | ||
4143 | 0x30, 0x18, 0x5a, 0x07, 0x7a, 0x77, 0x60, 0x0c, 0xf6, 0x69, 0x32, 0x8f, 0x1f, 0xa6, 0x7c, 0xb4, | ||
4144 | 0xe6, 0xa1, 0x8b, 0x9e, 0x55, 0xa7, 0x20, 0x49, 0x47, 0xa1, 0x9b, 0x0a, 0x51, 0x14, 0x82, 0xe2, | ||
4145 | 0x21, 0x76, 0xa0, 0x9c, 0xb8, 0x88, 0xb2, 0xd5, 0xd8, 0x6e, 0x5d, 0xa6, 0x1c, 0x2a, 0x60, 0xdc, | ||
4146 | 0x20, 0x66, 0xf3, 0x69, 0xec, 0x06, 0x53, 0xee, 0x76, 0xca, 0x56, 0x8d, 0xa6, 0x63, 0xf2, 0x1e, | ||
4147 | 0x40, 0xc4, 0xec, 0x70, 0x7c, 0x62, 0x3f, 0x9b, 0xb2, 0x56, 0x85, 0x7b, 0xf6, 0x4e, 0x79, 0x62, | ||
4148 | 0x4f, 0x23, 0x46, 0x33, 0x0c, 0x62, 0xc3, 0xdd, 0x49, 0x1c, 0x59, 0xb1, 0xff, 0x9c, 0x79, 0xee, | ||
4149 | 0x2b, 0x9b, 0x07, 0x12, 0xcb, 0x0f, 0xf8, 0x0f, 0xfa, 0x58, 0x73, 0xfb, 0xc3, 0x65, 0x5b, 0x7f, | ||
4150 | 0x14, 0x47, 0x66, 0x66, 0xc6, 0x10, 0x27, 0xd0, 0xdb, 0x93, 0x65, 0x64, 0xd2, 0x86, 0xca, 0xd4, | ||
4151 | 0x1f, 0xdb, 0x53, 0xd6, 0xaa, 0x73, 0x2d, 0xec, 0x28, 0xcc, 0xa3, 0x92, 0xa2, 0xfd, 0xb3, 0x02, | ||
4152 | 0x55, 0xa9, 0x47, 0xd2, 0x84, 0x8c, 0x26, 0xd5, 0x37, 0x48, 0x0d, 0x4a, 0xbb, 0xfd, 0xe1, 0xae, | ||
4153 | 0xda, 0xe4, 0x4f, 0xa6, 0xfe, 0xbd, 0xa9, 0xae, 0x71, 0xcc, 0xee, 0x53, 0x53, 0x1f, 0x99, 0x94, | ||
4154 | 0x63, 0x54, 0xb2, 0x0e, 0xab, 0x5d, 0x73, 0x78, 0x60, 0xed, 0x75, 0x4d, 0x7d, 0x7f, 0x48, 0x9f, | ||
4155 | 0xaa, 0x05, 0xb2, 0x0a, 0x75, 0x24, 0xf5, 0x8d, 0xc1, 0x13, 0x55, 0xe1, 0x33, 0x70, 0x68, 0x1a, | ||
4156 | 0x66, 0x5f, 0x57, 0x8b, 0x44, 0x85, 0x15, 0x31, 0x63, 0x38, 0x30, 0xf5, 0x81, 0xa9, 0x96, 0x52, | ||
4157 | 0xca, 0xe8, 0xe8, 0xe0, 0xa0, 0x4b, 0x9f, 0xaa, 0x65, 0xb2, 0x06, 0x0d, 0xa4, 0x74, 0x8f, 0xcc, | ||
4158 | 0xc7, 0x43, 0xaa, 0x56, 0x48, 0x03, 0xaa, 0xfb, 0x3d, 0xeb, 0xbb, 0xc7, 0xfa, 0x40, 0xad, 0x92, | ||
4159 | 0x15, 0xa8, 0xed, 0xf7, 0x2c, 0xfd, 0xa0, 0x6b, 0xf4, 0xd5, 0x1a, 0x9f, 0xbd, 0xaf, 0x0f, 0xe9, | ||
4160 | 0x68, 0x64, 0x1d, 0x0e, 0x8d, 0x81, 0xa9, 0xd6, 0x49, 0x1d, 0xca, 0xfb, 0x3d, 0xcb, 0x38, 0x50, | ||
4161 | 0x81, 0x10, 0x68, 0xee, 0xf7, 0xac, 0xc3, 0xc7, 0xc3, 0x81, 0x3e, 0x38, 0x3a, 0xd8, 0xd5, 0xa9, | ||
4162 | 0xda, 0x20, 0xb7, 0x40, 0xe5, 0xb4, 0xe1, 0xc8, 0xec, 0xf6, 0xbb, 0xbd, 0x1e, 0xd5, 0x47, 0x23, | ||
4163 | 0x75, 0x85, 0x4b, 0xbd, 0xdf, 0xb3, 0x68, 0xd7, 0xe4, 0xfb, 0x5a, 0xe5, 0x2f, 0xe4, 0x7b, 0x7f, | ||
4164 | 0xa2, 0x3f, 0x55, 0xd7, 0xf9, 0x2b, 0xf4, 0x81, 0x69, 0x98, 0x4f, 0xad, 0x43, 0x3a, 0x34, 0x87, | ||
4165 | 0xea, 0x06, 0x17, 0xd0, 0x18, 0xf4, 0xf4, 0xef, 0xad, 0x6f, 0xbb, 0xfd, 0x23, 0x5d, 0x25, 0xda, | ||
4166 | 0x8f, 0xe1, 0xf6, 0xd2, 0x33, 0xe1, 0xaa, 0x7b, 0x6c, 0x1e, 0xf4, 0xd5, 0x02, 0x7f, 0xe2, 0x9b, | ||
4167 | 0x52, 0x15, 0xed, 0x0f, 0xa0, 0xc4, 0x5d, 0x86, 0x7c, 0x06, 0xd5, 0xc4, 0x1b, 0x0b, 0xe8, 0x8d, | ||
4168 | 0x77, 0xb3, 0x67, 0x6d, 0xc7, 0x27, 0x9d, 0xc4, 0xe3, 0x12, 0x5c, 0xbb, 0x0b, 0xd5, 0x45, 0x4f, | ||
4169 | 0x53, 0x2e, 0x78, 0x5a, 0xf1, 0x82, 0xa7, 0x95, 0x32, 0x9e, 0x66, 0x43, 0x3d, 0xf5, 0xed, 0x9b, | ||
4170 | 0x47, 0x91, 0x07, 0x50, 0xe2, 0xde, 0xdf, 0x6a, 0xa2, 0x87, 0xac, 0x2d, 0x08, 0x4c, 0x91, 0xa9, | ||
4171 | 0xfd, 0x43, 0x01, 0x4a, 0x3c, 0xda, 0x9e, 0x07, 0xda, 0xc2, 0x15, 0x81, 0x56, 0xb9, 0x32, 0xd0, | ||
4172 | 0x16, 0xaf, 0x15, 0x68, 0x2b, 0x37, 0x0b, 0xb4, 0xd5, 0x4b, 0x02, 0xad, 0xf6, 0x67, 0x45, 0x68, | ||
4173 | 0xe8, 0x38, 0xf3, 0x10, 0x13, 0xfd, 0xfb, 0x50, 0x7c, 0xce, 0xce, 0x50, 0x3f, 0x8d, 0xed, 0x5b, | ||
4174 | 0x99, 0xdd, 0xa6, 0x2a, 0xa4, 0x1c, 0x40, 0xb6, 0x61, 0x45, 0xbc, 0xd0, 0x3a, 0x0e, 0xfd, 0x79, | ||
4175 | 0xd0, 0x52, 0x97, 0xab, 0xa7, 0x21, 0x40, 0xfb, 0x1c, 0x43, 0xde, 0x83, 0xb2, 0xff, 0xc2, 0x63, | ||
4176 | 0x21, 0xc6, 0xc1, 0x3c, 0x98, 0x2b, 0x8f, 0x0a, 0x2e, 0x79, 0x08, 0xa5, 0xe7, 0xae, 0xe7, 0xe0, | ||
4177 | 0x19, 0xe6, 0x23, 0x61, 0x46, 0xd0, 0xce, 0x13, 0xd7, 0x73, 0x28, 0x02, 0xc9, 0x3d, 0xa8, 0xf1, | ||
4178 | 0x5f, 0x8c, 0x7b, 0x65, 0xdc, 0x68, 0x95, 0x8f, 0x79, 0xd0, 0x7b, 0x08, 0xb5, 0x40, 0xc6, 0x10, | ||
4179 | 0x4c, 0x00, 0x8d, 0xed, 0x8d, 0x25, 0xe1, 0x85, 0xa6, 0x20, 0xf2, 0x15, 0xac, 0x84, 0xf6, 0x0b, | ||
4180 | 0x2b, 0x9d, 0xb4, 0x76, 0xf9, 0xa4, 0x46, 0x68, 0xbf, 0x48, 0x23, 0x38, 0x81, 0x52, 0x68, 0x7b, | ||
4181 | 0xcf, 0x5b, 0x64, 0xb3, 0xb0, 0x55, 0xa6, 0xf8, 0xac, 0x7d, 0x01, 0x25, 0x2e, 0x25, 0x8f, 0x08, | ||
4182 | 0xfb, 0x3d, 0xf4, 0xff, 0xee, 0x9e, 0xa9, 0x16, 0x12, 0x7f, 0xfe, 0x96, 0x47, 0x03, 0x45, 0x72, | ||
4183 | 0x0f, 0xf4, 0xd1, 0xa8, 0xbb, 0xaf, 0xab, 0x45, 0xad, 0x07, 0xeb, 0x7b, 0xfe, 0x2c, 0xf0, 0x23, | ||
4184 | 0x37, 0x66, 0xe9, 0xf2, 0xf7, 0xa0, 0xe6, 0x7a, 0x0e, 0x7b, 0x69, 0xb9, 0x0e, 0x9a, 0x56, 0x91, | ||
4185 | 0x56, 0x71, 0x6c, 0x38, 0xdc, 0xe4, 0x4e, 0x65, 0x31, 0x55, 0xe4, 0x26, 0x87, 0x03, 0xed, 0x2f, | ||
4186 | 0x15, 0x28, 0x1b, 0x1c, 0xc1, 0x8d, 0x4f, 0x9e, 0x14, 0x7a, 0x8f, 0x30, 0x4c, 0x10, 0x24, 0x93, | ||
4187 | 0xfb, 0x50, 0x1b, 0x6a, 0xb6, 0x37, 0x66, 0xbc, 0xe2, 0xc3, 0x3c, 0x50, 0xa3, 0xe9, 0x98, 0x7c, | ||
4188 | 0x99, 0xd1, 0x9f, 0x82, 0x2e, 0x7b, 0x2f, 0xa3, 0x0a, 0x7c, 0xc1, 0x12, 0x2d, 0xb6, 0xff, 0xaa, | ||
4189 | 0x90, 0x49, 0x6e, 0xcb, 0x12, 0x4f, 0x1f, 0xea, 0x8e, 0x1b, 0x32, 0xac, 0x23, 0xe5, 0x41, 0x3f, | ||
4190 | 0xb8, 0x74, 0xe1, 0x4e, 0x2f, 0x81, 0xee, 0xd4, 0xbb, 0xa3, 0x3d, 0x7d, 0xd0, 0xe3, 0x99, 0xef, | ||
4191 | 0x7c, 0x01, 0xed, 0x23, 0xa8, 0xa7, 0x10, 0x0c, 0xc7, 0x09, 0x48, 0x2d, 0x70, 0xf5, 0xf6, 0xf4, | ||
4192 | 0x74, 0xac, 0x68, 0x7f, 0xad, 0x40, 0x33, 0xd5, 0xaf, 0xd0, 0xd0, 0x6d, 0xa8, 0xd8, 0x41, 0x90, | ||
4193 | 0xa8, 0xb6, 0x4e, 0xcb, 0x76, 0x10, 0x18, 0x8e, 0x8c, 0x2d, 0x0a, 0x6a, 0x9b, 0xc7, 0x96, 0x4f, | ||
4194 | 0x01, 0x1c, 0x36, 0x71, 0x3d, 0x17, 0x85, 0x2e, 0xa2, 0xc1, 0xab, 0x8b, 0x42, 0xd3, 0x0c, 0x86, | ||
4195 | 0x7c, 0x09, 0xe5, 0x28, 0xb6, 0x63, 0x91, 0x2b, 0x9b, 0xdb, 0xf7, 0x33, 0xe0, 0xbc, 0x08, 0x9d, | ||
4196 | 0x11, 0x87, 0x51, 0x81, 0x26, 0x5f, 0xc1, 0x2d, 0xdf, 0x9b, 0x9e, 0x59, 0xf3, 0x88, 0x59, 0xee, | ||
4197 | 0xc4, 0x0a, 0xd9, 0x0f, 0x73, 0x37, 0x64, 0x4e, 0x3e, 0xa7, 0xae, 0x73, 0xc8, 0x51, 0xc4, 0x8c, | ||
4198 | 0x09, 0x95, 0x7c, 0xed, 0x6b, 0x28, 0xe3, 0x3a, 0x7c, 0xcf, 0xdf, 0x51, 0xc3, 0xd4, 0xad, 0xe1, | ||
4199 | 0xa0, 0xff, 0x54, 0xe8, 0x80, 0xea, 0xdd, 0x9e, 0x85, 0x44, 0x55, 0xe1, 0xc1, 0xbe, 0xa7, 0xf7, | ||
4200 | 0x75, 0x53, 0xef, 0xa9, 0x45, 0x9e, 0x3d, 0x74, 0x4a, 0x87, 0x54, 0x2d, 0x69, 0xff, 0x53, 0x80, | ||
4201 | 0x15, 0x94, 0xe7, 0xd0, 0x8f, 0xe2, 0x89, 0xfb, 0x92, 0xec, 0x41, 0x43, 0x98, 0xdd, 0xa9, 0x2c, | ||
4202 | 0xe8, 0xb9, 0x33, 0x68, 0x8b, 0x7b, 0x96, 0x68, 0x31, 0x90, 0x75, 0xb4, 0x9b, 0x3e, 0x27, 0x21, | ||
4203 | 0x45, 0x41, 0xa7, 0xbf, 0x22, 0xa4, 0xbc, 0x05, 0x95, 0x67, 0x6c, 0xe2, 0x87, 0x22, 0x04, 0xd6, | ||
4204 | 0x76, 0x4a, 0x71, 0x38, 0x67, 0x54, 0xd2, 0xda, 0x36, 0xc0, 0xf9, 0xfa, 0xe4, 0x01, 0xac, 0x26, | ||
4205 | 0xc6, 0x66, 0xa1, 0x71, 0x89, 0x93, 0x5b, 0x49, 0x88, 0x83, 0x5c, 0x75, 0xa3, 0x5c, 0xab, 0xba, | ||
4206 | 0xd1, 0xbe, 0x86, 0xd5, 0x64, 0x3f, 0xe2, 0xfc, 0x54, 0x21, 0x79, 0x01, 0x63, 0xca, 0x82, 0x8c, | ||
4207 | 0xca, 0x45, 0x19, 0xb5, 0x9f, 0x41, 0x6d, 0xe4, 0xd9, 0x41, 0x74, 0xe2, 0xc7, 0xdc, 0x7a, 0xe2, | ||
4208 | 0x48, 0xfa, 0xaa, 0x12, 0x47, 0x9a, 0x06, 0x15, 0x7e, 0x38, 0xf3, 0x88, 0xbb, 0xbf, 0x31, 0xe8, | ||
4209 | 0xee, 0x99, 0xc6, 0xb7, 0xba, 0xfa, 0x06, 0x01, 0xa8, 0xc8, 0xe7, 0x82, 0xa6, 0x41, 0xd3, 0x90, | ||
4210 | 0xed, 0xd8, 0x63, 0x66, 0x3b, 0x2c, 0xe4, 0x12, 0xfc, 0xe0, 0x47, 0x89, 0x04, 0x3f, 0xf8, 0x91, | ||
4211 | 0xf6, 0x17, 0x05, 0x68, 0x98, 0xa1, 0xed, 0x45, 0xb6, 0x30, 0xf7, 0xcf, 0xa0, 0x72, 0x82, 0x58, | ||
4212 | 0x74, 0xa3, 0xc6, 0x82, 0x7f, 0x66, 0x17, 0xa3, 0x12, 0x48, 0xee, 0x40, 0xe5, 0xc4, 0xf6, 0x9c, | ||
4213 | 0xa9, 0xd0, 0x5a, 0x85, 0xca, 0x51, 0x92, 0x1b, 0x95, 0xf3, 0xdc, 0xb8, 0x05, 0x2b, 0x33, 0x3b, | ||
4214 | 0x7c, 0x6e, 0x8d, 0x4f, 0x6c, 0xef, 0x98, 0x45, 0xf2, 0x60, 0xa4, 0x05, 0x36, 0x38, 0x6b, 0x4f, | ||
4215 | 0x70, 0xb4, 0xbf, 0x5f, 0x81, 0xf2, 0x37, 0x73, 0x16, 0x9e, 0x65, 0x04, 0xfa, 0xe0, 0xba, 0x02, | ||
4216 | 0xc9, 0x17, 0x17, 0x2e, 0x4b, 0xca, 0x6f, 0x2f, 0x26, 0x65, 0x22, 0x53, 0x84, 0xc8, 0x95, 0x22, | ||
4217 | 0x0b, 0x7c, 0x9a, 0x09, 0x63, 0xeb, 0x57, 0xd8, 0xda, 0x79, 0x70, 0x7b, 0x08, 0x95, 0x89, 0x3b, | ||
4218 | 0x8d, 0x51, 0x75, 0x8b, 0xd5, 0x08, 0xee, 0xa5, 0xf3, 0x08, 0xd9, 0x54, 0xc2, 0xc8, 0xbb, 0xb0, | ||
4219 | 0x22, 0x2a, 0x59, 0xeb, 0x07, 0xce, 0xc6, 0x82, 0x95, 0xf7, 0xa6, 0x48, 0x13, 0xbb, 0xff, 0x18, | ||
4220 | 0xca, 0x7e, 0xc8, 0x37, 0x5f, 0xc7, 0x25, 0xef, 0x5c, 0x58, 0x72, 0xc8, 0xb9, 0x54, 0x80, 0xc8, | ||
4221 | 0x87, 0x50, 0x3a, 0x71, 0xbd, 0x18, 0xb3, 0x46, 0x73, 0xfb, 0xf6, 0x05, 0xf0, 0x63, 0xd7, 0x8b, | ||
4222 | 0x29, 0x42, 0x78, 0x98, 0x1f, 0xfb, 0x73, 0x2f, 0x6e, 0xdd, 0xc5, 0x0c, 0x23, 0x06, 0xe4, 0x1e, | ||
4223 | 0x54, 0xfc, 0xc9, 0x24, 0x62, 0x31, 0x76, 0x96, 0xe5, 0x9d, 0xc2, 0xa7, 0x54, 0x12, 0xf8, 0x84, | ||
4224 | 0xa9, 0x3b, 0x73, 0x63, 0xec, 0x43, 0xca, 0x54, 0x0c, 0xc8, 0x2e, 0xac, 0x8d, 0xfd, 0x59, 0xe0, | ||
4225 | 0x4e, 0x99, 0x63, 0x8d, 0xe7, 0x61, 0xe4, 0x87, 0xad, 0x77, 0x2e, 0x1c, 0xd3, 0x9e, 0x44, 0xec, | ||
4226 | 0x21, 0x80, 0x36, 0xc7, 0xb9, 0x31, 0x31, 0x60, 0x83, 0x79, 0x8e, 0xb5, 0xb8, 0xce, 0xfd, 0xd7, | ||
4227 | 0xad, 0xb3, 0xce, 0x3c, 0x27, 0x4f, 0x4a, 0xc4, 0xc1, 0x48, 0x68, 0x61, 0xcc, 0x68, 0x6d, 0x60, | ||
4228 | 0x90, 0xb9, 0x77, 0x69, 0xac, 0x14, 0xe2, 0x64, 0xc2, 0xf7, 0x6f, 0xc0, 0x2d, 0x19, 0x22, 0xad, | ||
4229 | 0x80, 0x85, 0x13, 0x36, 0x8e, 0xad, 0x60, 0x6a, 0x7b, 0x58, 0xca, 0xa5, 0xc6, 0x4a, 0x24, 0xe4, | ||
4230 | 0x50, 0x20, 0x0e, 0xa7, 0xb6, 0x47, 0x34, 0xa8, 0x3f, 0x67, 0x67, 0x91, 0xc5, 0x23, 0x29, 0x76, | ||
4231 | 0xae, 0x29, 0xba, 0xc6, 0xe9, 0x43, 0x6f, 0x7a, 0x46, 0x7e, 0x02, 0x8d, 0xf8, 0xdc, 0xdb, 0xb0, | ||
4232 | 0x61, 0x6d, 0xe4, 0x4e, 0x35, 0xe3, 0x8b, 0x34, 0x0b, 0x25, 0xf7, 0xa1, 0x2a, 0x35, 0xd4, 0xba, | ||
4233 | 0x97, 0x5d, 0x3b, 0xa1, 0xf2, 0xc4, 0x3c, 0xb1, 0xdd, 0xa9, 0x7f, 0xca, 0x42, 0x6b, 0x16, 0xb5, | ||
4234 | 0xda, 0xe2, 0xb6, 0x24, 0x21, 0x1d, 0x44, 0xdc, 0x4f, 0xa3, 0x38, 0xf4, 0xbd, 0xe3, 0xd6, 0x26, | ||
4235 | 0xde, 0x93, 0xc8, 0xd1, 0xc5, 0xe0, 0xf7, 0x2e, 0x66, 0xfe, 0x7c, 0xf0, 0xfb, 0x1c, 0xee, 0x60, | ||
4236 | 0x65, 0x66, 0x3d, 0x3b, 0xb3, 0xf2, 0x68, 0x0d, 0xd1, 0x1b, 0xc8, 0xdd, 0x3d, 0x3b, 0xcc, 0x4e, | ||
4237 | 0x6a, 0x43, 0xcd, 0x71, 0xa3, 0xd8, 0xf5, 0xc6, 0x71, 0xab, 0x85, 0xef, 0x4c, 0xc7, 0xe4, 0x33, | ||
4238 | 0xb8, 0x3d, 0x73, 0x3d, 0x2b, 0xb2, 0x27, 0xcc, 0x8a, 0x5d, 0xee, 0x9b, 0x6c, 0xec, 0x7b, 0x4e, | ||
4239 | 0xd4, 0x7a, 0x80, 0x82, 0x93, 0x99, 0xeb, 0x8d, 0xec, 0x09, 0x33, 0xdd, 0x19, 0x1b, 0x09, 0x0e, | ||
4240 | 0xf9, 0x08, 0xd6, 0x11, 0x1e, 0xb2, 0x60, 0xea, 0x8e, 0x6d, 0xf1, 0xfa, 0x1f, 0xe1, 0xeb, 0xd7, | ||
4241 | 0x38, 0x83, 0x0a, 0x3a, 0xbe, 0xfa, 0x63, 0x68, 0x06, 0x2c, 0x8c, 0xdc, 0x28, 0xb6, 0xa4, 0x45, | ||
4242 | 0xbf, 0x97, 0xd5, 0xda, 0xaa, 0x64, 0x0e, 0x91, 0xd7, 0xfe, 0xcf, 0x02, 0x54, 0x84, 0x73, 0x92, | ||
4243 | 0x4f, 0x41, 0xf1, 0x03, 0xbc, 0x06, 0x69, 0x6e, 0x6f, 0x5e, 0xe2, 0xc1, 0x9d, 0x61, 0xc0, 0xeb, | ||
4244 | 0x5e, 0x3f, 0xa4, 0x8a, 0x1f, 0xdc, 0xb8, 0x28, 0xd4, 0xfe, 0x10, 0x6a, 0xc9, 0x02, 0xbc, 0xbc, | ||
4245 | 0xe8, 0xeb, 0xa3, 0x91, 0x65, 0x3e, 0xee, 0x0e, 0xd4, 0x02, 0xb9, 0x03, 0x24, 0x1d, 0x5a, 0x43, | ||
4246 | 0x6a, 0xe9, 0xdf, 0x1c, 0x75, 0xfb, 0xaa, 0x82, 0x5d, 0x1a, 0xd5, 0xbb, 0xa6, 0x4e, 0x05, 0xb2, | ||
4247 | 0x48, 0xee, 0xc1, 0xed, 0x2c, 0xe5, 0x1c, 0x5c, 0xc2, 0x14, 0x8c, 0x8f, 0x65, 0x52, 0x01, 0xc5, | ||
4248 | 0x18, 0xa8, 0x15, 0x9e, 0x16, 0xf4, 0xef, 0x8d, 0x91, 0x39, 0x52, 0xab, 0xed, 0xbf, 0x29, 0x40, | ||
4249 | 0x19, 0xc3, 0x06, 0x3f, 0x9f, 0x54, 0x72, 0x71, 0x5d, 0x73, 0x5e, 0xb9, 0x1a, 0xd9, 0x92, 0xaa, | ||
4250 | 0x81, 0x01, 0x65, 0x73, 0x79, 0xf4, 0xf9, 0xb5, 0xd6, 0x53, 0x3f, 0x85, 0x12, 0x8f, 0x52, 0xbc, | ||
4251 | 0x43, 0x1c, 0xd2, 0x9e, 0x4e, 0xad, 0x47, 0x06, 0x1d, 0xf1, 0x2a, 0x97, 0x40, 0xb3, 0x3b, 0xd8, | ||
4252 | 0xd3, 0x47, 0xe6, 0x30, 0xa1, 0xa1, 0x56, 0x1e, 0x19, 0x7d, 0x33, 0x45, 0x15, 0xb5, 0x9f, 0xd7, | ||
4253 | 0x60, 0x35, 0x89, 0x09, 0x22, 0x82, 0x3e, 0x82, 0x46, 0x10, 0xba, 0x33, 0x3b, 0x3c, 0x8b, 0xc6, | ||
4254 | 0xb6, 0x87, 0x49, 0x01, 0xb6, 0x7f, 0xb4, 0x24, 0xaa, 0x88, 0x1d, 0x1d, 0x0a, 0xec, 0x68, 0x6c, | ||
4255 | 0x7b, 0x34, 0x3b, 0x91, 0xf4, 0x61, 0x75, 0xc6, 0xc2, 0x63, 0xf6, 0x7b, 0xbe, 0xeb, 0xe1, 0x4a, | ||
4256 | 0x55, 0x8c, 0xc8, 0xef, 0x5f, 0xba, 0xd2, 0x01, 0x47, 0xff, 0x8e, 0xef, 0x7a, 0xb8, 0x56, 0x7e, | ||
4257 | 0x32, 0xf9, 0x04, 0xea, 0xa2, 0x12, 0x72, 0xd8, 0x04, 0x63, 0xc5, 0xb2, 0xda, 0x4f, 0xd4, 0xe8, | ||
4258 | 0x3d, 0x36, 0xc9, 0xc4, 0x65, 0xb8, 0x34, 0x2e, 0x37, 0xb2, 0x71, 0xf9, 0xcd, 0x6c, 0x2c, 0x5a, | ||
4259 | 0x11, 0x55, 0x78, 0x1a, 0x84, 0x2e, 0x38, 0x7c, 0x6b, 0x89, 0xc3, 0x77, 0x60, 0x23, 0xf1, 0x55, | ||
4260 | 0xcb, 0xf5, 0x26, 0xee, 0x4b, 0x2b, 0x72, 0x5f, 0x89, 0xd8, 0x53, 0xa6, 0xeb, 0x09, 0xcb, 0xe0, | ||
4261 | 0x9c, 0x91, 0xfb, 0x8a, 0x11, 0x23, 0xe9, 0xe0, 0x64, 0x0e, 0x5c, 0xc5, 0xab, 0xc9, 0xf7, 0x2e, | ||
4262 | 0x55, 0x8f, 0x68, 0xbe, 0x64, 0x46, 0xcc, 0x4d, 0x6d, 0xff, 0x52, 0x81, 0x46, 0xe6, 0x1c, 0x78, | ||
4263 | 0xf6, 0x16, 0xca, 0x42, 0x61, 0xc5, 0x55, 0x94, 0x50, 0x1f, 0x4a, 0xfa, 0x26, 0xd4, 0xa3, 0xd8, | ||
4264 | 0x0e, 0x63, 0x8b, 0x17, 0x57, 0xb2, 0xdd, 0x45, 0xc2, 0x13, 0x76, 0x46, 0x3e, 0x80, 0x35, 0xc1, | ||
4265 | 0x74, 0xbd, 0xf1, 0x74, 0x1e, 0xb9, 0xa7, 0xa2, 0x99, 0xaf, 0xd1, 0x26, 0x92, 0x8d, 0x84, 0x4a, | ||
4266 | 0xee, 0x42, 0x95, 0x67, 0x21, 0xbe, 0x86, 0x68, 0xfa, 0x2a, 0xcc, 0x73, 0xf8, 0x0a, 0x0f, 0x60, | ||
4267 | 0x95, 0x33, 0xce, 0xe7, 0x57, 0xc4, 0x2d, 0x33, 0xf3, 0x9c, 0xf3, 0xd9, 0x1d, 0xd8, 0x10, 0xaf, | ||
4268 | 0x09, 0x44, 0xf1, 0x2a, 0x2b, 0xdc, 0x3b, 0xa8, 0xd8, 0x75, 0x64, 0xc9, 0xb2, 0x56, 0x14, 0x9c, | ||
4269 | 0x1f, 0x01, 0xcf, 0x5e, 0x0b, 0xe8, 0xbb, 0x22, 0x94, 0x31, 0xcf, 0xc9, 0x61, 0x77, 0xe1, 0x1d, | ||
4270 | 0x8e, 0x9d, 0x7b, 0x76, 0x10, 0x4c, 0x5d, 0xe6, 0x58, 0x53, 0xff, 0x18, 0x43, 0x66, 0x14, 0xdb, | ||
4271 | 0xb3, 0xc0, 0x9a, 0x47, 0xad, 0x0d, 0x0c, 0x99, 0x6d, 0xe6, 0x39, 0x47, 0x09, 0xa8, 0xef, 0x1f, | ||
4272 | 0x9b, 0x09, 0xe4, 0x28, 0x6a, 0xff, 0x3e, 0xac, 0xe6, 0xec, 0x71, 0x41, 0xa7, 0x35, 0x74, 0xfe, | ||
4273 | 0x8c, 0x4e, 0xdf, 0x85, 0x95, 0x20, 0x64, 0xe7, 0xa2, 0xd5, 0x51, 0xb4, 0x86, 0xa0, 0x09, 0xb1, | ||
4274 | 0xb6, 0x60, 0x05, 0x79, 0x96, 0x20, 0xe6, 0xf3, 0x63, 0x03, 0x59, 0x87, 0xc8, 0x69, 0xbf, 0x80, | ||
4275 | 0x95, 0xec, 0x69, 0x93, 0x77, 0x33, 0x69, 0xa1, 0x99, 0xcb, 0x93, 0x69, 0x76, 0x48, 0x2a, 0xb2, | ||
4276 | 0xf5, 0x4b, 0x2a, 0x32, 0x72, 0x9d, 0x8a, 0x4c, 0xfb, 0x2f, 0xd9, 0x9c, 0x65, 0x2a, 0x84, 0x9f, | ||
4277 | 0x41, 0x2d, 0x90, 0xf5, 0x38, 0x5a, 0x52, 0xfe, 0x12, 0x3e, 0x0f, 0xee, 0x24, 0x95, 0x3b, 0x4d, | ||
4278 | 0xe7, 0xb4, 0xff, 0x56, 0x81, 0x5a, 0x5a, 0xd0, 0xe7, 0x2c, 0xef, 0xcd, 0x05, 0xcb, 0x3b, 0x90, | ||
4279 | 0x1a, 0x16, 0x0a, 0x7c, 0x1b, 0xa3, 0xc5, 0x27, 0xaf, 0x7f, 0xd7, 0xc5, 0xb6, 0xe7, 0x34, 0xdb, | ||
4280 | 0xf6, 0x6c, 0xbe, 0xae, 0xed, 0xf9, 0xe4, 0xa2, 0xc1, 0xbf, 0x95, 0xe9, 0x2d, 0x16, 0xcc, 0xbe, | ||
4281 | 0xfd, 0x7d, 0xae, 0x0f, 0xca, 0x26, 0x84, 0x77, 0xc4, 0x7e, 0xd2, 0x84, 0x90, 0xb6, 0x3f, 0xf7, | ||
4282 | 0xaf, 0xd7, 0xfe, 0x6c, 0x43, 0x45, 0xea, 0xfc, 0x0e, 0x54, 0x64, 0x4d, 0x27, 0x1b, 0x04, 0x31, | ||
4283 | 0x3a, 0x6f, 0x10, 0x0a, 0xb2, 0x4e, 0xd7, 0x7e, 0xae, 0x40, 0x59, 0x0f, 0x43, 0x3f, 0xd4, 0xfe, | ||
4284 | 0x48, 0x81, 0x3a, 0x3e, 0xed, 0xf9, 0x0e, 0xe3, 0xd9, 0x60, 0xb7, 0xdb, 0xb3, 0xa8, 0xfe, 0xcd, | ||
4285 | 0x91, 0x8e, 0xd9, 0xa0, 0x0d, 0x77, 0xf6, 0x86, 0x83, 0xbd, 0x23, 0x4a, 0xf5, 0x81, 0x69, 0x99, | ||
4286 | 0xb4, 0x3b, 0x18, 0xf1, 0xb6, 0x67, 0x38, 0x50, 0x15, 0x9e, 0x29, 0x8c, 0x81, 0xa9, 0xd3, 0x41, | ||
4287 | 0xb7, 0x6f, 0x89, 0x56, 0xb4, 0x88, 0x77, 0xb3, 0xba, 0xde, 0xb3, 0xf0, 0xd6, 0x51, 0x2d, 0xf1, | ||
4288 | 0x96, 0xd5, 0x34, 0x0e, 0xf4, 0xe1, 0x91, 0xa9, 0x96, 0xc9, 0x6d, 0x58, 0x3f, 0xd4, 0xe9, 0x81, | ||
4289 | 0x31, 0x1a, 0x19, 0xc3, 0x81, 0xd5, 0xd3, 0x07, 0x86, 0xde, 0x53, 0x2b, 0x7c, 0x9d, 0x5d, 0x63, | ||
4290 | 0xdf, 0xec, 0xee, 0xf6, 0x75, 0xb9, 0x4e, 0x95, 0x6c, 0xc2, 0x5b, 0x7b, 0xc3, 0x83, 0x03, 0xc3, | ||
4291 | 0x34, 0xf5, 0x9e, 0xb5, 0x7b, 0x64, 0x5a, 0x23, 0xd3, 0xe8, 0xf7, 0xad, 0xee, 0xe1, 0x61, 0xff, | ||
4292 | 0x29, 0x4f, 0x60, 0x35, 0x72, 0x17, 0x36, 0xf6, 0xba, 0x87, 0xdd, 0x5d, 0xa3, 0x6f, 0x98, 0x4f, | ||
4293 | 0xad, 0x9e, 0x31, 0xe2, 0xf3, 0x7b, 0x6a, 0x9d, 0x27, 0x6c, 0x93, 0x3e, 0xb5, 0xba, 0x7d, 0x14, | ||
4294 | 0xcd, 0xd4, 0xad, 0xdd, 0xee, 0xde, 0x13, 0x7d, 0xd0, 0x53, 0x81, 0x0b, 0x30, 0xea, 0x3e, 0xd2, | ||
4295 | 0x2d, 0x2e, 0x92, 0x65, 0x0e, 0x87, 0xd6, 0xb0, 0xdf, 0x53, 0x1b, 0xda, 0xbf, 0x14, 0xa1, 0xb4, | ||
4296 | 0xe7, 0x47, 0x31, 0xf7, 0x46, 0xe1, 0xac, 0x2f, 0x42, 0x37, 0x66, 0xa2, 0x7f, 0x2b, 0x53, 0xd1, | ||
4297 | 0x4b, 0x7f, 0x87, 0x24, 0x1e, 0x50, 0x32, 0x10, 0xeb, 0xd9, 0x19, 0xc7, 0x29, 0x88, 0x5b, 0x3b, | ||
4298 | 0xc7, 0xed, 0x72, 0xb2, 0x88, 0x68, 0x78, 0x85, 0x23, 0xd7, 0x2b, 0x22, 0x4e, 0x06, 0x61, 0xb9, | ||
4299 | 0xe0, 0xc7, 0x40, 0xb2, 0x20, 0xb9, 0x62, 0x09, 0x91, 0x6a, 0x06, 0x29, 0x96, 0xdc, 0x01, 0x18, | ||
4300 | 0xfb, 0xb3, 0x99, 0x1b, 0x8f, 0xfd, 0x28, 0x96, 0x5f, 0xc8, 0xda, 0x39, 0x63, 0x8f, 0x62, 0x6e, | ||
4301 | 0xf1, 0x33, 0x37, 0xe6, 0x8f, 0x34, 0x83, 0x26, 0x3b, 0x70, 0xcf, 0x0e, 0x82, 0xd0, 0x7f, 0xe9, | ||
4302 | 0xce, 0xec, 0x98, 0x59, 0xdc, 0x73, 0xed, 0x63, 0x66, 0x39, 0x6c, 0x1a, 0xdb, 0xd8, 0x13, 0x95, | ||
4303 | 0xe9, 0xdd, 0x0c, 0x60, 0x24, 0xf8, 0x3d, 0xce, 0xe6, 0x71, 0xd7, 0x75, 0xac, 0x88, 0xfd, 0x30, | ||
4304 | 0xe7, 0x1e, 0x60, 0xcd, 0x03, 0xc7, 0xe6, 0x62, 0xd6, 0x45, 0x96, 0x72, 0x9d, 0x91, 0xe4, 0x1c, | ||
4305 | 0x09, 0x46, 0xfb, 0x15, 0xc0, 0xb9, 0x14, 0x64, 0x1b, 0x6e, 0xf3, 0x3a, 0x9e, 0x45, 0x31, 0x73, | ||
4306 | 0x2c, 0xb9, 0xdb, 0x60, 0x1e, 0x47, 0x18, 0xe2, 0xcb, 0x74, 0x23, 0x65, 0xca, 0x9b, 0xc2, 0x79, | ||
4307 | 0x1c, 0x91, 0x9f, 0x40, 0xeb, 0xc2, 0x1c, 0x87, 0x4d, 0x19, 0x7f, 0x6d, 0x15, 0xa7, 0xdd, 0x59, | ||
4308 | 0x98, 0xd6, 0x13, 0x5c, 0xed, 0x4f, 0x14, 0x80, 0x7d, 0x16, 0x53, 0xc1, 0xcd, 0x34, 0xb6, 0x95, | ||
4309 | 0xeb, 0x36, 0xb6, 0xef, 0x27, 0x17, 0x08, 0xc5, 0xab, 0x63, 0xc0, 0x42, 0x97, 0xa1, 0xdc, 0xa4, | ||
4310 | 0xcb, 0xc8, 0x35, 0x11, 0xc5, 0x2b, 0x9a, 0x88, 0x52, 0xae, 0x89, 0xf8, 0x18, 0x9a, 0xf6, 0x74, | ||
4311 | 0xea, 0xbf, 0xe0, 0x05, 0x0d, 0x0b, 0x43, 0xe6, 0xa0, 0x11, 0x9c, 0xd7, 0xdb, 0xc8, 0xec, 0x49, | ||
4312 | 0x9e, 0xf6, 0xe7, 0x0a, 0x34, 0x50, 0x15, 0x51, 0xe0, 0x7b, 0x11, 0x23, 0x5f, 0x42, 0x45, 0x5e, | ||
4313 | 0x44, 0x8b, 0x8b, 0xfc, 0xb7, 0x33, 0xb2, 0x66, 0x70, 0xb2, 0x68, 0xa0, 0x12, 0xcc, 0x33, 0x42, | ||
4314 | 0xe6, 0x75, 0x97, 0x2b, 0x25, 0x45, 0x91, 0xfb, 0x50, 0x73, 0x3d, 0x4b, 0xb4, 0xd4, 0x95, 0x4c, | ||
4315 | 0x58, 0xac, 0xba, 0x1e, 0xd6, 0xb2, 0xed, 0x57, 0x50, 0x11, 0x2f, 0x21, 0x9d, 0x54, 0xa6, 0x8b, | ||
4316 | 0xfa, 0xcb, 0xdc, 0x1c, 0xa7, 0xc2, 0xc8, 0xc3, 0x29, 0xbd, 0x2e, 0x40, 0xb7, 0xa0, 0x7a, 0xca, | ||
4317 | 0x9b, 0x0f, 0xbc, 0xf4, 0xe3, 0xea, 0x4d, 0x86, 0xda, 0x1f, 0x97, 0x00, 0x0e, 0xe7, 0x4b, 0x0c, | ||
4318 | 0xa4, 0x71, 0x5d, 0x03, 0xe9, 0xe4, 0xf4, 0xf8, 0x7a, 0x99, 0x7f, 0x75, 0x43, 0x59, 0xd2, 0x69, | ||
4319 | 0x17, 0x6f, 0xda, 0x69, 0xdf, 0x87, 0x6a, 0x1c, 0xce, 0xb9, 0xa3, 0x08, 0x63, 0x4a, 0x5b, 0x5a, | ||
4320 | 0x49, 0x25, 0x6f, 0x42, 0x79, 0xe2, 0x87, 0x63, 0x86, 0x8e, 0x95, 0xb2, 0x05, 0xed, 0xc2, 0x65, | ||
4321 | 0x52, 0xed, 0xb2, 0xcb, 0x24, 0xde, 0xa0, 0x45, 0xf2, 0x1e, 0x0d, 0x0b, 0x99, 0x7c, 0x83, 0x96, | ||
4322 | 0x5c, 0xb1, 0xd1, 0x14, 0x44, 0xbe, 0x81, 0xa6, 0x3d, 0x8f, 0x7d, 0xcb, 0xe5, 0x15, 0xda, 0xd4, | ||
4323 | 0x1d, 0x9f, 0x61, 0xd9, 0xdd, 0xcc, 0x7f, 0xaf, 0x4f, 0x0f, 0xaa, 0xd3, 0x9d, 0xc7, 0xbe, 0xe1, | ||
4324 | 0x1c, 0x22, 0x72, 0xa7, 0x2a, 0x93, 0x12, 0x5d, 0xb1, 0x33, 0x64, 0xed, 0xc7, 0xb0, 0x92, 0x85, | ||
4325 | 0xf1, 0x04, 0x24, 0x81, 0xea, 0x1b, 0x3c, 0x3b, 0x8d, 0x78, 0x6a, 0x1b, 0x98, 0x46, 0xb7, 0xaf, | ||
4326 | 0x16, 0xb4, 0x18, 0x1a, 0xb8, 0xbc, 0xf4, 0x8e, 0xeb, 0xba, 0xfd, 0x03, 0x28, 0x61, 0xf8, 0x55, | ||
4327 | 0x2e, 0x7c, 0x0f, 0xc1, 0x98, 0x8b, 0xcc, 0xbc, 0xf9, 0x15, 0xb3, 0xe6, 0xf7, 0xdf, 0x05, 0x58, | ||
4328 | 0x31, 0xfd, 0xf9, 0xf8, 0xe4, 0xa2, 0x01, 0xc2, 0xaf, 0x3b, 0x42, 0x2d, 0x31, 0x1f, 0xe5, 0xa6, | ||
4329 | 0xe6, 0x93, 0x5a, 0x47, 0x71, 0x89, 0x75, 0xdc, 0xf4, 0xcc, 0xb5, 0x2f, 0x60, 0x55, 0x6e, 0x5e, | ||
4330 | 0x6a, 0x3d, 0xd1, 0x66, 0xe1, 0x0a, 0x6d, 0x6a, 0xbf, 0x50, 0x60, 0x55, 0xc4, 0xf7, 0xff, 0xbb, | ||
4331 | 0xd2, 0x2a, 0x37, 0x0c, 0xeb, 0xe5, 0x1b, 0x5d, 0x1e, 0xfd, 0xbf, 0xf4, 0x34, 0x6d, 0x08, 0xcd, | ||
4332 | 0x44, 0x7d, 0x37, 0x50, 0xfb, 0x15, 0x46, 0xfc, 0x8b, 0x02, 0x34, 0x06, 0xec, 0xe5, 0x92, 0x20, | ||
4333 | 0x5a, 0xbe, 0xee, 0x71, 0x7c, 0x98, 0x2b, 0x57, 0x1b, 0xdb, 0xeb, 0x59, 0x19, 0xc4, 0xd5, 0x63, | ||
4334 | 0x52, 0xc1, 0xa6, 0xb7, 0xa8, 0xca, 0xf2, 0x5b, 0xd4, 0xd2, 0x62, 0xb7, 0x9e, 0xb9, 0xc5, 0x2b, | ||
4335 | 0x2e, 0xbb, 0xc5, 0xd3, 0xfe, 0xad, 0x08, 0x0d, 0x6c, 0x90, 0x29, 0x8b, 0xe6, 0xd3, 0x38, 0x27, | ||
4336 | 0x4c, 0xe1, 0x6a, 0x61, 0x3a, 0x50, 0x09, 0x71, 0x92, 0x74, 0xa5, 0x4b, 0x83, 0xbf, 0x40, 0x61, | ||
4337 | 0x6b, 0xfc, 0xdc, 0x0d, 0x02, 0xe6, 0x58, 0x82, 0x92, 0x14, 0x30, 0x4d, 0x49, 0x16, 0x22, 0x44, | ||
4338 | 0xbc, 0xfc, 0x9c, 0xf9, 0x21, 0x4b, 0x51, 0x45, 0xbc, 0x4f, 0x68, 0x70, 0x5a, 0x02, 0xc9, 0xdd, | ||
4339 | 0x37, 0x88, 0xca, 0xe0, 0xfc, 0xbe, 0x21, 0xed, 0x35, 0x91, 0x5b, 0x47, 0xae, 0xe8, 0x35, 0x91, | ||
4340 | 0xcd, 0xbb, 0xa8, 0x99, 0x3d, 0x9d, 0x5a, 0x7e, 0x10, 0xa1, 0xd3, 0xd4, 0x68, 0x0d, 0x09, 0xc3, | ||
4341 | 0x20, 0x22, 0x5f, 0x43, 0x7a, 0x5d, 0x2c, 0x6f, 0xc9, 0xc5, 0x39, 0xb6, 0x2e, 0xbb, 0x58, 0xa0, | ||
4342 | 0xab, 0xe3, 0xdc, 0xfd, 0xcf, 0x92, 0x1b, 0xea, 0xca, 0x4d, 0x6f, 0xa8, 0x1f, 0x42, 0x59, 0xc4, | ||
4343 | 0xa8, 0xda, 0xeb, 0x62, 0x94, 0xc0, 0x65, 0xed, 0xb3, 0x91, 0xb7, 0xcf, 0x5f, 0x16, 0x80, 0x74, | ||
4344 | 0xa7, 0x53, 0x7f, 0x6c, 0xc7, 0xcc, 0x70, 0xa2, 0x8b, 0x66, 0x7a, 0xed, 0xcf, 0x2e, 0x9f, 0x41, | ||
4345 | 0x7d, 0xe6, 0x3b, 0x6c, 0x6a, 0x25, 0xdf, 0x94, 0x2e, 0xad, 0x7e, 0x10, 0xc6, 0x5b, 0x52, 0x02, | ||
4346 | 0x25, 0xbc, 0xc4, 0x51, 0xb0, 0xee, 0xc0, 0x67, 0xde, 0x84, 0xcd, 0xec, 0x97, 0xb2, 0x14, 0xe1, | ||
4347 | 0x8f, 0xa4, 0x03, 0xd5, 0x90, 0x45, 0x2c, 0x3c, 0x65, 0x57, 0x16, 0x55, 0x09, 0x48, 0x7b, 0x06, | ||
4348 | 0x1b, 0xb9, 0x1d, 0x49, 0x47, 0xbe, 0x85, 0x5f, 0x2b, 0xc3, 0x58, 0x7e, 0xb4, 0x12, 0x03, 0xfe, | ||
4349 | 0x3a, 0xe6, 0x25, 0x9f, 0x41, 0xf9, 0x63, 0xea, 0xf0, 0xc5, 0xab, 0xe2, 0xec, 0x1e, 0xa8, 0x59, | ||
4350 | 0x4d, 0xbb, 0x63, 0x0c, 0x36, 0xf2, 0x54, 0x0a, 0xd7, 0x3b, 0x15, 0xed, 0xef, 0x0a, 0xb0, 0xde, | ||
4351 | 0x75, 0x1c, 0xf1, 0x77, 0xc3, 0x25, 0xaa, 0x2f, 0x5e, 0x57, 0xf5, 0x0b, 0x81, 0x58, 0x84, 0x89, | ||
4352 | 0x6b, 0x05, 0xe2, 0x0f, 0xa1, 0x92, 0xd6, 0x5a, 0xc5, 0x05, 0x77, 0x16, 0x72, 0x51, 0x09, 0xd0, | ||
4353 | 0x6e, 0x01, 0xc9, 0x0a, 0x2b, 0xb4, 0xaa, 0xfd, 0x69, 0x11, 0xee, 0xee, 0xb2, 0x63, 0xd7, 0xcb, | ||
4354 | 0xbe, 0xe2, 0x57, 0xdf, 0xc9, 0xc5, 0x4f, 0x65, 0x9f, 0xc1, 0xba, 0x28, 0xe4, 0x93, 0x7f, 0x62, | ||
4355 | 0x59, 0xec, 0x58, 0x7e, 0x9d, 0x94, 0xb1, 0x6a, 0x0d, 0xf9, 0x07, 0x92, 0xad, 0xe3, 0x7f, 0xc5, | ||
4356 | 0x1c, 0x3b, 0xb6, 0x9f, 0xd9, 0x11, 0xb3, 0x5c, 0x47, 0xfe, 0x59, 0x06, 0x12, 0x92, 0xe1, 0x90, | ||
4357 | 0x21, 0x94, 0xb8, 0x0d, 0xa2, 0xeb, 0x36, 0xb7, 0xb7, 0x33, 0x62, 0x5d, 0xb2, 0x95, 0xac, 0x02, | ||
4358 | 0x0f, 0x7c, 0x87, 0xed, 0x54, 0x8f, 0x06, 0x4f, 0x06, 0xc3, 0xef, 0x06, 0x14, 0x17, 0x22, 0x06, | ||
4359 | 0xdc, 0x0a, 0x42, 0x76, 0xea, 0xfa, 0xf3, 0xc8, 0xca, 0x9e, 0x44, 0xf5, 0xca, 0x94, 0xb8, 0x91, | ||
4360 | 0xcc, 0xc9, 0x10, 0xb5, 0x9f, 0xc2, 0xda, 0xc2, 0xcb, 0x78, 0x6d, 0x26, 0x5f, 0xa7, 0xbe, 0x41, | ||
4361 | 0x56, 0xa1, 0x8e, 0x1f, 0xbb, 0x97, 0x7f, 0xfb, 0xd6, 0xfe, 0xb5, 0x80, 0x57, 0x4c, 0x33, 0x37, | ||
4362 | 0xbe, 0x59, 0x06, 0xfb, 0xcd, 0x7c, 0x06, 0x83, 0xed, 0x77, 0xf3, 0xe6, 0x9b, 0x59, 0xb0, 0xf3, | ||
4363 | 0xad, 0x00, 0xa6, 0x41, 0xa4, 0x6d, 0x43, 0x55, 0xd2, 0xc8, 0x6f, 0xc1, 0x5a, 0xe8, 0xfb, 0x71, | ||
4364 | 0xd2, 0x89, 0x8a, 0x0e, 0xe4, 0xf2, 0x3f, 0xdb, 0xac, 0x72, 0xb0, 0x48, 0x06, 0x4f, 0xf2, 0xbd, | ||
4365 | 0x48, 0x59, 0xfc, 0x0d, 0x44, 0x0e, 0x77, 0x1b, 0xbf, 0x5b, 0x4f, 0xff, 0xb7, 0xfb, 0xbf, 0x01, | ||
4366 | 0x00, 0x00, 0xff, 0xff, 0x35, 0x9f, 0x30, 0x98, 0xf2, 0x2b, 0x00, 0x00, | ||
4367 | } | ||
diff --git a/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.proto b/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.proto new file mode 100644 index 0000000..497b4d9 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/datastore/datastore_v3.proto | |||
@@ -0,0 +1,551 @@ | |||
1 | syntax = "proto2"; | ||
2 | option go_package = "datastore"; | ||
3 | |||
4 | package appengine; | ||
5 | |||
6 | message Action{} | ||
7 | |||
8 | message PropertyValue { | ||
9 | optional int64 int64Value = 1; | ||
10 | optional bool booleanValue = 2; | ||
11 | optional string stringValue = 3; | ||
12 | optional double doubleValue = 4; | ||
13 | |||
14 | optional group PointValue = 5 { | ||
15 | required double x = 6; | ||
16 | required double y = 7; | ||
17 | } | ||
18 | |||
19 | optional group UserValue = 8 { | ||
20 | required string email = 9; | ||
21 | required string auth_domain = 10; | ||
22 | optional string nickname = 11; | ||
23 | optional string federated_identity = 21; | ||
24 | optional string federated_provider = 22; | ||
25 | } | ||
26 | |||
27 | optional group ReferenceValue = 12 { | ||
28 | required string app = 13; | ||
29 | optional string name_space = 20; | ||
30 | repeated group PathElement = 14 { | ||
31 | required string type = 15; | ||
32 | optional int64 id = 16; | ||
33 | optional string name = 17; | ||
34 | } | ||
35 | } | ||
36 | } | ||
37 | |||
38 | message Property { | ||
39 | enum Meaning { | ||
40 | NO_MEANING = 0; | ||
41 | BLOB = 14; | ||
42 | TEXT = 15; | ||
43 | BYTESTRING = 16; | ||
44 | |||
45 | ATOM_CATEGORY = 1; | ||
46 | ATOM_LINK = 2; | ||
47 | ATOM_TITLE = 3; | ||
48 | ATOM_CONTENT = 4; | ||
49 | ATOM_SUMMARY = 5; | ||
50 | ATOM_AUTHOR = 6; | ||
51 | |||
52 | GD_WHEN = 7; | ||
53 | GD_EMAIL = 8; | ||
54 | GEORSS_POINT = 9; | ||
55 | GD_IM = 10; | ||
56 | |||
57 | GD_PHONENUMBER = 11; | ||
58 | GD_POSTALADDRESS = 12; | ||
59 | |||
60 | GD_RATING = 13; | ||
61 | |||
62 | BLOBKEY = 17; | ||
63 | ENTITY_PROTO = 19; | ||
64 | |||
65 | INDEX_VALUE = 18; | ||
66 | }; | ||
67 | |||
68 | optional Meaning meaning = 1 [default = NO_MEANING]; | ||
69 | optional string meaning_uri = 2; | ||
70 | |||
71 | required string name = 3; | ||
72 | |||
73 | required PropertyValue value = 5; | ||
74 | |||
75 | required bool multiple = 4; | ||
76 | |||
77 | optional bool searchable = 6 [default=false]; | ||
78 | |||
79 | enum FtsTokenizationOption { | ||
80 | HTML = 1; | ||
81 | ATOM = 2; | ||
82 | } | ||
83 | |||
84 | optional FtsTokenizationOption fts_tokenization_option = 8; | ||
85 | |||
86 | optional string locale = 9 [default = "en"]; | ||
87 | } | ||
88 | |||
89 | message Path { | ||
90 | repeated group Element = 1 { | ||
91 | required string type = 2; | ||
92 | optional int64 id = 3; | ||
93 | optional string name = 4; | ||
94 | } | ||
95 | } | ||
96 | |||
97 | message Reference { | ||
98 | required string app = 13; | ||
99 | optional string name_space = 20; | ||
100 | required Path path = 14; | ||
101 | } | ||
102 | |||
103 | message User { | ||
104 | required string email = 1; | ||
105 | required string auth_domain = 2; | ||
106 | optional string nickname = 3; | ||
107 | optional string federated_identity = 6; | ||
108 | optional string federated_provider = 7; | ||
109 | } | ||
110 | |||
111 | message EntityProto { | ||
112 | required Reference key = 13; | ||
113 | required Path entity_group = 16; | ||
114 | optional User owner = 17; | ||
115 | |||
116 | enum Kind { | ||
117 | GD_CONTACT = 1; | ||
118 | GD_EVENT = 2; | ||
119 | GD_MESSAGE = 3; | ||
120 | } | ||
121 | optional Kind kind = 4; | ||
122 | optional string kind_uri = 5; | ||
123 | |||
124 | repeated Property property = 14; | ||
125 | repeated Property raw_property = 15; | ||
126 | |||
127 | optional int32 rank = 18; | ||
128 | } | ||
129 | |||
130 | message CompositeProperty { | ||
131 | required int64 index_id = 1; | ||
132 | repeated string value = 2; | ||
133 | } | ||
134 | |||
135 | message Index { | ||
136 | required string entity_type = 1; | ||
137 | required bool ancestor = 5; | ||
138 | repeated group Property = 2 { | ||
139 | required string name = 3; | ||
140 | enum Direction { | ||
141 | ASCENDING = 1; | ||
142 | DESCENDING = 2; | ||
143 | } | ||
144 | optional Direction direction = 4 [default = ASCENDING]; | ||
145 | } | ||
146 | } | ||
147 | |||
148 | message CompositeIndex { | ||
149 | required string app_id = 1; | ||
150 | required int64 id = 2; | ||
151 | required Index definition = 3; | ||
152 | |||
153 | enum State { | ||
154 | WRITE_ONLY = 1; | ||
155 | READ_WRITE = 2; | ||
156 | DELETED = 3; | ||
157 | ERROR = 4; | ||
158 | } | ||
159 | required State state = 4; | ||
160 | |||
161 | optional bool only_use_if_required = 6 [default = false]; | ||
162 | } | ||
163 | |||
164 | message IndexPostfix { | ||
165 | message IndexValue { | ||
166 | required string property_name = 1; | ||
167 | required PropertyValue value = 2; | ||
168 | } | ||
169 | |||
170 | repeated IndexValue index_value = 1; | ||
171 | |||
172 | optional Reference key = 2; | ||
173 | |||
174 | optional bool before = 3 [default=true]; | ||
175 | } | ||
176 | |||
177 | message IndexPosition { | ||
178 | optional string key = 1; | ||
179 | |||
180 | optional bool before = 2 [default=true]; | ||
181 | } | ||
182 | |||
183 | message Snapshot { | ||
184 | enum Status { | ||
185 | INACTIVE = 0; | ||
186 | ACTIVE = 1; | ||
187 | } | ||
188 | |||
189 | required int64 ts = 1; | ||
190 | } | ||
191 | |||
192 | message InternalHeader { | ||
193 | optional string qos = 1; | ||
194 | } | ||
195 | |||
196 | message Transaction { | ||
197 | optional InternalHeader header = 4; | ||
198 | required fixed64 handle = 1; | ||
199 | required string app = 2; | ||
200 | optional bool mark_changes = 3 [default = false]; | ||
201 | } | ||
202 | |||
203 | message Query { | ||
204 | optional InternalHeader header = 39; | ||
205 | |||
206 | required string app = 1; | ||
207 | optional string name_space = 29; | ||
208 | |||
209 | optional string kind = 3; | ||
210 | optional Reference ancestor = 17; | ||
211 | |||
212 | repeated group Filter = 4 { | ||
213 | enum Operator { | ||
214 | LESS_THAN = 1; | ||
215 | LESS_THAN_OR_EQUAL = 2; | ||
216 | GREATER_THAN = 3; | ||
217 | GREATER_THAN_OR_EQUAL = 4; | ||
218 | EQUAL = 5; | ||
219 | IN = 6; | ||
220 | EXISTS = 7; | ||
221 | } | ||
222 | |||
223 | required Operator op = 6; | ||
224 | repeated Property property = 14; | ||
225 | } | ||
226 | |||
227 | optional string search_query = 8; | ||
228 | |||
229 | repeated group Order = 9 { | ||
230 | enum Direction { | ||
231 | ASCENDING = 1; | ||
232 | DESCENDING = 2; | ||
233 | } | ||
234 | |||
235 | required string property = 10; | ||
236 | optional Direction direction = 11 [default = ASCENDING]; | ||
237 | } | ||
238 | |||
239 | enum Hint { | ||
240 | ORDER_FIRST = 1; | ||
241 | ANCESTOR_FIRST = 2; | ||
242 | FILTER_FIRST = 3; | ||
243 | } | ||
244 | optional Hint hint = 18; | ||
245 | |||
246 | optional int32 count = 23; | ||
247 | |||
248 | optional int32 offset = 12 [default = 0]; | ||
249 | |||
250 | optional int32 limit = 16; | ||
251 | |||
252 | optional CompiledCursor compiled_cursor = 30; | ||
253 | optional CompiledCursor end_compiled_cursor = 31; | ||
254 | |||
255 | repeated CompositeIndex composite_index = 19; | ||
256 | |||
257 | optional bool require_perfect_plan = 20 [default = false]; | ||
258 | |||
259 | optional bool keys_only = 21 [default = false]; | ||
260 | |||
261 | optional Transaction transaction = 22; | ||
262 | |||
263 | optional bool compile = 25 [default = false]; | ||
264 | |||
265 | optional int64 failover_ms = 26; | ||
266 | |||
267 | optional bool strong = 32; | ||
268 | |||
269 | repeated string property_name = 33; | ||
270 | |||
271 | repeated string group_by_property_name = 34; | ||
272 | |||
273 | optional bool distinct = 24; | ||
274 | |||
275 | optional int64 min_safe_time_seconds = 35; | ||
276 | |||
277 | repeated string safe_replica_name = 36; | ||
278 | |||
279 | optional bool persist_offset = 37 [default=false]; | ||
280 | } | ||
281 | |||
282 | message CompiledQuery { | ||
283 | required group PrimaryScan = 1 { | ||
284 | optional string index_name = 2; | ||
285 | |||
286 | optional string start_key = 3; | ||
287 | optional bool start_inclusive = 4; | ||
288 | optional string end_key = 5; | ||
289 | optional bool end_inclusive = 6; | ||
290 | |||
291 | repeated string start_postfix_value = 22; | ||
292 | repeated string end_postfix_value = 23; | ||
293 | |||
294 | optional int64 end_unapplied_log_timestamp_us = 19; | ||
295 | } | ||
296 | |||
297 | repeated group MergeJoinScan = 7 { | ||
298 | required string index_name = 8; | ||
299 | |||
300 | repeated string prefix_value = 9; | ||
301 | |||
302 | optional bool value_prefix = 20 [default=false]; | ||
303 | } | ||
304 | |||
305 | optional Index index_def = 21; | ||
306 | |||
307 | optional int32 offset = 10 [default = 0]; | ||
308 | |||
309 | optional int32 limit = 11; | ||
310 | |||
311 | required bool keys_only = 12; | ||
312 | |||
313 | repeated string property_name = 24; | ||
314 | |||
315 | optional int32 distinct_infix_size = 25; | ||
316 | |||
317 | optional group EntityFilter = 13 { | ||
318 | optional bool distinct = 14 [default=false]; | ||
319 | |||
320 | optional string kind = 17; | ||
321 | optional Reference ancestor = 18; | ||
322 | } | ||
323 | } | ||
324 | |||
325 | message CompiledCursor { | ||
326 | optional group Position = 2 { | ||
327 | optional string start_key = 27; | ||
328 | |||
329 | repeated group IndexValue = 29 { | ||
330 | optional string property = 30; | ||
331 | required PropertyValue value = 31; | ||
332 | } | ||
333 | |||
334 | optional Reference key = 32; | ||
335 | |||
336 | optional bool start_inclusive = 28 [default=true]; | ||
337 | } | ||
338 | } | ||
339 | |||
340 | message Cursor { | ||
341 | required fixed64 cursor = 1; | ||
342 | |||
343 | optional string app = 2; | ||
344 | } | ||
345 | |||
346 | message Error { | ||
347 | enum ErrorCode { | ||
348 | BAD_REQUEST = 1; | ||
349 | CONCURRENT_TRANSACTION = 2; | ||
350 | INTERNAL_ERROR = 3; | ||
351 | NEED_INDEX = 4; | ||
352 | TIMEOUT = 5; | ||
353 | PERMISSION_DENIED = 6; | ||
354 | BIGTABLE_ERROR = 7; | ||
355 | COMMITTED_BUT_STILL_APPLYING = 8; | ||
356 | CAPABILITY_DISABLED = 9; | ||
357 | TRY_ALTERNATE_BACKEND = 10; | ||
358 | SAFE_TIME_TOO_OLD = 11; | ||
359 | } | ||
360 | } | ||
361 | |||
362 | message Cost { | ||
363 | optional int32 index_writes = 1; | ||
364 | optional int32 index_write_bytes = 2; | ||
365 | optional int32 entity_writes = 3; | ||
366 | optional int32 entity_write_bytes = 4; | ||
367 | optional group CommitCost = 5 { | ||
368 | optional int32 requested_entity_puts = 6; | ||
369 | optional int32 requested_entity_deletes = 7; | ||
370 | }; | ||
371 | optional int32 approximate_storage_delta = 8; | ||
372 | optional int32 id_sequence_updates = 9; | ||
373 | } | ||
374 | |||
375 | message GetRequest { | ||
376 | optional InternalHeader header = 6; | ||
377 | |||
378 | repeated Reference key = 1; | ||
379 | optional Transaction transaction = 2; | ||
380 | |||
381 | optional int64 failover_ms = 3; | ||
382 | |||
383 | optional bool strong = 4; | ||
384 | |||
385 | optional bool allow_deferred = 5 [default=false]; | ||
386 | } | ||
387 | |||
388 | message GetResponse { | ||
389 | repeated group Entity = 1 { | ||
390 | optional EntityProto entity = 2; | ||
391 | optional Reference key = 4; | ||
392 | |||
393 | optional int64 version = 3; | ||
394 | } | ||
395 | |||
396 | repeated Reference deferred = 5; | ||
397 | |||
398 | optional bool in_order = 6 [default=true]; | ||
399 | } | ||
400 | |||
401 | message PutRequest { | ||
402 | optional InternalHeader header = 11; | ||
403 | |||
404 | repeated EntityProto entity = 1; | ||
405 | optional Transaction transaction = 2; | ||
406 | repeated CompositeIndex composite_index = 3; | ||
407 | |||
408 | optional bool trusted = 4 [default = false]; | ||
409 | |||
410 | optional bool force = 7 [default = false]; | ||
411 | |||
412 | optional bool mark_changes = 8 [default = false]; | ||
413 | repeated Snapshot snapshot = 9; | ||
414 | |||
415 | enum AutoIdPolicy { | ||
416 | CURRENT = 0; | ||
417 | SEQUENTIAL = 1; | ||
418 | } | ||
419 | optional AutoIdPolicy auto_id_policy = 10 [default = CURRENT]; | ||
420 | } | ||
421 | |||
422 | message PutResponse { | ||
423 | repeated Reference key = 1; | ||
424 | optional Cost cost = 2; | ||
425 | repeated int64 version = 3; | ||
426 | } | ||
427 | |||
428 | message TouchRequest { | ||
429 | optional InternalHeader header = 10; | ||
430 | |||
431 | repeated Reference key = 1; | ||
432 | repeated CompositeIndex composite_index = 2; | ||
433 | optional bool force = 3 [default = false]; | ||
434 | repeated Snapshot snapshot = 9; | ||
435 | } | ||
436 | |||
437 | message TouchResponse { | ||
438 | optional Cost cost = 1; | ||
439 | } | ||
440 | |||
441 | message DeleteRequest { | ||
442 | optional InternalHeader header = 10; | ||
443 | |||
444 | repeated Reference key = 6; | ||
445 | optional Transaction transaction = 5; | ||
446 | |||
447 | optional bool trusted = 4 [default = false]; | ||
448 | |||
449 | optional bool force = 7 [default = false]; | ||
450 | |||
451 | optional bool mark_changes = 8 [default = false]; | ||
452 | repeated Snapshot snapshot = 9; | ||
453 | } | ||
454 | |||
455 | message DeleteResponse { | ||
456 | optional Cost cost = 1; | ||
457 | repeated int64 version = 3; | ||
458 | } | ||
459 | |||
460 | message NextRequest { | ||
461 | optional InternalHeader header = 5; | ||
462 | |||
463 | required Cursor cursor = 1; | ||
464 | optional int32 count = 2; | ||
465 | |||
466 | optional int32 offset = 4 [default = 0]; | ||
467 | |||
468 | optional bool compile = 3 [default = false]; | ||
469 | } | ||
470 | |||
471 | message QueryResult { | ||
472 | optional Cursor cursor = 1; | ||
473 | |||
474 | repeated EntityProto result = 2; | ||
475 | |||
476 | optional int32 skipped_results = 7; | ||
477 | |||
478 | required bool more_results = 3; | ||
479 | |||
480 | optional bool keys_only = 4; | ||
481 | |||
482 | optional bool index_only = 9; | ||
483 | |||
484 | optional bool small_ops = 10; | ||
485 | |||
486 | optional CompiledQuery compiled_query = 5; | ||
487 | |||
488 | optional CompiledCursor compiled_cursor = 6; | ||
489 | |||
490 | repeated CompositeIndex index = 8; | ||
491 | |||
492 | repeated int64 version = 11; | ||
493 | } | ||
494 | |||
495 | message AllocateIdsRequest { | ||
496 | optional InternalHeader header = 4; | ||
497 | |||
498 | optional Reference model_key = 1; | ||
499 | |||
500 | optional int64 size = 2; | ||
501 | |||
502 | optional int64 max = 3; | ||
503 | |||
504 | repeated Reference reserve = 5; | ||
505 | } | ||
506 | |||
507 | message AllocateIdsResponse { | ||
508 | required int64 start = 1; | ||
509 | required int64 end = 2; | ||
510 | optional Cost cost = 3; | ||
511 | } | ||
512 | |||
513 | message CompositeIndices { | ||
514 | repeated CompositeIndex index = 1; | ||
515 | } | ||
516 | |||
517 | message AddActionsRequest { | ||
518 | optional InternalHeader header = 3; | ||
519 | |||
520 | required Transaction transaction = 1; | ||
521 | repeated Action action = 2; | ||
522 | } | ||
523 | |||
524 | message AddActionsResponse { | ||
525 | } | ||
526 | |||
527 | message BeginTransactionRequest { | ||
528 | optional InternalHeader header = 3; | ||
529 | |||
530 | required string app = 1; | ||
531 | optional bool allow_multiple_eg = 2 [default = false]; | ||
532 | optional string database_id = 4; | ||
533 | |||
534 | enum TransactionMode { | ||
535 | UNKNOWN = 0; | ||
536 | READ_ONLY = 1; | ||
537 | READ_WRITE = 2; | ||
538 | } | ||
539 | optional TransactionMode mode = 5 [default = UNKNOWN]; | ||
540 | |||
541 | optional Transaction previous_transaction = 7; | ||
542 | } | ||
543 | |||
544 | message CommitResponse { | ||
545 | optional Cost cost = 1; | ||
546 | |||
547 | repeated group Version = 3 { | ||
548 | required Reference root_entity_key = 4; | ||
549 | required int64 version = 5; | ||
550 | } | ||
551 | } | ||
diff --git a/vendor/google.golang.org/appengine/internal/identity.go b/vendor/google.golang.org/appengine/internal/identity.go new file mode 100644 index 0000000..9b4134e --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/identity.go | |||
@@ -0,0 +1,55 @@ | |||
1 | // Copyright 2011 Google Inc. All rights reserved. | ||
2 | // Use of this source code is governed by the Apache 2.0 | ||
3 | // license that can be found in the LICENSE file. | ||
4 | |||
5 | package internal | ||
6 | |||
7 | import ( | ||
8 | "os" | ||
9 | |||
10 | netcontext "golang.org/x/net/context" | ||
11 | ) | ||
12 | |||
13 | var ( | ||
14 | // This is set to true in identity_classic.go, which is behind the appengine build tag. | ||
15 | // The appengine build tag is set for the first generation runtimes (<= Go 1.9) but not | ||
16 | // the second generation runtimes (>= Go 1.11), so this indicates whether we're on a | ||
17 | // first-gen runtime. See IsStandard below for the second-gen check. | ||
18 | appengineStandard bool | ||
19 | |||
20 | // This is set to true in identity_flex.go, which is behind the appenginevm build tag. | ||
21 | appengineFlex bool | ||
22 | ) | ||
23 | |||
24 | // AppID is the implementation of the wrapper function of the same name in | ||
25 | // ../identity.go. See that file for commentary. | ||
26 | func AppID(c netcontext.Context) string { | ||
27 | return appID(FullyQualifiedAppID(c)) | ||
28 | } | ||
29 | |||
30 | // IsStandard is the implementation of the wrapper function of the same name in | ||
31 | // ../appengine.go. See that file for commentary. | ||
32 | func IsStandard() bool { | ||
33 | // appengineStandard will be true for first-gen runtimes (<= Go 1.9) but not | ||
34 | // second-gen (>= Go 1.11). | ||
35 | return appengineStandard || IsSecondGen() | ||
36 | } | ||
37 | |||
38 | // IsStandard is the implementation of the wrapper function of the same name in | ||
39 | // ../appengine.go. See that file for commentary. | ||
40 | func IsSecondGen() bool { | ||
41 | // Second-gen runtimes set $GAE_ENV so we use that to check if we're on a second-gen runtime. | ||
42 | return os.Getenv("GAE_ENV") == "standard" | ||
43 | } | ||
44 | |||
45 | // IsFlex is the implementation of the wrapper function of the same name in | ||
46 | // ../appengine.go. See that file for commentary. | ||
47 | func IsFlex() bool { | ||
48 | return appengineFlex | ||
49 | } | ||
50 | |||
51 | // IsAppEngine is the implementation of the wrapper function of the same name in | ||
52 | // ../appengine.go. See that file for commentary. | ||
53 | func IsAppEngine() bool { | ||
54 | return IsStandard() || IsFlex() | ||
55 | } | ||
diff --git a/vendor/google.golang.org/appengine/internal/identity_classic.go b/vendor/google.golang.org/appengine/internal/identity_classic.go new file mode 100644 index 0000000..4e979f4 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/identity_classic.go | |||
@@ -0,0 +1,61 @@ | |||
1 | // Copyright 2015 Google Inc. All rights reserved. | ||
2 | // Use of this source code is governed by the Apache 2.0 | ||
3 | // license that can be found in the LICENSE file. | ||
4 | |||
5 | // +build appengine | ||
6 | |||
7 | package internal | ||
8 | |||
9 | import ( | ||
10 | "appengine" | ||
11 | |||
12 | netcontext "golang.org/x/net/context" | ||
13 | ) | ||
14 | |||
15 | func init() { | ||
16 | appengineStandard = true | ||
17 | } | ||
18 | |||
19 | func DefaultVersionHostname(ctx netcontext.Context) string { | ||
20 | c := fromContext(ctx) | ||
21 | if c == nil { | ||
22 | panic(errNotAppEngineContext) | ||
23 | } | ||
24 | return appengine.DefaultVersionHostname(c) | ||
25 | } | ||
26 | |||
27 | func Datacenter(_ netcontext.Context) string { return appengine.Datacenter() } | ||
28 | func ServerSoftware() string { return appengine.ServerSoftware() } | ||
29 | func InstanceID() string { return appengine.InstanceID() } | ||
30 | func IsDevAppServer() bool { return appengine.IsDevAppServer() } | ||
31 | |||
32 | func RequestID(ctx netcontext.Context) string { | ||
33 | c := fromContext(ctx) | ||
34 | if c == nil { | ||
35 | panic(errNotAppEngineContext) | ||
36 | } | ||
37 | return appengine.RequestID(c) | ||
38 | } | ||
39 | |||
40 | func ModuleName(ctx netcontext.Context) string { | ||
41 | c := fromContext(ctx) | ||
42 | if c == nil { | ||
43 | panic(errNotAppEngineContext) | ||
44 | } | ||
45 | return appengine.ModuleName(c) | ||
46 | } | ||
47 | func VersionID(ctx netcontext.Context) string { | ||
48 | c := fromContext(ctx) | ||
49 | if c == nil { | ||
50 | panic(errNotAppEngineContext) | ||
51 | } | ||
52 | return appengine.VersionID(c) | ||
53 | } | ||
54 | |||
55 | func fullyQualifiedAppID(ctx netcontext.Context) string { | ||
56 | c := fromContext(ctx) | ||
57 | if c == nil { | ||
58 | panic(errNotAppEngineContext) | ||
59 | } | ||
60 | return c.FullyQualifiedAppID() | ||
61 | } | ||
diff --git a/vendor/google.golang.org/appengine/internal/identity_flex.go b/vendor/google.golang.org/appengine/internal/identity_flex.go new file mode 100644 index 0000000..d5e2e7b --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/identity_flex.go | |||
@@ -0,0 +1,11 @@ | |||
1 | // Copyright 2018 Google LLC. All rights reserved. | ||
2 | // Use of this source code is governed by the Apache 2.0 | ||
3 | // license that can be found in the LICENSE file. | ||
4 | |||
5 | // +build appenginevm | ||
6 | |||
7 | package internal | ||
8 | |||
9 | func init() { | ||
10 | appengineFlex = true | ||
11 | } | ||
diff --git a/vendor/google.golang.org/appengine/internal/identity_vm.go b/vendor/google.golang.org/appengine/internal/identity_vm.go new file mode 100644 index 0000000..5d80672 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/identity_vm.go | |||
@@ -0,0 +1,134 @@ | |||
1 | // Copyright 2011 Google Inc. All rights reserved. | ||
2 | // Use of this source code is governed by the Apache 2.0 | ||
3 | // license that can be found in the LICENSE file. | ||
4 | |||
5 | // +build !appengine | ||
6 | |||
7 | package internal | ||
8 | |||
9 | import ( | ||
10 | "log" | ||
11 | "net/http" | ||
12 | "os" | ||
13 | "strings" | ||
14 | |||
15 | netcontext "golang.org/x/net/context" | ||
16 | ) | ||
17 | |||
18 | // These functions are implementations of the wrapper functions | ||
19 | // in ../appengine/identity.go. See that file for commentary. | ||
20 | |||
21 | const ( | ||
22 | hDefaultVersionHostname = "X-AppEngine-Default-Version-Hostname" | ||
23 | hRequestLogId = "X-AppEngine-Request-Log-Id" | ||
24 | hDatacenter = "X-AppEngine-Datacenter" | ||
25 | ) | ||
26 | |||
27 | func ctxHeaders(ctx netcontext.Context) http.Header { | ||
28 | c := fromContext(ctx) | ||
29 | if c == nil { | ||
30 | return nil | ||
31 | } | ||
32 | return c.Request().Header | ||
33 | } | ||
34 | |||
35 | func DefaultVersionHostname(ctx netcontext.Context) string { | ||
36 | return ctxHeaders(ctx).Get(hDefaultVersionHostname) | ||
37 | } | ||
38 | |||
39 | func RequestID(ctx netcontext.Context) string { | ||
40 | return ctxHeaders(ctx).Get(hRequestLogId) | ||
41 | } | ||
42 | |||
43 | func Datacenter(ctx netcontext.Context) string { | ||
44 | if dc := ctxHeaders(ctx).Get(hDatacenter); dc != "" { | ||
45 | return dc | ||
46 | } | ||
47 | // If the header isn't set, read zone from the metadata service. | ||
48 | // It has the format projects/[NUMERIC_PROJECT_ID]/zones/[ZONE] | ||
49 | zone, err := getMetadata("instance/zone") | ||
50 | if err != nil { | ||
51 | log.Printf("Datacenter: %v", err) | ||
52 | return "" | ||
53 | } | ||
54 | parts := strings.Split(string(zone), "/") | ||
55 | if len(parts) == 0 { | ||
56 | return "" | ||
57 | } | ||
58 | return parts[len(parts)-1] | ||
59 | } | ||
60 | |||
61 | func ServerSoftware() string { | ||
62 | // TODO(dsymonds): Remove fallback when we've verified this. | ||
63 | if s := os.Getenv("SERVER_SOFTWARE"); s != "" { | ||
64 | return s | ||
65 | } | ||
66 | if s := os.Getenv("GAE_ENV"); s != "" { | ||
67 | return s | ||
68 | } | ||
69 | return "Google App Engine/1.x.x" | ||
70 | } | ||
71 | |||
72 | // TODO(dsymonds): Remove the metadata fetches. | ||
73 | |||
74 | func ModuleName(_ netcontext.Context) string { | ||
75 | if s := os.Getenv("GAE_MODULE_NAME"); s != "" { | ||
76 | return s | ||
77 | } | ||
78 | if s := os.Getenv("GAE_SERVICE"); s != "" { | ||
79 | return s | ||
80 | } | ||
81 | return string(mustGetMetadata("instance/attributes/gae_backend_name")) | ||
82 | } | ||
83 | |||
84 | func VersionID(_ netcontext.Context) string { | ||
85 | if s1, s2 := os.Getenv("GAE_MODULE_VERSION"), os.Getenv("GAE_MINOR_VERSION"); s1 != "" && s2 != "" { | ||
86 | return s1 + "." + s2 | ||
87 | } | ||
88 | if s1, s2 := os.Getenv("GAE_VERSION"), os.Getenv("GAE_DEPLOYMENT_ID"); s1 != "" && s2 != "" { | ||
89 | return s1 + "." + s2 | ||
90 | } | ||
91 | return string(mustGetMetadata("instance/attributes/gae_backend_version")) + "." + string(mustGetMetadata("instance/attributes/gae_backend_minor_version")) | ||
92 | } | ||
93 | |||
94 | func InstanceID() string { | ||
95 | if s := os.Getenv("GAE_MODULE_INSTANCE"); s != "" { | ||
96 | return s | ||
97 | } | ||
98 | if s := os.Getenv("GAE_INSTANCE"); s != "" { | ||
99 | return s | ||
100 | } | ||
101 | return string(mustGetMetadata("instance/attributes/gae_backend_instance")) | ||
102 | } | ||
103 | |||
104 | func partitionlessAppID() string { | ||
105 | // gae_project has everything except the partition prefix. | ||
106 | if appID := os.Getenv("GAE_LONG_APP_ID"); appID != "" { | ||
107 | return appID | ||
108 | } | ||
109 | if project := os.Getenv("GOOGLE_CLOUD_PROJECT"); project != "" { | ||
110 | return project | ||
111 | } | ||
112 | return string(mustGetMetadata("instance/attributes/gae_project")) | ||
113 | } | ||
114 | |||
115 | func fullyQualifiedAppID(_ netcontext.Context) string { | ||
116 | if s := os.Getenv("GAE_APPLICATION"); s != "" { | ||
117 | return s | ||
118 | } | ||
119 | appID := partitionlessAppID() | ||
120 | |||
121 | part := os.Getenv("GAE_PARTITION") | ||
122 | if part == "" { | ||
123 | part = string(mustGetMetadata("instance/attributes/gae_partition")) | ||
124 | } | ||
125 | |||
126 | if part != "" { | ||
127 | appID = part + "~" + appID | ||
128 | } | ||
129 | return appID | ||
130 | } | ||
131 | |||
132 | func IsDevAppServer() bool { | ||
133 | return os.Getenv("RUN_WITH_DEVAPPSERVER") != "" | ||
134 | } | ||
diff --git a/vendor/google.golang.org/appengine/internal/internal.go b/vendor/google.golang.org/appengine/internal/internal.go new file mode 100644 index 0000000..051ea39 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/internal.go | |||
@@ -0,0 +1,110 @@ | |||
1 | // Copyright 2011 Google Inc. All rights reserved. | ||
2 | // Use of this source code is governed by the Apache 2.0 | ||
3 | // license that can be found in the LICENSE file. | ||
4 | |||
5 | // Package internal provides support for package appengine. | ||
6 | // | ||
7 | // Programs should not use this package directly. Its API is not stable. | ||
8 | // Use packages appengine and appengine/* instead. | ||
9 | package internal | ||
10 | |||
11 | import ( | ||
12 | "fmt" | ||
13 | |||
14 | "github.com/golang/protobuf/proto" | ||
15 | |||
16 | remotepb "google.golang.org/appengine/internal/remote_api" | ||
17 | ) | ||
18 | |||
19 | // errorCodeMaps is a map of service name to the error code map for the service. | ||
20 | var errorCodeMaps = make(map[string]map[int32]string) | ||
21 | |||
22 | // RegisterErrorCodeMap is called from API implementations to register their | ||
23 | // error code map. This should only be called from init functions. | ||
24 | func RegisterErrorCodeMap(service string, m map[int32]string) { | ||
25 | errorCodeMaps[service] = m | ||
26 | } | ||
27 | |||
28 | type timeoutCodeKey struct { | ||
29 | service string | ||
30 | code int32 | ||
31 | } | ||
32 | |||
33 | // timeoutCodes is the set of service+code pairs that represent timeouts. | ||
34 | var timeoutCodes = make(map[timeoutCodeKey]bool) | ||
35 | |||
36 | func RegisterTimeoutErrorCode(service string, code int32) { | ||
37 | timeoutCodes[timeoutCodeKey{service, code}] = true | ||
38 | } | ||
39 | |||
40 | // APIError is the type returned by appengine.Context's Call method | ||
41 | // when an API call fails in an API-specific way. This may be, for instance, | ||
42 | // a taskqueue API call failing with TaskQueueServiceError::UNKNOWN_QUEUE. | ||
43 | type APIError struct { | ||
44 | Service string | ||
45 | Detail string | ||
46 | Code int32 // API-specific error code | ||
47 | } | ||
48 | |||
49 | func (e *APIError) Error() string { | ||
50 | if e.Code == 0 { | ||
51 | if e.Detail == "" { | ||
52 | return "APIError <empty>" | ||
53 | } | ||
54 | return e.Detail | ||
55 | } | ||
56 | s := fmt.Sprintf("API error %d", e.Code) | ||
57 | if m, ok := errorCodeMaps[e.Service]; ok { | ||
58 | s += " (" + e.Service + ": " + m[e.Code] + ")" | ||
59 | } else { | ||
60 | // Shouldn't happen, but provide a bit more detail if it does. | ||
61 | s = e.Service + " " + s | ||
62 | } | ||
63 | if e.Detail != "" { | ||
64 | s += ": " + e.Detail | ||
65 | } | ||
66 | return s | ||
67 | } | ||
68 | |||
69 | func (e *APIError) IsTimeout() bool { | ||
70 | return timeoutCodes[timeoutCodeKey{e.Service, e.Code}] | ||
71 | } | ||
72 | |||
73 | // CallError is the type returned by appengine.Context's Call method when an | ||
74 | // API call fails in a generic way, such as RpcError::CAPABILITY_DISABLED. | ||
75 | type CallError struct { | ||
76 | Detail string | ||
77 | Code int32 | ||
78 | // TODO: Remove this if we get a distinguishable error code. | ||
79 | Timeout bool | ||
80 | } | ||
81 | |||
82 | func (e *CallError) Error() string { | ||
83 | var msg string | ||
84 | switch remotepb.RpcError_ErrorCode(e.Code) { | ||
85 | case remotepb.RpcError_UNKNOWN: | ||
86 | return e.Detail | ||
87 | case remotepb.RpcError_OVER_QUOTA: | ||
88 | msg = "Over quota" | ||
89 | case remotepb.RpcError_CAPABILITY_DISABLED: | ||
90 | msg = "Capability disabled" | ||
91 | case remotepb.RpcError_CANCELLED: | ||
92 | msg = "Canceled" | ||
93 | default: | ||
94 | msg = fmt.Sprintf("Call error %d", e.Code) | ||
95 | } | ||
96 | s := msg + ": " + e.Detail | ||
97 | if e.Timeout { | ||
98 | s += " (timeout)" | ||
99 | } | ||
100 | return s | ||
101 | } | ||
102 | |||
103 | func (e *CallError) IsTimeout() bool { | ||
104 | return e.Timeout | ||
105 | } | ||
106 | |||
107 | // NamespaceMods is a map from API service to a function that will mutate an RPC request to attach a namespace. | ||
108 | // The function should be prepared to be called on the same message more than once; it should only modify the | ||
109 | // RPC request the first time. | ||
110 | var NamespaceMods = make(map[string]func(m proto.Message, namespace string)) | ||
diff --git a/vendor/google.golang.org/appengine/internal/log/log_service.pb.go b/vendor/google.golang.org/appengine/internal/log/log_service.pb.go new file mode 100644 index 0000000..8545ac4 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/log/log_service.pb.go | |||
@@ -0,0 +1,1313 @@ | |||
1 | // Code generated by protoc-gen-go. DO NOT EDIT. | ||
2 | // source: google.golang.org/appengine/internal/log/log_service.proto | ||
3 | |||
4 | package log | ||
5 | |||
6 | import proto "github.com/golang/protobuf/proto" | ||
7 | import fmt "fmt" | ||
8 | import math "math" | ||
9 | |||
10 | // Reference imports to suppress errors if they are not otherwise used. | ||
11 | var _ = proto.Marshal | ||
12 | var _ = fmt.Errorf | ||
13 | var _ = math.Inf | ||
14 | |||
15 | // This is a compile-time assertion to ensure that this generated file | ||
16 | // is compatible with the proto package it is being compiled against. | ||
17 | // A compilation error at this line likely means your copy of the | ||
18 | // proto package needs to be updated. | ||
19 | const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package | ||
20 | |||
21 | type LogServiceError_ErrorCode int32 | ||
22 | |||
23 | const ( | ||
24 | LogServiceError_OK LogServiceError_ErrorCode = 0 | ||
25 | LogServiceError_INVALID_REQUEST LogServiceError_ErrorCode = 1 | ||
26 | LogServiceError_STORAGE_ERROR LogServiceError_ErrorCode = 2 | ||
27 | ) | ||
28 | |||
29 | var LogServiceError_ErrorCode_name = map[int32]string{ | ||
30 | 0: "OK", | ||
31 | 1: "INVALID_REQUEST", | ||
32 | 2: "STORAGE_ERROR", | ||
33 | } | ||
34 | var LogServiceError_ErrorCode_value = map[string]int32{ | ||
35 | "OK": 0, | ||
36 | "INVALID_REQUEST": 1, | ||
37 | "STORAGE_ERROR": 2, | ||
38 | } | ||
39 | |||
40 | func (x LogServiceError_ErrorCode) Enum() *LogServiceError_ErrorCode { | ||
41 | p := new(LogServiceError_ErrorCode) | ||
42 | *p = x | ||
43 | return p | ||
44 | } | ||
45 | func (x LogServiceError_ErrorCode) String() string { | ||
46 | return proto.EnumName(LogServiceError_ErrorCode_name, int32(x)) | ||
47 | } | ||
48 | func (x *LogServiceError_ErrorCode) UnmarshalJSON(data []byte) error { | ||
49 | value, err := proto.UnmarshalJSONEnum(LogServiceError_ErrorCode_value, data, "LogServiceError_ErrorCode") | ||
50 | if err != nil { | ||
51 | return err | ||
52 | } | ||
53 | *x = LogServiceError_ErrorCode(value) | ||
54 | return nil | ||
55 | } | ||
56 | func (LogServiceError_ErrorCode) EnumDescriptor() ([]byte, []int) { | ||
57 | return fileDescriptor_log_service_f054fd4b5012319d, []int{0, 0} | ||
58 | } | ||
59 | |||
60 | type LogServiceError struct { | ||
61 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
62 | XXX_unrecognized []byte `json:"-"` | ||
63 | XXX_sizecache int32 `json:"-"` | ||
64 | } | ||
65 | |||
66 | func (m *LogServiceError) Reset() { *m = LogServiceError{} } | ||
67 | func (m *LogServiceError) String() string { return proto.CompactTextString(m) } | ||
68 | func (*LogServiceError) ProtoMessage() {} | ||
69 | func (*LogServiceError) Descriptor() ([]byte, []int) { | ||
70 | return fileDescriptor_log_service_f054fd4b5012319d, []int{0} | ||
71 | } | ||
72 | func (m *LogServiceError) XXX_Unmarshal(b []byte) error { | ||
73 | return xxx_messageInfo_LogServiceError.Unmarshal(m, b) | ||
74 | } | ||
75 | func (m *LogServiceError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
76 | return xxx_messageInfo_LogServiceError.Marshal(b, m, deterministic) | ||
77 | } | ||
78 | func (dst *LogServiceError) XXX_Merge(src proto.Message) { | ||
79 | xxx_messageInfo_LogServiceError.Merge(dst, src) | ||
80 | } | ||
81 | func (m *LogServiceError) XXX_Size() int { | ||
82 | return xxx_messageInfo_LogServiceError.Size(m) | ||
83 | } | ||
84 | func (m *LogServiceError) XXX_DiscardUnknown() { | ||
85 | xxx_messageInfo_LogServiceError.DiscardUnknown(m) | ||
86 | } | ||
87 | |||
88 | var xxx_messageInfo_LogServiceError proto.InternalMessageInfo | ||
89 | |||
90 | type UserAppLogLine struct { | ||
91 | TimestampUsec *int64 `protobuf:"varint,1,req,name=timestamp_usec,json=timestampUsec" json:"timestamp_usec,omitempty"` | ||
92 | Level *int64 `protobuf:"varint,2,req,name=level" json:"level,omitempty"` | ||
93 | Message *string `protobuf:"bytes,3,req,name=message" json:"message,omitempty"` | ||
94 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
95 | XXX_unrecognized []byte `json:"-"` | ||
96 | XXX_sizecache int32 `json:"-"` | ||
97 | } | ||
98 | |||
99 | func (m *UserAppLogLine) Reset() { *m = UserAppLogLine{} } | ||
100 | func (m *UserAppLogLine) String() string { return proto.CompactTextString(m) } | ||
101 | func (*UserAppLogLine) ProtoMessage() {} | ||
102 | func (*UserAppLogLine) Descriptor() ([]byte, []int) { | ||
103 | return fileDescriptor_log_service_f054fd4b5012319d, []int{1} | ||
104 | } | ||
105 | func (m *UserAppLogLine) XXX_Unmarshal(b []byte) error { | ||
106 | return xxx_messageInfo_UserAppLogLine.Unmarshal(m, b) | ||
107 | } | ||
108 | func (m *UserAppLogLine) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
109 | return xxx_messageInfo_UserAppLogLine.Marshal(b, m, deterministic) | ||
110 | } | ||
111 | func (dst *UserAppLogLine) XXX_Merge(src proto.Message) { | ||
112 | xxx_messageInfo_UserAppLogLine.Merge(dst, src) | ||
113 | } | ||
114 | func (m *UserAppLogLine) XXX_Size() int { | ||
115 | return xxx_messageInfo_UserAppLogLine.Size(m) | ||
116 | } | ||
117 | func (m *UserAppLogLine) XXX_DiscardUnknown() { | ||
118 | xxx_messageInfo_UserAppLogLine.DiscardUnknown(m) | ||
119 | } | ||
120 | |||
121 | var xxx_messageInfo_UserAppLogLine proto.InternalMessageInfo | ||
122 | |||
123 | func (m *UserAppLogLine) GetTimestampUsec() int64 { | ||
124 | if m != nil && m.TimestampUsec != nil { | ||
125 | return *m.TimestampUsec | ||
126 | } | ||
127 | return 0 | ||
128 | } | ||
129 | |||
130 | func (m *UserAppLogLine) GetLevel() int64 { | ||
131 | if m != nil && m.Level != nil { | ||
132 | return *m.Level | ||
133 | } | ||
134 | return 0 | ||
135 | } | ||
136 | |||
137 | func (m *UserAppLogLine) GetMessage() string { | ||
138 | if m != nil && m.Message != nil { | ||
139 | return *m.Message | ||
140 | } | ||
141 | return "" | ||
142 | } | ||
143 | |||
144 | type UserAppLogGroup struct { | ||
145 | LogLine []*UserAppLogLine `protobuf:"bytes,2,rep,name=log_line,json=logLine" json:"log_line,omitempty"` | ||
146 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
147 | XXX_unrecognized []byte `json:"-"` | ||
148 | XXX_sizecache int32 `json:"-"` | ||
149 | } | ||
150 | |||
151 | func (m *UserAppLogGroup) Reset() { *m = UserAppLogGroup{} } | ||
152 | func (m *UserAppLogGroup) String() string { return proto.CompactTextString(m) } | ||
153 | func (*UserAppLogGroup) ProtoMessage() {} | ||
154 | func (*UserAppLogGroup) Descriptor() ([]byte, []int) { | ||
155 | return fileDescriptor_log_service_f054fd4b5012319d, []int{2} | ||
156 | } | ||
157 | func (m *UserAppLogGroup) XXX_Unmarshal(b []byte) error { | ||
158 | return xxx_messageInfo_UserAppLogGroup.Unmarshal(m, b) | ||
159 | } | ||
160 | func (m *UserAppLogGroup) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
161 | return xxx_messageInfo_UserAppLogGroup.Marshal(b, m, deterministic) | ||
162 | } | ||
163 | func (dst *UserAppLogGroup) XXX_Merge(src proto.Message) { | ||
164 | xxx_messageInfo_UserAppLogGroup.Merge(dst, src) | ||
165 | } | ||
166 | func (m *UserAppLogGroup) XXX_Size() int { | ||
167 | return xxx_messageInfo_UserAppLogGroup.Size(m) | ||
168 | } | ||
169 | func (m *UserAppLogGroup) XXX_DiscardUnknown() { | ||
170 | xxx_messageInfo_UserAppLogGroup.DiscardUnknown(m) | ||
171 | } | ||
172 | |||
173 | var xxx_messageInfo_UserAppLogGroup proto.InternalMessageInfo | ||
174 | |||
175 | func (m *UserAppLogGroup) GetLogLine() []*UserAppLogLine { | ||
176 | if m != nil { | ||
177 | return m.LogLine | ||
178 | } | ||
179 | return nil | ||
180 | } | ||
181 | |||
182 | type FlushRequest struct { | ||
183 | Logs []byte `protobuf:"bytes,1,opt,name=logs" json:"logs,omitempty"` | ||
184 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
185 | XXX_unrecognized []byte `json:"-"` | ||
186 | XXX_sizecache int32 `json:"-"` | ||
187 | } | ||
188 | |||
189 | func (m *FlushRequest) Reset() { *m = FlushRequest{} } | ||
190 | func (m *FlushRequest) String() string { return proto.CompactTextString(m) } | ||
191 | func (*FlushRequest) ProtoMessage() {} | ||
192 | func (*FlushRequest) Descriptor() ([]byte, []int) { | ||
193 | return fileDescriptor_log_service_f054fd4b5012319d, []int{3} | ||
194 | } | ||
195 | func (m *FlushRequest) XXX_Unmarshal(b []byte) error { | ||
196 | return xxx_messageInfo_FlushRequest.Unmarshal(m, b) | ||
197 | } | ||
198 | func (m *FlushRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
199 | return xxx_messageInfo_FlushRequest.Marshal(b, m, deterministic) | ||
200 | } | ||
201 | func (dst *FlushRequest) XXX_Merge(src proto.Message) { | ||
202 | xxx_messageInfo_FlushRequest.Merge(dst, src) | ||
203 | } | ||
204 | func (m *FlushRequest) XXX_Size() int { | ||
205 | return xxx_messageInfo_FlushRequest.Size(m) | ||
206 | } | ||
207 | func (m *FlushRequest) XXX_DiscardUnknown() { | ||
208 | xxx_messageInfo_FlushRequest.DiscardUnknown(m) | ||
209 | } | ||
210 | |||
211 | var xxx_messageInfo_FlushRequest proto.InternalMessageInfo | ||
212 | |||
213 | func (m *FlushRequest) GetLogs() []byte { | ||
214 | if m != nil { | ||
215 | return m.Logs | ||
216 | } | ||
217 | return nil | ||
218 | } | ||
219 | |||
220 | type SetStatusRequest struct { | ||
221 | Status *string `protobuf:"bytes,1,req,name=status" json:"status,omitempty"` | ||
222 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
223 | XXX_unrecognized []byte `json:"-"` | ||
224 | XXX_sizecache int32 `json:"-"` | ||
225 | } | ||
226 | |||
227 | func (m *SetStatusRequest) Reset() { *m = SetStatusRequest{} } | ||
228 | func (m *SetStatusRequest) String() string { return proto.CompactTextString(m) } | ||
229 | func (*SetStatusRequest) ProtoMessage() {} | ||
230 | func (*SetStatusRequest) Descriptor() ([]byte, []int) { | ||
231 | return fileDescriptor_log_service_f054fd4b5012319d, []int{4} | ||
232 | } | ||
233 | func (m *SetStatusRequest) XXX_Unmarshal(b []byte) error { | ||
234 | return xxx_messageInfo_SetStatusRequest.Unmarshal(m, b) | ||
235 | } | ||
236 | func (m *SetStatusRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
237 | return xxx_messageInfo_SetStatusRequest.Marshal(b, m, deterministic) | ||
238 | } | ||
239 | func (dst *SetStatusRequest) XXX_Merge(src proto.Message) { | ||
240 | xxx_messageInfo_SetStatusRequest.Merge(dst, src) | ||
241 | } | ||
242 | func (m *SetStatusRequest) XXX_Size() int { | ||
243 | return xxx_messageInfo_SetStatusRequest.Size(m) | ||
244 | } | ||
245 | func (m *SetStatusRequest) XXX_DiscardUnknown() { | ||
246 | xxx_messageInfo_SetStatusRequest.DiscardUnknown(m) | ||
247 | } | ||
248 | |||
249 | var xxx_messageInfo_SetStatusRequest proto.InternalMessageInfo | ||
250 | |||
251 | func (m *SetStatusRequest) GetStatus() string { | ||
252 | if m != nil && m.Status != nil { | ||
253 | return *m.Status | ||
254 | } | ||
255 | return "" | ||
256 | } | ||
257 | |||
258 | type LogOffset struct { | ||
259 | RequestId []byte `protobuf:"bytes,1,opt,name=request_id,json=requestId" json:"request_id,omitempty"` | ||
260 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
261 | XXX_unrecognized []byte `json:"-"` | ||
262 | XXX_sizecache int32 `json:"-"` | ||
263 | } | ||
264 | |||
265 | func (m *LogOffset) Reset() { *m = LogOffset{} } | ||
266 | func (m *LogOffset) String() string { return proto.CompactTextString(m) } | ||
267 | func (*LogOffset) ProtoMessage() {} | ||
268 | func (*LogOffset) Descriptor() ([]byte, []int) { | ||
269 | return fileDescriptor_log_service_f054fd4b5012319d, []int{5} | ||
270 | } | ||
271 | func (m *LogOffset) XXX_Unmarshal(b []byte) error { | ||
272 | return xxx_messageInfo_LogOffset.Unmarshal(m, b) | ||
273 | } | ||
274 | func (m *LogOffset) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
275 | return xxx_messageInfo_LogOffset.Marshal(b, m, deterministic) | ||
276 | } | ||
277 | func (dst *LogOffset) XXX_Merge(src proto.Message) { | ||
278 | xxx_messageInfo_LogOffset.Merge(dst, src) | ||
279 | } | ||
280 | func (m *LogOffset) XXX_Size() int { | ||
281 | return xxx_messageInfo_LogOffset.Size(m) | ||
282 | } | ||
283 | func (m *LogOffset) XXX_DiscardUnknown() { | ||
284 | xxx_messageInfo_LogOffset.DiscardUnknown(m) | ||
285 | } | ||
286 | |||
287 | var xxx_messageInfo_LogOffset proto.InternalMessageInfo | ||
288 | |||
289 | func (m *LogOffset) GetRequestId() []byte { | ||
290 | if m != nil { | ||
291 | return m.RequestId | ||
292 | } | ||
293 | return nil | ||
294 | } | ||
295 | |||
296 | type LogLine struct { | ||
297 | Time *int64 `protobuf:"varint,1,req,name=time" json:"time,omitempty"` | ||
298 | Level *int32 `protobuf:"varint,2,req,name=level" json:"level,omitempty"` | ||
299 | LogMessage *string `protobuf:"bytes,3,req,name=log_message,json=logMessage" json:"log_message,omitempty"` | ||
300 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
301 | XXX_unrecognized []byte `json:"-"` | ||
302 | XXX_sizecache int32 `json:"-"` | ||
303 | } | ||
304 | |||
305 | func (m *LogLine) Reset() { *m = LogLine{} } | ||
306 | func (m *LogLine) String() string { return proto.CompactTextString(m) } | ||
307 | func (*LogLine) ProtoMessage() {} | ||
308 | func (*LogLine) Descriptor() ([]byte, []int) { | ||
309 | return fileDescriptor_log_service_f054fd4b5012319d, []int{6} | ||
310 | } | ||
311 | func (m *LogLine) XXX_Unmarshal(b []byte) error { | ||
312 | return xxx_messageInfo_LogLine.Unmarshal(m, b) | ||
313 | } | ||
314 | func (m *LogLine) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
315 | return xxx_messageInfo_LogLine.Marshal(b, m, deterministic) | ||
316 | } | ||
317 | func (dst *LogLine) XXX_Merge(src proto.Message) { | ||
318 | xxx_messageInfo_LogLine.Merge(dst, src) | ||
319 | } | ||
320 | func (m *LogLine) XXX_Size() int { | ||
321 | return xxx_messageInfo_LogLine.Size(m) | ||
322 | } | ||
323 | func (m *LogLine) XXX_DiscardUnknown() { | ||
324 | xxx_messageInfo_LogLine.DiscardUnknown(m) | ||
325 | } | ||
326 | |||
327 | var xxx_messageInfo_LogLine proto.InternalMessageInfo | ||
328 | |||
329 | func (m *LogLine) GetTime() int64 { | ||
330 | if m != nil && m.Time != nil { | ||
331 | return *m.Time | ||
332 | } | ||
333 | return 0 | ||
334 | } | ||
335 | |||
336 | func (m *LogLine) GetLevel() int32 { | ||
337 | if m != nil && m.Level != nil { | ||
338 | return *m.Level | ||
339 | } | ||
340 | return 0 | ||
341 | } | ||
342 | |||
343 | func (m *LogLine) GetLogMessage() string { | ||
344 | if m != nil && m.LogMessage != nil { | ||
345 | return *m.LogMessage | ||
346 | } | ||
347 | return "" | ||
348 | } | ||
349 | |||
350 | type RequestLog struct { | ||
351 | AppId *string `protobuf:"bytes,1,req,name=app_id,json=appId" json:"app_id,omitempty"` | ||
352 | ModuleId *string `protobuf:"bytes,37,opt,name=module_id,json=moduleId,def=default" json:"module_id,omitempty"` | ||
353 | VersionId *string `protobuf:"bytes,2,req,name=version_id,json=versionId" json:"version_id,omitempty"` | ||
354 | RequestId []byte `protobuf:"bytes,3,req,name=request_id,json=requestId" json:"request_id,omitempty"` | ||
355 | Offset *LogOffset `protobuf:"bytes,35,opt,name=offset" json:"offset,omitempty"` | ||
356 | Ip *string `protobuf:"bytes,4,req,name=ip" json:"ip,omitempty"` | ||
357 | Nickname *string `protobuf:"bytes,5,opt,name=nickname" json:"nickname,omitempty"` | ||
358 | StartTime *int64 `protobuf:"varint,6,req,name=start_time,json=startTime" json:"start_time,omitempty"` | ||
359 | EndTime *int64 `protobuf:"varint,7,req,name=end_time,json=endTime" json:"end_time,omitempty"` | ||
360 | Latency *int64 `protobuf:"varint,8,req,name=latency" json:"latency,omitempty"` | ||
361 | Mcycles *int64 `protobuf:"varint,9,req,name=mcycles" json:"mcycles,omitempty"` | ||
362 | Method *string `protobuf:"bytes,10,req,name=method" json:"method,omitempty"` | ||
363 | Resource *string `protobuf:"bytes,11,req,name=resource" json:"resource,omitempty"` | ||
364 | HttpVersion *string `protobuf:"bytes,12,req,name=http_version,json=httpVersion" json:"http_version,omitempty"` | ||
365 | Status *int32 `protobuf:"varint,13,req,name=status" json:"status,omitempty"` | ||
366 | ResponseSize *int64 `protobuf:"varint,14,req,name=response_size,json=responseSize" json:"response_size,omitempty"` | ||
367 | Referrer *string `protobuf:"bytes,15,opt,name=referrer" json:"referrer,omitempty"` | ||
368 | UserAgent *string `protobuf:"bytes,16,opt,name=user_agent,json=userAgent" json:"user_agent,omitempty"` | ||
369 | UrlMapEntry *string `protobuf:"bytes,17,req,name=url_map_entry,json=urlMapEntry" json:"url_map_entry,omitempty"` | ||
370 | Combined *string `protobuf:"bytes,18,req,name=combined" json:"combined,omitempty"` | ||
371 | ApiMcycles *int64 `protobuf:"varint,19,opt,name=api_mcycles,json=apiMcycles" json:"api_mcycles,omitempty"` | ||
372 | Host *string `protobuf:"bytes,20,opt,name=host" json:"host,omitempty"` | ||
373 | Cost *float64 `protobuf:"fixed64,21,opt,name=cost" json:"cost,omitempty"` | ||
374 | TaskQueueName *string `protobuf:"bytes,22,opt,name=task_queue_name,json=taskQueueName" json:"task_queue_name,omitempty"` | ||
375 | TaskName *string `protobuf:"bytes,23,opt,name=task_name,json=taskName" json:"task_name,omitempty"` | ||
376 | WasLoadingRequest *bool `protobuf:"varint,24,opt,name=was_loading_request,json=wasLoadingRequest" json:"was_loading_request,omitempty"` | ||
377 | PendingTime *int64 `protobuf:"varint,25,opt,name=pending_time,json=pendingTime" json:"pending_time,omitempty"` | ||
378 | ReplicaIndex *int32 `protobuf:"varint,26,opt,name=replica_index,json=replicaIndex,def=-1" json:"replica_index,omitempty"` | ||
379 | Finished *bool `protobuf:"varint,27,opt,name=finished,def=1" json:"finished,omitempty"` | ||
380 | CloneKey []byte `protobuf:"bytes,28,opt,name=clone_key,json=cloneKey" json:"clone_key,omitempty"` | ||
381 | Line []*LogLine `protobuf:"bytes,29,rep,name=line" json:"line,omitempty"` | ||
382 | LinesIncomplete *bool `protobuf:"varint,36,opt,name=lines_incomplete,json=linesIncomplete" json:"lines_incomplete,omitempty"` | ||
383 | AppEngineRelease []byte `protobuf:"bytes,38,opt,name=app_engine_release,json=appEngineRelease" json:"app_engine_release,omitempty"` | ||
384 | ExitReason *int32 `protobuf:"varint,30,opt,name=exit_reason,json=exitReason" json:"exit_reason,omitempty"` | ||
385 | WasThrottledForTime *bool `protobuf:"varint,31,opt,name=was_throttled_for_time,json=wasThrottledForTime" json:"was_throttled_for_time,omitempty"` | ||
386 | WasThrottledForRequests *bool `protobuf:"varint,32,opt,name=was_throttled_for_requests,json=wasThrottledForRequests" json:"was_throttled_for_requests,omitempty"` | ||
387 | ThrottledTime *int64 `protobuf:"varint,33,opt,name=throttled_time,json=throttledTime" json:"throttled_time,omitempty"` | ||
388 | ServerName []byte `protobuf:"bytes,34,opt,name=server_name,json=serverName" json:"server_name,omitempty"` | ||
389 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
390 | XXX_unrecognized []byte `json:"-"` | ||
391 | XXX_sizecache int32 `json:"-"` | ||
392 | } | ||
393 | |||
394 | func (m *RequestLog) Reset() { *m = RequestLog{} } | ||
395 | func (m *RequestLog) String() string { return proto.CompactTextString(m) } | ||
396 | func (*RequestLog) ProtoMessage() {} | ||
397 | func (*RequestLog) Descriptor() ([]byte, []int) { | ||
398 | return fileDescriptor_log_service_f054fd4b5012319d, []int{7} | ||
399 | } | ||
400 | func (m *RequestLog) XXX_Unmarshal(b []byte) error { | ||
401 | return xxx_messageInfo_RequestLog.Unmarshal(m, b) | ||
402 | } | ||
403 | func (m *RequestLog) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
404 | return xxx_messageInfo_RequestLog.Marshal(b, m, deterministic) | ||
405 | } | ||
406 | func (dst *RequestLog) XXX_Merge(src proto.Message) { | ||
407 | xxx_messageInfo_RequestLog.Merge(dst, src) | ||
408 | } | ||
409 | func (m *RequestLog) XXX_Size() int { | ||
410 | return xxx_messageInfo_RequestLog.Size(m) | ||
411 | } | ||
412 | func (m *RequestLog) XXX_DiscardUnknown() { | ||
413 | xxx_messageInfo_RequestLog.DiscardUnknown(m) | ||
414 | } | ||
415 | |||
416 | var xxx_messageInfo_RequestLog proto.InternalMessageInfo | ||
417 | |||
418 | const Default_RequestLog_ModuleId string = "default" | ||
419 | const Default_RequestLog_ReplicaIndex int32 = -1 | ||
420 | const Default_RequestLog_Finished bool = true | ||
421 | |||
422 | func (m *RequestLog) GetAppId() string { | ||
423 | if m != nil && m.AppId != nil { | ||
424 | return *m.AppId | ||
425 | } | ||
426 | return "" | ||
427 | } | ||
428 | |||
429 | func (m *RequestLog) GetModuleId() string { | ||
430 | if m != nil && m.ModuleId != nil { | ||
431 | return *m.ModuleId | ||
432 | } | ||
433 | return Default_RequestLog_ModuleId | ||
434 | } | ||
435 | |||
436 | func (m *RequestLog) GetVersionId() string { | ||
437 | if m != nil && m.VersionId != nil { | ||
438 | return *m.VersionId | ||
439 | } | ||
440 | return "" | ||
441 | } | ||
442 | |||
443 | func (m *RequestLog) GetRequestId() []byte { | ||
444 | if m != nil { | ||
445 | return m.RequestId | ||
446 | } | ||
447 | return nil | ||
448 | } | ||
449 | |||
450 | func (m *RequestLog) GetOffset() *LogOffset { | ||
451 | if m != nil { | ||
452 | return m.Offset | ||
453 | } | ||
454 | return nil | ||
455 | } | ||
456 | |||
457 | func (m *RequestLog) GetIp() string { | ||
458 | if m != nil && m.Ip != nil { | ||
459 | return *m.Ip | ||
460 | } | ||
461 | return "" | ||
462 | } | ||
463 | |||
464 | func (m *RequestLog) GetNickname() string { | ||
465 | if m != nil && m.Nickname != nil { | ||
466 | return *m.Nickname | ||
467 | } | ||
468 | return "" | ||
469 | } | ||
470 | |||
471 | func (m *RequestLog) GetStartTime() int64 { | ||
472 | if m != nil && m.StartTime != nil { | ||
473 | return *m.StartTime | ||
474 | } | ||
475 | return 0 | ||
476 | } | ||
477 | |||
478 | func (m *RequestLog) GetEndTime() int64 { | ||
479 | if m != nil && m.EndTime != nil { | ||
480 | return *m.EndTime | ||
481 | } | ||
482 | return 0 | ||
483 | } | ||
484 | |||
485 | func (m *RequestLog) GetLatency() int64 { | ||
486 | if m != nil && m.Latency != nil { | ||
487 | return *m.Latency | ||
488 | } | ||
489 | return 0 | ||
490 | } | ||
491 | |||
492 | func (m *RequestLog) GetMcycles() int64 { | ||
493 | if m != nil && m.Mcycles != nil { | ||
494 | return *m.Mcycles | ||
495 | } | ||
496 | return 0 | ||
497 | } | ||
498 | |||
499 | func (m *RequestLog) GetMethod() string { | ||
500 | if m != nil && m.Method != nil { | ||
501 | return *m.Method | ||
502 | } | ||
503 | return "" | ||
504 | } | ||
505 | |||
506 | func (m *RequestLog) GetResource() string { | ||
507 | if m != nil && m.Resource != nil { | ||
508 | return *m.Resource | ||
509 | } | ||
510 | return "" | ||
511 | } | ||
512 | |||
513 | func (m *RequestLog) GetHttpVersion() string { | ||
514 | if m != nil && m.HttpVersion != nil { | ||
515 | return *m.HttpVersion | ||
516 | } | ||
517 | return "" | ||
518 | } | ||
519 | |||
520 | func (m *RequestLog) GetStatus() int32 { | ||
521 | if m != nil && m.Status != nil { | ||
522 | return *m.Status | ||
523 | } | ||
524 | return 0 | ||
525 | } | ||
526 | |||
527 | func (m *RequestLog) GetResponseSize() int64 { | ||
528 | if m != nil && m.ResponseSize != nil { | ||
529 | return *m.ResponseSize | ||
530 | } | ||
531 | return 0 | ||
532 | } | ||
533 | |||
534 | func (m *RequestLog) GetReferrer() string { | ||
535 | if m != nil && m.Referrer != nil { | ||
536 | return *m.Referrer | ||
537 | } | ||
538 | return "" | ||
539 | } | ||
540 | |||
541 | func (m *RequestLog) GetUserAgent() string { | ||
542 | if m != nil && m.UserAgent != nil { | ||
543 | return *m.UserAgent | ||
544 | } | ||
545 | return "" | ||
546 | } | ||
547 | |||
548 | func (m *RequestLog) GetUrlMapEntry() string { | ||
549 | if m != nil && m.UrlMapEntry != nil { | ||
550 | return *m.UrlMapEntry | ||
551 | } | ||
552 | return "" | ||
553 | } | ||
554 | |||
555 | func (m *RequestLog) GetCombined() string { | ||
556 | if m != nil && m.Combined != nil { | ||
557 | return *m.Combined | ||
558 | } | ||
559 | return "" | ||
560 | } | ||
561 | |||
562 | func (m *RequestLog) GetApiMcycles() int64 { | ||
563 | if m != nil && m.ApiMcycles != nil { | ||
564 | return *m.ApiMcycles | ||
565 | } | ||
566 | return 0 | ||
567 | } | ||
568 | |||
569 | func (m *RequestLog) GetHost() string { | ||
570 | if m != nil && m.Host != nil { | ||
571 | return *m.Host | ||
572 | } | ||
573 | return "" | ||
574 | } | ||
575 | |||
576 | func (m *RequestLog) GetCost() float64 { | ||
577 | if m != nil && m.Cost != nil { | ||
578 | return *m.Cost | ||
579 | } | ||
580 | return 0 | ||
581 | } | ||
582 | |||
583 | func (m *RequestLog) GetTaskQueueName() string { | ||
584 | if m != nil && m.TaskQueueName != nil { | ||
585 | return *m.TaskQueueName | ||
586 | } | ||
587 | return "" | ||
588 | } | ||
589 | |||
590 | func (m *RequestLog) GetTaskName() string { | ||
591 | if m != nil && m.TaskName != nil { | ||
592 | return *m.TaskName | ||
593 | } | ||
594 | return "" | ||
595 | } | ||
596 | |||
597 | func (m *RequestLog) GetWasLoadingRequest() bool { | ||
598 | if m != nil && m.WasLoadingRequest != nil { | ||
599 | return *m.WasLoadingRequest | ||
600 | } | ||
601 | return false | ||
602 | } | ||
603 | |||
604 | func (m *RequestLog) GetPendingTime() int64 { | ||
605 | if m != nil && m.PendingTime != nil { | ||
606 | return *m.PendingTime | ||
607 | } | ||
608 | return 0 | ||
609 | } | ||
610 | |||
611 | func (m *RequestLog) GetReplicaIndex() int32 { | ||
612 | if m != nil && m.ReplicaIndex != nil { | ||
613 | return *m.ReplicaIndex | ||
614 | } | ||
615 | return Default_RequestLog_ReplicaIndex | ||
616 | } | ||
617 | |||
618 | func (m *RequestLog) GetFinished() bool { | ||
619 | if m != nil && m.Finished != nil { | ||
620 | return *m.Finished | ||
621 | } | ||
622 | return Default_RequestLog_Finished | ||
623 | } | ||
624 | |||
625 | func (m *RequestLog) GetCloneKey() []byte { | ||
626 | if m != nil { | ||
627 | return m.CloneKey | ||
628 | } | ||
629 | return nil | ||
630 | } | ||
631 | |||
632 | func (m *RequestLog) GetLine() []*LogLine { | ||
633 | if m != nil { | ||
634 | return m.Line | ||
635 | } | ||
636 | return nil | ||
637 | } | ||
638 | |||
639 | func (m *RequestLog) GetLinesIncomplete() bool { | ||
640 | if m != nil && m.LinesIncomplete != nil { | ||
641 | return *m.LinesIncomplete | ||
642 | } | ||
643 | return false | ||
644 | } | ||
645 | |||
646 | func (m *RequestLog) GetAppEngineRelease() []byte { | ||
647 | if m != nil { | ||
648 | return m.AppEngineRelease | ||
649 | } | ||
650 | return nil | ||
651 | } | ||
652 | |||
653 | func (m *RequestLog) GetExitReason() int32 { | ||
654 | if m != nil && m.ExitReason != nil { | ||
655 | return *m.ExitReason | ||
656 | } | ||
657 | return 0 | ||
658 | } | ||
659 | |||
660 | func (m *RequestLog) GetWasThrottledForTime() bool { | ||
661 | if m != nil && m.WasThrottledForTime != nil { | ||
662 | return *m.WasThrottledForTime | ||
663 | } | ||
664 | return false | ||
665 | } | ||
666 | |||
667 | func (m *RequestLog) GetWasThrottledForRequests() bool { | ||
668 | if m != nil && m.WasThrottledForRequests != nil { | ||
669 | return *m.WasThrottledForRequests | ||
670 | } | ||
671 | return false | ||
672 | } | ||
673 | |||
674 | func (m *RequestLog) GetThrottledTime() int64 { | ||
675 | if m != nil && m.ThrottledTime != nil { | ||
676 | return *m.ThrottledTime | ||
677 | } | ||
678 | return 0 | ||
679 | } | ||
680 | |||
681 | func (m *RequestLog) GetServerName() []byte { | ||
682 | if m != nil { | ||
683 | return m.ServerName | ||
684 | } | ||
685 | return nil | ||
686 | } | ||
687 | |||
688 | type LogModuleVersion struct { | ||
689 | ModuleId *string `protobuf:"bytes,1,opt,name=module_id,json=moduleId,def=default" json:"module_id,omitempty"` | ||
690 | VersionId *string `protobuf:"bytes,2,opt,name=version_id,json=versionId" json:"version_id,omitempty"` | ||
691 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
692 | XXX_unrecognized []byte `json:"-"` | ||
693 | XXX_sizecache int32 `json:"-"` | ||
694 | } | ||
695 | |||
696 | func (m *LogModuleVersion) Reset() { *m = LogModuleVersion{} } | ||
697 | func (m *LogModuleVersion) String() string { return proto.CompactTextString(m) } | ||
698 | func (*LogModuleVersion) ProtoMessage() {} | ||
699 | func (*LogModuleVersion) Descriptor() ([]byte, []int) { | ||
700 | return fileDescriptor_log_service_f054fd4b5012319d, []int{8} | ||
701 | } | ||
702 | func (m *LogModuleVersion) XXX_Unmarshal(b []byte) error { | ||
703 | return xxx_messageInfo_LogModuleVersion.Unmarshal(m, b) | ||
704 | } | ||
705 | func (m *LogModuleVersion) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
706 | return xxx_messageInfo_LogModuleVersion.Marshal(b, m, deterministic) | ||
707 | } | ||
708 | func (dst *LogModuleVersion) XXX_Merge(src proto.Message) { | ||
709 | xxx_messageInfo_LogModuleVersion.Merge(dst, src) | ||
710 | } | ||
711 | func (m *LogModuleVersion) XXX_Size() int { | ||
712 | return xxx_messageInfo_LogModuleVersion.Size(m) | ||
713 | } | ||
714 | func (m *LogModuleVersion) XXX_DiscardUnknown() { | ||
715 | xxx_messageInfo_LogModuleVersion.DiscardUnknown(m) | ||
716 | } | ||
717 | |||
718 | var xxx_messageInfo_LogModuleVersion proto.InternalMessageInfo | ||
719 | |||
720 | const Default_LogModuleVersion_ModuleId string = "default" | ||
721 | |||
722 | func (m *LogModuleVersion) GetModuleId() string { | ||
723 | if m != nil && m.ModuleId != nil { | ||
724 | return *m.ModuleId | ||
725 | } | ||
726 | return Default_LogModuleVersion_ModuleId | ||
727 | } | ||
728 | |||
729 | func (m *LogModuleVersion) GetVersionId() string { | ||
730 | if m != nil && m.VersionId != nil { | ||
731 | return *m.VersionId | ||
732 | } | ||
733 | return "" | ||
734 | } | ||
735 | |||
736 | type LogReadRequest struct { | ||
737 | AppId *string `protobuf:"bytes,1,req,name=app_id,json=appId" json:"app_id,omitempty"` | ||
738 | VersionId []string `protobuf:"bytes,2,rep,name=version_id,json=versionId" json:"version_id,omitempty"` | ||
739 | ModuleVersion []*LogModuleVersion `protobuf:"bytes,19,rep,name=module_version,json=moduleVersion" json:"module_version,omitempty"` | ||
740 | StartTime *int64 `protobuf:"varint,3,opt,name=start_time,json=startTime" json:"start_time,omitempty"` | ||
741 | EndTime *int64 `protobuf:"varint,4,opt,name=end_time,json=endTime" json:"end_time,omitempty"` | ||
742 | Offset *LogOffset `protobuf:"bytes,5,opt,name=offset" json:"offset,omitempty"` | ||
743 | RequestId [][]byte `protobuf:"bytes,6,rep,name=request_id,json=requestId" json:"request_id,omitempty"` | ||
744 | MinimumLogLevel *int32 `protobuf:"varint,7,opt,name=minimum_log_level,json=minimumLogLevel" json:"minimum_log_level,omitempty"` | ||
745 | IncludeIncomplete *bool `protobuf:"varint,8,opt,name=include_incomplete,json=includeIncomplete" json:"include_incomplete,omitempty"` | ||
746 | Count *int64 `protobuf:"varint,9,opt,name=count" json:"count,omitempty"` | ||
747 | CombinedLogRegex *string `protobuf:"bytes,14,opt,name=combined_log_regex,json=combinedLogRegex" json:"combined_log_regex,omitempty"` | ||
748 | HostRegex *string `protobuf:"bytes,15,opt,name=host_regex,json=hostRegex" json:"host_regex,omitempty"` | ||
749 | ReplicaIndex *int32 `protobuf:"varint,16,opt,name=replica_index,json=replicaIndex" json:"replica_index,omitempty"` | ||
750 | IncludeAppLogs *bool `protobuf:"varint,10,opt,name=include_app_logs,json=includeAppLogs" json:"include_app_logs,omitempty"` | ||
751 | AppLogsPerRequest *int32 `protobuf:"varint,17,opt,name=app_logs_per_request,json=appLogsPerRequest" json:"app_logs_per_request,omitempty"` | ||
752 | IncludeHost *bool `protobuf:"varint,11,opt,name=include_host,json=includeHost" json:"include_host,omitempty"` | ||
753 | IncludeAll *bool `protobuf:"varint,12,opt,name=include_all,json=includeAll" json:"include_all,omitempty"` | ||
754 | CacheIterator *bool `protobuf:"varint,13,opt,name=cache_iterator,json=cacheIterator" json:"cache_iterator,omitempty"` | ||
755 | NumShards *int32 `protobuf:"varint,18,opt,name=num_shards,json=numShards" json:"num_shards,omitempty"` | ||
756 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
757 | XXX_unrecognized []byte `json:"-"` | ||
758 | XXX_sizecache int32 `json:"-"` | ||
759 | } | ||
760 | |||
761 | func (m *LogReadRequest) Reset() { *m = LogReadRequest{} } | ||
762 | func (m *LogReadRequest) String() string { return proto.CompactTextString(m) } | ||
763 | func (*LogReadRequest) ProtoMessage() {} | ||
764 | func (*LogReadRequest) Descriptor() ([]byte, []int) { | ||
765 | return fileDescriptor_log_service_f054fd4b5012319d, []int{9} | ||
766 | } | ||
767 | func (m *LogReadRequest) XXX_Unmarshal(b []byte) error { | ||
768 | return xxx_messageInfo_LogReadRequest.Unmarshal(m, b) | ||
769 | } | ||
770 | func (m *LogReadRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
771 | return xxx_messageInfo_LogReadRequest.Marshal(b, m, deterministic) | ||
772 | } | ||
773 | func (dst *LogReadRequest) XXX_Merge(src proto.Message) { | ||
774 | xxx_messageInfo_LogReadRequest.Merge(dst, src) | ||
775 | } | ||
776 | func (m *LogReadRequest) XXX_Size() int { | ||
777 | return xxx_messageInfo_LogReadRequest.Size(m) | ||
778 | } | ||
779 | func (m *LogReadRequest) XXX_DiscardUnknown() { | ||
780 | xxx_messageInfo_LogReadRequest.DiscardUnknown(m) | ||
781 | } | ||
782 | |||
783 | var xxx_messageInfo_LogReadRequest proto.InternalMessageInfo | ||
784 | |||
785 | func (m *LogReadRequest) GetAppId() string { | ||
786 | if m != nil && m.AppId != nil { | ||
787 | return *m.AppId | ||
788 | } | ||
789 | return "" | ||
790 | } | ||
791 | |||
792 | func (m *LogReadRequest) GetVersionId() []string { | ||
793 | if m != nil { | ||
794 | return m.VersionId | ||
795 | } | ||
796 | return nil | ||
797 | } | ||
798 | |||
799 | func (m *LogReadRequest) GetModuleVersion() []*LogModuleVersion { | ||
800 | if m != nil { | ||
801 | return m.ModuleVersion | ||
802 | } | ||
803 | return nil | ||
804 | } | ||
805 | |||
806 | func (m *LogReadRequest) GetStartTime() int64 { | ||
807 | if m != nil && m.StartTime != nil { | ||
808 | return *m.StartTime | ||
809 | } | ||
810 | return 0 | ||
811 | } | ||
812 | |||
813 | func (m *LogReadRequest) GetEndTime() int64 { | ||
814 | if m != nil && m.EndTime != nil { | ||
815 | return *m.EndTime | ||
816 | } | ||
817 | return 0 | ||
818 | } | ||
819 | |||
820 | func (m *LogReadRequest) GetOffset() *LogOffset { | ||
821 | if m != nil { | ||
822 | return m.Offset | ||
823 | } | ||
824 | return nil | ||
825 | } | ||
826 | |||
827 | func (m *LogReadRequest) GetRequestId() [][]byte { | ||
828 | if m != nil { | ||
829 | return m.RequestId | ||
830 | } | ||
831 | return nil | ||
832 | } | ||
833 | |||
834 | func (m *LogReadRequest) GetMinimumLogLevel() int32 { | ||
835 | if m != nil && m.MinimumLogLevel != nil { | ||
836 | return *m.MinimumLogLevel | ||
837 | } | ||
838 | return 0 | ||
839 | } | ||
840 | |||
841 | func (m *LogReadRequest) GetIncludeIncomplete() bool { | ||
842 | if m != nil && m.IncludeIncomplete != nil { | ||
843 | return *m.IncludeIncomplete | ||
844 | } | ||
845 | return false | ||
846 | } | ||
847 | |||
848 | func (m *LogReadRequest) GetCount() int64 { | ||
849 | if m != nil && m.Count != nil { | ||
850 | return *m.Count | ||
851 | } | ||
852 | return 0 | ||
853 | } | ||
854 | |||
855 | func (m *LogReadRequest) GetCombinedLogRegex() string { | ||
856 | if m != nil && m.CombinedLogRegex != nil { | ||
857 | return *m.CombinedLogRegex | ||
858 | } | ||
859 | return "" | ||
860 | } | ||
861 | |||
862 | func (m *LogReadRequest) GetHostRegex() string { | ||
863 | if m != nil && m.HostRegex != nil { | ||
864 | return *m.HostRegex | ||
865 | } | ||
866 | return "" | ||
867 | } | ||
868 | |||
869 | func (m *LogReadRequest) GetReplicaIndex() int32 { | ||
870 | if m != nil && m.ReplicaIndex != nil { | ||
871 | return *m.ReplicaIndex | ||
872 | } | ||
873 | return 0 | ||
874 | } | ||
875 | |||
876 | func (m *LogReadRequest) GetIncludeAppLogs() bool { | ||
877 | if m != nil && m.IncludeAppLogs != nil { | ||
878 | return *m.IncludeAppLogs | ||
879 | } | ||
880 | return false | ||
881 | } | ||
882 | |||
883 | func (m *LogReadRequest) GetAppLogsPerRequest() int32 { | ||
884 | if m != nil && m.AppLogsPerRequest != nil { | ||
885 | return *m.AppLogsPerRequest | ||
886 | } | ||
887 | return 0 | ||
888 | } | ||
889 | |||
890 | func (m *LogReadRequest) GetIncludeHost() bool { | ||
891 | if m != nil && m.IncludeHost != nil { | ||
892 | return *m.IncludeHost | ||
893 | } | ||
894 | return false | ||
895 | } | ||
896 | |||
897 | func (m *LogReadRequest) GetIncludeAll() bool { | ||
898 | if m != nil && m.IncludeAll != nil { | ||
899 | return *m.IncludeAll | ||
900 | } | ||
901 | return false | ||
902 | } | ||
903 | |||
904 | func (m *LogReadRequest) GetCacheIterator() bool { | ||
905 | if m != nil && m.CacheIterator != nil { | ||
906 | return *m.CacheIterator | ||
907 | } | ||
908 | return false | ||
909 | } | ||
910 | |||
911 | func (m *LogReadRequest) GetNumShards() int32 { | ||
912 | if m != nil && m.NumShards != nil { | ||
913 | return *m.NumShards | ||
914 | } | ||
915 | return 0 | ||
916 | } | ||
917 | |||
918 | type LogReadResponse struct { | ||
919 | Log []*RequestLog `protobuf:"bytes,1,rep,name=log" json:"log,omitempty"` | ||
920 | Offset *LogOffset `protobuf:"bytes,2,opt,name=offset" json:"offset,omitempty"` | ||
921 | LastEndTime *int64 `protobuf:"varint,3,opt,name=last_end_time,json=lastEndTime" json:"last_end_time,omitempty"` | ||
922 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
923 | XXX_unrecognized []byte `json:"-"` | ||
924 | XXX_sizecache int32 `json:"-"` | ||
925 | } | ||
926 | |||
927 | func (m *LogReadResponse) Reset() { *m = LogReadResponse{} } | ||
928 | func (m *LogReadResponse) String() string { return proto.CompactTextString(m) } | ||
929 | func (*LogReadResponse) ProtoMessage() {} | ||
930 | func (*LogReadResponse) Descriptor() ([]byte, []int) { | ||
931 | return fileDescriptor_log_service_f054fd4b5012319d, []int{10} | ||
932 | } | ||
933 | func (m *LogReadResponse) XXX_Unmarshal(b []byte) error { | ||
934 | return xxx_messageInfo_LogReadResponse.Unmarshal(m, b) | ||
935 | } | ||
936 | func (m *LogReadResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
937 | return xxx_messageInfo_LogReadResponse.Marshal(b, m, deterministic) | ||
938 | } | ||
939 | func (dst *LogReadResponse) XXX_Merge(src proto.Message) { | ||
940 | xxx_messageInfo_LogReadResponse.Merge(dst, src) | ||
941 | } | ||
942 | func (m *LogReadResponse) XXX_Size() int { | ||
943 | return xxx_messageInfo_LogReadResponse.Size(m) | ||
944 | } | ||
945 | func (m *LogReadResponse) XXX_DiscardUnknown() { | ||
946 | xxx_messageInfo_LogReadResponse.DiscardUnknown(m) | ||
947 | } | ||
948 | |||
949 | var xxx_messageInfo_LogReadResponse proto.InternalMessageInfo | ||
950 | |||
951 | func (m *LogReadResponse) GetLog() []*RequestLog { | ||
952 | if m != nil { | ||
953 | return m.Log | ||
954 | } | ||
955 | return nil | ||
956 | } | ||
957 | |||
958 | func (m *LogReadResponse) GetOffset() *LogOffset { | ||
959 | if m != nil { | ||
960 | return m.Offset | ||
961 | } | ||
962 | return nil | ||
963 | } | ||
964 | |||
965 | func (m *LogReadResponse) GetLastEndTime() int64 { | ||
966 | if m != nil && m.LastEndTime != nil { | ||
967 | return *m.LastEndTime | ||
968 | } | ||
969 | return 0 | ||
970 | } | ||
971 | |||
972 | type LogUsageRecord struct { | ||
973 | VersionId *string `protobuf:"bytes,1,opt,name=version_id,json=versionId" json:"version_id,omitempty"` | ||
974 | StartTime *int32 `protobuf:"varint,2,opt,name=start_time,json=startTime" json:"start_time,omitempty"` | ||
975 | EndTime *int32 `protobuf:"varint,3,opt,name=end_time,json=endTime" json:"end_time,omitempty"` | ||
976 | Count *int64 `protobuf:"varint,4,opt,name=count" json:"count,omitempty"` | ||
977 | TotalSize *int64 `protobuf:"varint,5,opt,name=total_size,json=totalSize" json:"total_size,omitempty"` | ||
978 | Records *int32 `protobuf:"varint,6,opt,name=records" json:"records,omitempty"` | ||
979 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
980 | XXX_unrecognized []byte `json:"-"` | ||
981 | XXX_sizecache int32 `json:"-"` | ||
982 | } | ||
983 | |||
984 | func (m *LogUsageRecord) Reset() { *m = LogUsageRecord{} } | ||
985 | func (m *LogUsageRecord) String() string { return proto.CompactTextString(m) } | ||
986 | func (*LogUsageRecord) ProtoMessage() {} | ||
987 | func (*LogUsageRecord) Descriptor() ([]byte, []int) { | ||
988 | return fileDescriptor_log_service_f054fd4b5012319d, []int{11} | ||
989 | } | ||
990 | func (m *LogUsageRecord) XXX_Unmarshal(b []byte) error { | ||
991 | return xxx_messageInfo_LogUsageRecord.Unmarshal(m, b) | ||
992 | } | ||
993 | func (m *LogUsageRecord) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
994 | return xxx_messageInfo_LogUsageRecord.Marshal(b, m, deterministic) | ||
995 | } | ||
996 | func (dst *LogUsageRecord) XXX_Merge(src proto.Message) { | ||
997 | xxx_messageInfo_LogUsageRecord.Merge(dst, src) | ||
998 | } | ||
999 | func (m *LogUsageRecord) XXX_Size() int { | ||
1000 | return xxx_messageInfo_LogUsageRecord.Size(m) | ||
1001 | } | ||
1002 | func (m *LogUsageRecord) XXX_DiscardUnknown() { | ||
1003 | xxx_messageInfo_LogUsageRecord.DiscardUnknown(m) | ||
1004 | } | ||
1005 | |||
1006 | var xxx_messageInfo_LogUsageRecord proto.InternalMessageInfo | ||
1007 | |||
1008 | func (m *LogUsageRecord) GetVersionId() string { | ||
1009 | if m != nil && m.VersionId != nil { | ||
1010 | return *m.VersionId | ||
1011 | } | ||
1012 | return "" | ||
1013 | } | ||
1014 | |||
1015 | func (m *LogUsageRecord) GetStartTime() int32 { | ||
1016 | if m != nil && m.StartTime != nil { | ||
1017 | return *m.StartTime | ||
1018 | } | ||
1019 | return 0 | ||
1020 | } | ||
1021 | |||
1022 | func (m *LogUsageRecord) GetEndTime() int32 { | ||
1023 | if m != nil && m.EndTime != nil { | ||
1024 | return *m.EndTime | ||
1025 | } | ||
1026 | return 0 | ||
1027 | } | ||
1028 | |||
1029 | func (m *LogUsageRecord) GetCount() int64 { | ||
1030 | if m != nil && m.Count != nil { | ||
1031 | return *m.Count | ||
1032 | } | ||
1033 | return 0 | ||
1034 | } | ||
1035 | |||
1036 | func (m *LogUsageRecord) GetTotalSize() int64 { | ||
1037 | if m != nil && m.TotalSize != nil { | ||
1038 | return *m.TotalSize | ||
1039 | } | ||
1040 | return 0 | ||
1041 | } | ||
1042 | |||
1043 | func (m *LogUsageRecord) GetRecords() int32 { | ||
1044 | if m != nil && m.Records != nil { | ||
1045 | return *m.Records | ||
1046 | } | ||
1047 | return 0 | ||
1048 | } | ||
1049 | |||
1050 | type LogUsageRequest struct { | ||
1051 | AppId *string `protobuf:"bytes,1,req,name=app_id,json=appId" json:"app_id,omitempty"` | ||
1052 | VersionId []string `protobuf:"bytes,2,rep,name=version_id,json=versionId" json:"version_id,omitempty"` | ||
1053 | StartTime *int32 `protobuf:"varint,3,opt,name=start_time,json=startTime" json:"start_time,omitempty"` | ||
1054 | EndTime *int32 `protobuf:"varint,4,opt,name=end_time,json=endTime" json:"end_time,omitempty"` | ||
1055 | ResolutionHours *uint32 `protobuf:"varint,5,opt,name=resolution_hours,json=resolutionHours,def=1" json:"resolution_hours,omitempty"` | ||
1056 | CombineVersions *bool `protobuf:"varint,6,opt,name=combine_versions,json=combineVersions" json:"combine_versions,omitempty"` | ||
1057 | UsageVersion *int32 `protobuf:"varint,7,opt,name=usage_version,json=usageVersion" json:"usage_version,omitempty"` | ||
1058 | VersionsOnly *bool `protobuf:"varint,8,opt,name=versions_only,json=versionsOnly" json:"versions_only,omitempty"` | ||
1059 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
1060 | XXX_unrecognized []byte `json:"-"` | ||
1061 | XXX_sizecache int32 `json:"-"` | ||
1062 | } | ||
1063 | |||
1064 | func (m *LogUsageRequest) Reset() { *m = LogUsageRequest{} } | ||
1065 | func (m *LogUsageRequest) String() string { return proto.CompactTextString(m) } | ||
1066 | func (*LogUsageRequest) ProtoMessage() {} | ||
1067 | func (*LogUsageRequest) Descriptor() ([]byte, []int) { | ||
1068 | return fileDescriptor_log_service_f054fd4b5012319d, []int{12} | ||
1069 | } | ||
1070 | func (m *LogUsageRequest) XXX_Unmarshal(b []byte) error { | ||
1071 | return xxx_messageInfo_LogUsageRequest.Unmarshal(m, b) | ||
1072 | } | ||
1073 | func (m *LogUsageRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
1074 | return xxx_messageInfo_LogUsageRequest.Marshal(b, m, deterministic) | ||
1075 | } | ||
1076 | func (dst *LogUsageRequest) XXX_Merge(src proto.Message) { | ||
1077 | xxx_messageInfo_LogUsageRequest.Merge(dst, src) | ||
1078 | } | ||
1079 | func (m *LogUsageRequest) XXX_Size() int { | ||
1080 | return xxx_messageInfo_LogUsageRequest.Size(m) | ||
1081 | } | ||
1082 | func (m *LogUsageRequest) XXX_DiscardUnknown() { | ||
1083 | xxx_messageInfo_LogUsageRequest.DiscardUnknown(m) | ||
1084 | } | ||
1085 | |||
1086 | var xxx_messageInfo_LogUsageRequest proto.InternalMessageInfo | ||
1087 | |||
1088 | const Default_LogUsageRequest_ResolutionHours uint32 = 1 | ||
1089 | |||
1090 | func (m *LogUsageRequest) GetAppId() string { | ||
1091 | if m != nil && m.AppId != nil { | ||
1092 | return *m.AppId | ||
1093 | } | ||
1094 | return "" | ||
1095 | } | ||
1096 | |||
1097 | func (m *LogUsageRequest) GetVersionId() []string { | ||
1098 | if m != nil { | ||
1099 | return m.VersionId | ||
1100 | } | ||
1101 | return nil | ||
1102 | } | ||
1103 | |||
1104 | func (m *LogUsageRequest) GetStartTime() int32 { | ||
1105 | if m != nil && m.StartTime != nil { | ||
1106 | return *m.StartTime | ||
1107 | } | ||
1108 | return 0 | ||
1109 | } | ||
1110 | |||
1111 | func (m *LogUsageRequest) GetEndTime() int32 { | ||
1112 | if m != nil && m.EndTime != nil { | ||
1113 | return *m.EndTime | ||
1114 | } | ||
1115 | return 0 | ||
1116 | } | ||
1117 | |||
1118 | func (m *LogUsageRequest) GetResolutionHours() uint32 { | ||
1119 | if m != nil && m.ResolutionHours != nil { | ||
1120 | return *m.ResolutionHours | ||
1121 | } | ||
1122 | return Default_LogUsageRequest_ResolutionHours | ||
1123 | } | ||
1124 | |||
1125 | func (m *LogUsageRequest) GetCombineVersions() bool { | ||
1126 | if m != nil && m.CombineVersions != nil { | ||
1127 | return *m.CombineVersions | ||
1128 | } | ||
1129 | return false | ||
1130 | } | ||
1131 | |||
1132 | func (m *LogUsageRequest) GetUsageVersion() int32 { | ||
1133 | if m != nil && m.UsageVersion != nil { | ||
1134 | return *m.UsageVersion | ||
1135 | } | ||
1136 | return 0 | ||
1137 | } | ||
1138 | |||
1139 | func (m *LogUsageRequest) GetVersionsOnly() bool { | ||
1140 | if m != nil && m.VersionsOnly != nil { | ||
1141 | return *m.VersionsOnly | ||
1142 | } | ||
1143 | return false | ||
1144 | } | ||
1145 | |||
1146 | type LogUsageResponse struct { | ||
1147 | Usage []*LogUsageRecord `protobuf:"bytes,1,rep,name=usage" json:"usage,omitempty"` | ||
1148 | Summary *LogUsageRecord `protobuf:"bytes,2,opt,name=summary" json:"summary,omitempty"` | ||
1149 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
1150 | XXX_unrecognized []byte `json:"-"` | ||
1151 | XXX_sizecache int32 `json:"-"` | ||
1152 | } | ||
1153 | |||
1154 | func (m *LogUsageResponse) Reset() { *m = LogUsageResponse{} } | ||
1155 | func (m *LogUsageResponse) String() string { return proto.CompactTextString(m) } | ||
1156 | func (*LogUsageResponse) ProtoMessage() {} | ||
1157 | func (*LogUsageResponse) Descriptor() ([]byte, []int) { | ||
1158 | return fileDescriptor_log_service_f054fd4b5012319d, []int{13} | ||
1159 | } | ||
1160 | func (m *LogUsageResponse) XXX_Unmarshal(b []byte) error { | ||
1161 | return xxx_messageInfo_LogUsageResponse.Unmarshal(m, b) | ||
1162 | } | ||
1163 | func (m *LogUsageResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
1164 | return xxx_messageInfo_LogUsageResponse.Marshal(b, m, deterministic) | ||
1165 | } | ||
1166 | func (dst *LogUsageResponse) XXX_Merge(src proto.Message) { | ||
1167 | xxx_messageInfo_LogUsageResponse.Merge(dst, src) | ||
1168 | } | ||
1169 | func (m *LogUsageResponse) XXX_Size() int { | ||
1170 | return xxx_messageInfo_LogUsageResponse.Size(m) | ||
1171 | } | ||
1172 | func (m *LogUsageResponse) XXX_DiscardUnknown() { | ||
1173 | xxx_messageInfo_LogUsageResponse.DiscardUnknown(m) | ||
1174 | } | ||
1175 | |||
1176 | var xxx_messageInfo_LogUsageResponse proto.InternalMessageInfo | ||
1177 | |||
1178 | func (m *LogUsageResponse) GetUsage() []*LogUsageRecord { | ||
1179 | if m != nil { | ||
1180 | return m.Usage | ||
1181 | } | ||
1182 | return nil | ||
1183 | } | ||
1184 | |||
1185 | func (m *LogUsageResponse) GetSummary() *LogUsageRecord { | ||
1186 | if m != nil { | ||
1187 | return m.Summary | ||
1188 | } | ||
1189 | return nil | ||
1190 | } | ||
1191 | |||
1192 | func init() { | ||
1193 | proto.RegisterType((*LogServiceError)(nil), "appengine.LogServiceError") | ||
1194 | proto.RegisterType((*UserAppLogLine)(nil), "appengine.UserAppLogLine") | ||
1195 | proto.RegisterType((*UserAppLogGroup)(nil), "appengine.UserAppLogGroup") | ||
1196 | proto.RegisterType((*FlushRequest)(nil), "appengine.FlushRequest") | ||
1197 | proto.RegisterType((*SetStatusRequest)(nil), "appengine.SetStatusRequest") | ||
1198 | proto.RegisterType((*LogOffset)(nil), "appengine.LogOffset") | ||
1199 | proto.RegisterType((*LogLine)(nil), "appengine.LogLine") | ||
1200 | proto.RegisterType((*RequestLog)(nil), "appengine.RequestLog") | ||
1201 | proto.RegisterType((*LogModuleVersion)(nil), "appengine.LogModuleVersion") | ||
1202 | proto.RegisterType((*LogReadRequest)(nil), "appengine.LogReadRequest") | ||
1203 | proto.RegisterType((*LogReadResponse)(nil), "appengine.LogReadResponse") | ||
1204 | proto.RegisterType((*LogUsageRecord)(nil), "appengine.LogUsageRecord") | ||
1205 | proto.RegisterType((*LogUsageRequest)(nil), "appengine.LogUsageRequest") | ||
1206 | proto.RegisterType((*LogUsageResponse)(nil), "appengine.LogUsageResponse") | ||
1207 | } | ||
1208 | |||
1209 | func init() { | ||
1210 | proto.RegisterFile("google.golang.org/appengine/internal/log/log_service.proto", fileDescriptor_log_service_f054fd4b5012319d) | ||
1211 | } | ||
1212 | |||
1213 | var fileDescriptor_log_service_f054fd4b5012319d = []byte{ | ||
1214 | // 1553 bytes of a gzipped FileDescriptorProto | ||
1215 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x56, 0xdd, 0x72, 0xdb, 0xc6, | ||
1216 | 0x15, 0x2e, 0x48, 0x51, 0x24, 0x0f, 0x49, 0x91, 0x5a, 0xcb, 0xce, 0xda, 0xae, 0x6b, 0x1a, 0x4e, | ||
1217 | 0x1c, 0xd6, 0x93, 0x48, 0x93, 0xa4, 0x57, 0xca, 0x95, 0xd3, 0x2a, 0x8e, 0x26, 0xb4, 0xd5, 0x40, | ||
1218 | 0x72, 0x3a, 0xd3, 0x1b, 0x0c, 0x0a, 0x1c, 0x81, 0x18, 0x2f, 0xb1, 0xc8, 0xee, 0xc2, 0x91, 0x72, | ||
1219 | 0xdb, 0xdb, 0x3e, 0x46, 0x1f, 0xa2, 0xaf, 0xd2, 0xb7, 0xe9, 0xec, 0xd9, 0x05, 0x44, 0x2a, 0x4d, | ||
1220 | 0xc6, 0x33, 0xb9, 0xe0, 0x10, 0xfb, 0x9d, 0x83, 0xdd, 0xf3, 0xf3, 0x9d, 0x6f, 0x01, 0xc7, 0xb9, | ||
1221 | 0x94, 0xb9, 0xc0, 0xc3, 0x5c, 0x8a, 0xa4, 0xcc, 0x0f, 0xa5, 0xca, 0x8f, 0x92, 0xaa, 0xc2, 0x32, | ||
1222 | 0x2f, 0x4a, 0x3c, 0x2a, 0x4a, 0x83, 0xaa, 0x4c, 0xc4, 0x91, 0x90, 0xb9, 0xfd, 0xc5, 0x1a, 0xd5, | ||
1223 | 0xbb, 0x22, 0xc5, 0xc3, 0x4a, 0x49, 0x23, 0xd9, 0xb0, 0xf5, 0x0c, 0x5f, 0xc3, 0x74, 0x29, 0xf3, | ||
1224 | 0x73, 0x67, 0x3e, 0x51, 0x4a, 0xaa, 0xf0, 0x4b, 0x18, 0xd2, 0xc3, 0x9f, 0x65, 0x86, 0x6c, 0x17, | ||
1225 | 0x3a, 0x67, 0xdf, 0xce, 0x7e, 0xc7, 0xee, 0xc0, 0xf4, 0xf4, 0xf5, 0xf7, 0x2f, 0x96, 0xa7, 0x7f, | ||
1226 | 0x89, 0xa3, 0x93, 0xef, 0xde, 0x9c, 0x9c, 0x5f, 0xcc, 0x02, 0xb6, 0x0f, 0x93, 0xf3, 0x8b, 0xb3, | ||
1227 | 0xe8, 0xc5, 0xcb, 0x93, 0xf8, 0x24, 0x8a, 0xce, 0xa2, 0x59, 0x27, 0xcc, 0x61, 0xef, 0x8d, 0x46, | ||
1228 | 0xf5, 0xa2, 0xaa, 0x96, 0x32, 0x5f, 0x16, 0x25, 0xb2, 0x8f, 0x60, 0xcf, 0x14, 0x6b, 0xd4, 0x26, | ||
1229 | 0x59, 0x57, 0x71, 0xad, 0x31, 0xe5, 0xc1, 0xbc, 0xb3, 0xe8, 0x46, 0x93, 0x16, 0x7d, 0xa3, 0x31, | ||
1230 | 0x65, 0x07, 0xd0, 0x13, 0xf8, 0x0e, 0x05, 0xef, 0x90, 0xd5, 0x2d, 0x18, 0x87, 0xfe, 0x1a, 0xb5, | ||
1231 | 0x4e, 0x72, 0xe4, 0xdd, 0x79, 0x67, 0x31, 0x8c, 0x9a, 0x65, 0xf8, 0x12, 0xa6, 0x37, 0x07, 0xbd, | ||
1232 | 0x54, 0xb2, 0xae, 0xd8, 0x9f, 0x60, 0x60, 0x73, 0x15, 0x45, 0x89, 0xbc, 0x33, 0xef, 0x2e, 0x46, | ||
1233 | 0x9f, 0xdf, 0x3f, 0x6c, 0x33, 0x3d, 0xdc, 0x0e, 0x2b, 0xea, 0x0b, 0xf7, 0x10, 0x86, 0x30, 0xfe, | ||
1234 | 0x5a, 0xd4, 0x7a, 0x15, 0xe1, 0x0f, 0x35, 0x6a, 0xc3, 0x18, 0xec, 0x08, 0x99, 0x6b, 0x1e, 0xcc, | ||
1235 | 0x83, 0xc5, 0x38, 0xa2, 0xe7, 0xf0, 0x39, 0xcc, 0xce, 0xd1, 0x9c, 0x9b, 0xc4, 0xd4, 0xba, 0xf1, | ||
1236 | 0xbb, 0x07, 0xbb, 0x9a, 0x00, 0xca, 0x67, 0x18, 0xf9, 0x55, 0xf8, 0x1c, 0x86, 0x4b, 0x99, 0x9f, | ||
1237 | 0x5d, 0x5e, 0x6a, 0x34, 0xec, 0x11, 0x80, 0x72, 0xfe, 0x71, 0x91, 0xf9, 0x2d, 0x87, 0x1e, 0x39, | ||
1238 | 0xcd, 0xc2, 0x0b, 0xe8, 0x37, 0x65, 0x62, 0xb0, 0x63, 0x0b, 0xe2, 0x8b, 0x43, 0xcf, 0xdb, 0x35, | ||
1239 | 0xe9, 0x35, 0x35, 0x79, 0x0c, 0x23, 0x9b, 0xe6, 0x76, 0x5d, 0x40, 0xc8, 0xfc, 0x95, 0x2f, 0xcd, | ||
1240 | 0x3f, 0x01, 0xc0, 0x47, 0xb9, 0x94, 0x39, 0xbb, 0x0b, 0xbb, 0x49, 0x55, 0xb9, 0xf3, 0xad, 0x6b, | ||
1241 | 0x2f, 0xa9, 0xaa, 0xd3, 0x8c, 0x7d, 0x08, 0xc3, 0xb5, 0xcc, 0x6a, 0x81, 0xd6, 0xf2, 0xd1, 0x3c, | ||
1242 | 0x58, 0x0c, 0x8f, 0xfb, 0x19, 0x5e, 0x26, 0xb5, 0x30, 0xd1, 0xc0, 0x59, 0x4e, 0x33, 0x9b, 0xc0, | ||
1243 | 0x3b, 0x54, 0xba, 0x90, 0xa5, 0x75, 0xeb, 0xd0, 0x06, 0x43, 0x8f, 0x38, 0xf3, 0x46, 0x7e, 0x36, | ||
1244 | 0x94, 0xcd, 0xfc, 0xd8, 0x27, 0xb0, 0x2b, 0xa9, 0x10, 0xfc, 0xe9, 0x3c, 0x58, 0x8c, 0x3e, 0x3f, | ||
1245 | 0xd8, 0xe8, 0x47, 0x5b, 0xa4, 0xc8, 0xfb, 0xb0, 0x3d, 0xe8, 0x14, 0x15, 0xdf, 0xa1, 0x33, 0x3a, | ||
1246 | 0x45, 0xc5, 0x1e, 0xc0, 0xa0, 0x2c, 0xd2, 0xb7, 0x65, 0xb2, 0x46, 0xde, 0xb3, 0x01, 0x46, 0xed, | ||
1247 | 0xda, 0x1e, 0xac, 0x4d, 0xa2, 0x4c, 0x4c, 0x45, 0xdb, 0xa5, 0xa2, 0x0d, 0x09, 0xb9, 0xb0, 0x95, | ||
1248 | 0xbb, 0x0f, 0x03, 0x2c, 0x33, 0x67, 0xec, 0x93, 0xb1, 0x8f, 0x65, 0x46, 0x26, 0x0e, 0x7d, 0x91, | ||
1249 | 0x18, 0x2c, 0xd3, 0x6b, 0x3e, 0x70, 0x16, 0xbf, 0x24, 0xb2, 0xa5, 0xd7, 0xa9, 0x40, 0xcd, 0x87, | ||
1250 | 0xce, 0xe2, 0x97, 0xb6, 0xd7, 0x6b, 0x34, 0x2b, 0x99, 0x71, 0x70, 0xbd, 0x76, 0x2b, 0x1b, 0xa1, | ||
1251 | 0x42, 0x2d, 0x6b, 0x95, 0x22, 0x1f, 0x91, 0xa5, 0x5d, 0xb3, 0x27, 0x30, 0x5e, 0x19, 0x53, 0xc5, | ||
1252 | 0xbe, 0x58, 0x7c, 0x4c, 0xf6, 0x91, 0xc5, 0xbe, 0x77, 0xd0, 0x06, 0x85, 0x26, 0xd4, 0x60, 0xbf, | ||
1253 | 0x62, 0x4f, 0x61, 0xa2, 0x50, 0x57, 0xb2, 0xd4, 0x18, 0xeb, 0xe2, 0x27, 0xe4, 0x7b, 0x14, 0xce, | ||
1254 | 0xb8, 0x01, 0xcf, 0x8b, 0x9f, 0xd0, 0x9d, 0x7d, 0x89, 0x4a, 0xa1, 0xe2, 0x53, 0x57, 0x9d, 0x66, | ||
1255 | 0x6d, 0xab, 0x53, 0x6b, 0x54, 0x71, 0x92, 0x63, 0x69, 0xf8, 0x8c, 0xac, 0x43, 0x8b, 0xbc, 0xb0, | ||
1256 | 0x00, 0x0b, 0x61, 0x52, 0x2b, 0x11, 0xaf, 0x93, 0x2a, 0xc6, 0xd2, 0xa8, 0x6b, 0xbe, 0xef, 0x62, | ||
1257 | 0xab, 0x95, 0x78, 0x95, 0x54, 0x27, 0x16, 0xb2, 0xdb, 0xa7, 0x72, 0xfd, 0x8f, 0xa2, 0xc4, 0x8c, | ||
1258 | 0x33, 0x97, 0x5a, 0xb3, 0xb6, 0x0c, 0x4c, 0xaa, 0x22, 0x6e, 0x8a, 0x75, 0x67, 0x1e, 0x2c, 0xba, | ||
1259 | 0x11, 0x24, 0x55, 0xf1, 0xca, 0xd7, 0x8b, 0xc1, 0xce, 0x4a, 0x6a, 0xc3, 0x0f, 0xe8, 0x64, 0x7a, | ||
1260 | 0xb6, 0x58, 0x6a, 0xb1, 0xbb, 0xf3, 0x60, 0x11, 0x44, 0xf4, 0xcc, 0x9e, 0xc1, 0xd4, 0x24, 0xfa, | ||
1261 | 0x6d, 0xfc, 0x43, 0x8d, 0x35, 0xc6, 0xd4, 0xe8, 0x7b, 0xf4, 0xca, 0xc4, 0xc2, 0xdf, 0x59, 0xf4, | ||
1262 | 0xb5, 0xed, 0xf6, 0x43, 0x18, 0x92, 0x1f, 0x79, 0x7c, 0xe0, 0x92, 0xb5, 0x00, 0x19, 0x0f, 0xe1, | ||
1263 | 0xce, 0x8f, 0x89, 0x8e, 0x85, 0x4c, 0xb2, 0xa2, 0xcc, 0x63, 0xcf, 0x3e, 0xce, 0xe7, 0xc1, 0x62, | ||
1264 | 0x10, 0xed, 0xff, 0x98, 0xe8, 0xa5, 0xb3, 0x34, 0x83, 0xfb, 0x04, 0xc6, 0x15, 0x96, 0xe4, 0x4b, | ||
1265 | 0xfc, 0xb8, 0x4f, 0xe1, 0x8f, 0x3c, 0x46, 0x1c, 0xf9, 0xd8, 0x36, 0xa0, 0x12, 0x45, 0x9a, 0xc4, | ||
1266 | 0x45, 0x99, 0xe1, 0x15, 0x7f, 0x30, 0x0f, 0x16, 0xbd, 0xe3, 0xce, 0xa7, 0x9f, 0xd9, 0x26, 0x90, | ||
1267 | 0xe1, 0xd4, 0xe2, 0x6c, 0x0e, 0x83, 0xcb, 0xa2, 0x2c, 0xf4, 0x0a, 0x33, 0xfe, 0xd0, 0x1e, 0x78, | ||
1268 | 0xbc, 0x63, 0x54, 0x8d, 0x51, 0x8b, 0xda, 0xd0, 0x53, 0x21, 0x4b, 0x8c, 0xdf, 0xe2, 0x35, 0xff, | ||
1269 | 0x3d, 0x09, 0xc0, 0x80, 0x80, 0x6f, 0xf1, 0x9a, 0x3d, 0x83, 0x1d, 0x52, 0xab, 0x47, 0xa4, 0x56, | ||
1270 | 0x6c, 0x7b, 0x3a, 0x48, 0xa6, 0xc8, 0xce, 0xfe, 0x08, 0x33, 0xfb, 0xaf, 0xe3, 0xa2, 0x4c, 0xe5, | ||
1271 | 0xba, 0x12, 0x68, 0x90, 0x7f, 0x48, 0xf9, 0x4d, 0x09, 0x3f, 0x6d, 0x61, 0xf6, 0x09, 0x30, 0x3b, | ||
1272 | 0xed, 0x6e, 0x9b, 0x58, 0xa1, 0xc0, 0x44, 0x23, 0x7f, 0x46, 0x07, 0xcf, 0x92, 0xaa, 0x3a, 0x21, | ||
1273 | 0x43, 0xe4, 0x70, 0xdb, 0x49, 0xbc, 0x2a, 0x4c, 0xac, 0x30, 0xd1, 0xb2, 0xe4, 0x7f, 0xb0, 0x69, | ||
1274 | 0x46, 0x60, 0xa1, 0x88, 0x10, 0xf6, 0x05, 0xdc, 0xb3, 0xc5, 0x35, 0x2b, 0x25, 0x8d, 0x11, 0x98, | ||
1275 | 0xc5, 0x97, 0x52, 0xb9, 0xb2, 0x3d, 0xa6, 0xf3, 0x6d, 0xe9, 0x2f, 0x1a, 0xe3, 0xd7, 0x52, 0x51, | ||
1276 | 0xf9, 0xbe, 0x84, 0x07, 0x3f, 0x7f, 0xc9, 0xf7, 0x45, 0xf3, 0x39, 0xbd, 0xf8, 0xc1, 0xad, 0x17, | ||
1277 | 0x7d, 0x77, 0x34, 0xdd, 0x17, 0xed, 0x8b, 0x74, 0xd2, 0x13, 0x6a, 0xd0, 0xa4, 0x45, 0xe9, 0x8c, | ||
1278 | 0xc7, 0x30, 0xb2, 0x97, 0x1a, 0x2a, 0x47, 0x8a, 0x90, 0x12, 0x04, 0x07, 0x59, 0x5a, 0x84, 0x7f, | ||
1279 | 0x83, 0xd9, 0x52, 0xe6, 0xaf, 0x48, 0xc8, 0x9a, 0x81, 0xdb, 0xd2, 0xbc, 0xe0, 0x7d, 0x35, 0x2f, | ||
1280 | 0xd8, 0xd2, 0xbc, 0xf0, 0xbf, 0x3d, 0xd8, 0x5b, 0xca, 0x3c, 0xc2, 0x24, 0x6b, 0x28, 0xf5, 0x0b, | ||
1281 | 0x12, 0x7b, 0x7b, 0xa3, 0xee, 0xb6, 0x78, 0x7e, 0x05, 0x7b, 0x3e, 0x9a, 0x46, 0x23, 0xee, 0x10, | ||
1282 | 0x0f, 0x1e, 0x6e, 0xf3, 0x60, 0x2b, 0x85, 0x68, 0xb2, 0xde, 0xca, 0x68, 0x5b, 0x07, 0xbb, 0x54, | ||
1283 | 0xa9, 0x5f, 0xd0, 0xc1, 0x1d, 0x32, 0xb6, 0x3a, 0x78, 0xa3, 0xcd, 0xbd, 0xf7, 0xd0, 0xe6, 0x6d, | ||
1284 | 0xa1, 0xdf, 0x9d, 0x77, 0xb7, 0x85, 0xfe, 0x39, 0xec, 0xaf, 0x8b, 0xb2, 0x58, 0xd7, 0xeb, 0x98, | ||
1285 | 0xae, 0x60, 0xba, 0xb5, 0xfa, 0xc4, 0xa6, 0xa9, 0x37, 0x58, 0x46, 0xd3, 0xfd, 0xf5, 0x29, 0xb0, | ||
1286 | 0xa2, 0x4c, 0x45, 0x9d, 0xe1, 0x26, 0x9d, 0x07, 0x6e, 0x5c, 0xbd, 0x65, 0x83, 0xd0, 0x07, 0xd0, | ||
1287 | 0x4b, 0x65, 0x5d, 0x1a, 0x3e, 0xa4, 0xf8, 0xdd, 0xc2, 0xd2, 0xbc, 0x91, 0x23, 0x3a, 0x51, 0x61, | ||
1288 | 0x8e, 0x57, 0x7c, 0x8f, 0x7a, 0x35, 0x6b, 0x2c, 0xd4, 0xa5, 0x1c, 0xaf, 0x6c, 0xf4, 0x56, 0x83, | ||
1289 | 0xbc, 0x97, 0x53, 0xcb, 0xa1, 0x45, 0x9c, 0xf9, 0xe9, 0xed, 0x71, 0x9f, 0x51, 0xe4, 0xdb, 0xa3, | ||
1290 | 0xbe, 0x80, 0x59, 0x13, 0xb6, 0xed, 0x35, 0x7d, 0x23, 0x00, 0x05, 0xbd, 0xe7, 0x71, 0xf7, 0x75, | ||
1291 | 0xa1, 0xd9, 0x11, 0x1c, 0x34, 0x1e, 0x71, 0x85, 0x2d, 0xf3, 0xf9, 0x3e, 0xed, 0xba, 0x9f, 0x38, | ||
1292 | 0xb7, 0xbf, 0xa2, 0xda, 0x50, 0xa4, 0x66, 0x6b, 0x92, 0xcd, 0x11, 0x6d, 0x3b, 0xf2, 0xd8, 0x37, | ||
1293 | 0x56, 0x29, 0x1f, 0xc3, 0xa8, 0x3d, 0x5d, 0x08, 0x3e, 0x26, 0x0f, 0x68, 0x0e, 0x16, 0xc2, 0x8e, | ||
1294 | 0x4d, 0x9a, 0xa4, 0x2b, 0x8c, 0x0b, 0x83, 0x2a, 0x31, 0x52, 0xf1, 0x09, 0xf9, 0x4c, 0x08, 0x3d, | ||
1295 | 0xf5, 0xa0, 0xad, 0x44, 0x59, 0xaf, 0x63, 0xbd, 0x4a, 0x54, 0xa6, 0x39, 0xa3, 0x88, 0x86, 0x65, | ||
1296 | 0xbd, 0x3e, 0x27, 0x20, 0xfc, 0x57, 0x40, 0xdf, 0x83, 0x8e, 0xdb, 0xee, 0xb2, 0x61, 0x1f, 0x43, | ||
1297 | 0x57, 0xc8, 0x9c, 0x07, 0xc4, 0xcd, 0xbb, 0x1b, 0x2c, 0xb9, 0xf9, 0xc6, 0x88, 0xac, 0xc7, 0x06, | ||
1298 | 0xa3, 0x3a, 0xef, 0xc1, 0xa8, 0x10, 0x26, 0x22, 0xd1, 0x26, 0x6e, 0xf9, 0xe9, 0xc8, 0x3b, 0xb2, | ||
1299 | 0xe0, 0x89, 0xe3, 0x68, 0xf8, 0x9f, 0x80, 0x46, 0xed, 0x8d, 0xfd, 0xac, 0x89, 0x30, 0x95, 0xea, | ||
1300 | 0xf6, 0x4c, 0x05, 0xb7, 0x86, 0xf3, 0xd6, 0x3c, 0x74, 0x5c, 0x7e, 0xff, 0x7f, 0x1e, 0xba, 0x64, | ||
1301 | 0x6c, 0xe7, 0xa1, 0xe5, 0xd9, 0xce, 0x26, 0xcf, 0x1e, 0x01, 0x18, 0x69, 0x12, 0xe1, 0xee, 0xe1, | ||
1302 | 0x9e, 0x9b, 0x2f, 0x42, 0xe8, 0x12, 0xe6, 0xd0, 0x57, 0x14, 0x97, 0xe6, 0xbb, 0x6e, 0x3b, 0xbf, | ||
1303 | 0x0c, 0xff, 0xdd, 0xa1, 0x4a, 0xfa, 0xd0, 0x7f, 0x8b, 0x4c, 0xfc, 0x7c, 0xc4, 0x7b, 0xbf, 0x36, | ||
1304 | 0xe2, 0xbd, 0xcd, 0x11, 0x9f, 0xd9, 0xcf, 0x11, 0x51, 0x1b, 0xbb, 0xf7, 0x4a, 0xd6, 0x4a, 0x53, | ||
1305 | 0x0a, 0x93, 0xe3, 0xe0, 0xb3, 0x68, 0x7a, 0x63, 0xfa, 0xc6, 0x5a, 0xec, 0x25, 0xe3, 0x07, 0xa7, | ||
1306 | 0xd1, 0x23, 0x97, 0xd4, 0x20, 0x9a, 0x7a, 0xdc, 0x8b, 0x0e, 0x7d, 0xa0, 0xd4, 0x36, 0xb1, 0x56, | ||
1307 | 0xb8, 0xdc, 0xa8, 0x8f, 0x09, 0x6c, 0xa4, 0xe9, 0x29, 0x4c, 0x9a, 0x7d, 0x62, 0x59, 0x8a, 0x6b, | ||
1308 | 0x3f, 0xe2, 0xe3, 0x06, 0x3c, 0x2b, 0xc5, 0x75, 0x78, 0x45, 0x2a, 0xed, 0xab, 0xe4, 0x09, 0x77, | ||
1309 | 0x04, 0x3d, 0xda, 0xc8, 0x53, 0xee, 0xfe, 0x36, 0x8d, 0x36, 0xc8, 0x10, 0x39, 0x3f, 0xf6, 0x05, | ||
1310 | 0xf4, 0x75, 0xbd, 0x5e, 0x27, 0xea, 0xda, 0x33, 0xef, 0x57, 0x5e, 0x69, 0x3c, 0xbf, 0xea, 0xfd, | ||
1311 | 0xdd, 0x92, 0xf6, 0x7f, 0x01, 0x00, 0x00, 0xff, 0xff, 0x70, 0xd9, 0xa0, 0xf8, 0x48, 0x0d, 0x00, | ||
1312 | 0x00, | ||
1313 | } | ||
diff --git a/vendor/google.golang.org/appengine/internal/log/log_service.proto b/vendor/google.golang.org/appengine/internal/log/log_service.proto new file mode 100644 index 0000000..8981dc4 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/log/log_service.proto | |||
@@ -0,0 +1,150 @@ | |||
1 | syntax = "proto2"; | ||
2 | option go_package = "log"; | ||
3 | |||
4 | package appengine; | ||
5 | |||
6 | message LogServiceError { | ||
7 | enum ErrorCode { | ||
8 | OK = 0; | ||
9 | INVALID_REQUEST = 1; | ||
10 | STORAGE_ERROR = 2; | ||
11 | } | ||
12 | } | ||
13 | |||
14 | message UserAppLogLine { | ||
15 | required int64 timestamp_usec = 1; | ||
16 | required int64 level = 2; | ||
17 | required string message = 3; | ||
18 | } | ||
19 | |||
20 | message UserAppLogGroup { | ||
21 | repeated UserAppLogLine log_line = 2; | ||
22 | } | ||
23 | |||
24 | message FlushRequest { | ||
25 | optional bytes logs = 1; | ||
26 | } | ||
27 | |||
28 | message SetStatusRequest { | ||
29 | required string status = 1; | ||
30 | } | ||
31 | |||
32 | |||
33 | message LogOffset { | ||
34 | optional bytes request_id = 1; | ||
35 | } | ||
36 | |||
37 | message LogLine { | ||
38 | required int64 time = 1; | ||
39 | required int32 level = 2; | ||
40 | required string log_message = 3; | ||
41 | } | ||
42 | |||
43 | message RequestLog { | ||
44 | required string app_id = 1; | ||
45 | optional string module_id = 37 [default="default"]; | ||
46 | required string version_id = 2; | ||
47 | required bytes request_id = 3; | ||
48 | optional LogOffset offset = 35; | ||
49 | required string ip = 4; | ||
50 | optional string nickname = 5; | ||
51 | required int64 start_time = 6; | ||
52 | required int64 end_time = 7; | ||
53 | required int64 latency = 8; | ||
54 | required int64 mcycles = 9; | ||
55 | required string method = 10; | ||
56 | required string resource = 11; | ||
57 | required string http_version = 12; | ||
58 | required int32 status = 13; | ||
59 | required int64 response_size = 14; | ||
60 | optional string referrer = 15; | ||
61 | optional string user_agent = 16; | ||
62 | required string url_map_entry = 17; | ||
63 | required string combined = 18; | ||
64 | optional int64 api_mcycles = 19; | ||
65 | optional string host = 20; | ||
66 | optional double cost = 21; | ||
67 | |||
68 | optional string task_queue_name = 22; | ||
69 | optional string task_name = 23; | ||
70 | |||
71 | optional bool was_loading_request = 24; | ||
72 | optional int64 pending_time = 25; | ||
73 | optional int32 replica_index = 26 [default = -1]; | ||
74 | optional bool finished = 27 [default = true]; | ||
75 | optional bytes clone_key = 28; | ||
76 | |||
77 | repeated LogLine line = 29; | ||
78 | |||
79 | optional bool lines_incomplete = 36; | ||
80 | optional bytes app_engine_release = 38; | ||
81 | |||
82 | optional int32 exit_reason = 30; | ||
83 | optional bool was_throttled_for_time = 31; | ||
84 | optional bool was_throttled_for_requests = 32; | ||
85 | optional int64 throttled_time = 33; | ||
86 | |||
87 | optional bytes server_name = 34; | ||
88 | } | ||
89 | |||
90 | message LogModuleVersion { | ||
91 | optional string module_id = 1 [default="default"]; | ||
92 | optional string version_id = 2; | ||
93 | } | ||
94 | |||
95 | message LogReadRequest { | ||
96 | required string app_id = 1; | ||
97 | repeated string version_id = 2; | ||
98 | repeated LogModuleVersion module_version = 19; | ||
99 | |||
100 | optional int64 start_time = 3; | ||
101 | optional int64 end_time = 4; | ||
102 | optional LogOffset offset = 5; | ||
103 | repeated bytes request_id = 6; | ||
104 | |||
105 | optional int32 minimum_log_level = 7; | ||
106 | optional bool include_incomplete = 8; | ||
107 | optional int64 count = 9; | ||
108 | |||
109 | optional string combined_log_regex = 14; | ||
110 | optional string host_regex = 15; | ||
111 | optional int32 replica_index = 16; | ||
112 | |||
113 | optional bool include_app_logs = 10; | ||
114 | optional int32 app_logs_per_request = 17; | ||
115 | optional bool include_host = 11; | ||
116 | optional bool include_all = 12; | ||
117 | optional bool cache_iterator = 13; | ||
118 | optional int32 num_shards = 18; | ||
119 | } | ||
120 | |||
121 | message LogReadResponse { | ||
122 | repeated RequestLog log = 1; | ||
123 | optional LogOffset offset = 2; | ||
124 | optional int64 last_end_time = 3; | ||
125 | } | ||
126 | |||
127 | message LogUsageRecord { | ||
128 | optional string version_id = 1; | ||
129 | optional int32 start_time = 2; | ||
130 | optional int32 end_time = 3; | ||
131 | optional int64 count = 4; | ||
132 | optional int64 total_size = 5; | ||
133 | optional int32 records = 6; | ||
134 | } | ||
135 | |||
136 | message LogUsageRequest { | ||
137 | required string app_id = 1; | ||
138 | repeated string version_id = 2; | ||
139 | optional int32 start_time = 3; | ||
140 | optional int32 end_time = 4; | ||
141 | optional uint32 resolution_hours = 5 [default = 1]; | ||
142 | optional bool combine_versions = 6; | ||
143 | optional int32 usage_version = 7; | ||
144 | optional bool versions_only = 8; | ||
145 | } | ||
146 | |||
147 | message LogUsageResponse { | ||
148 | repeated LogUsageRecord usage = 1; | ||
149 | optional LogUsageRecord summary = 2; | ||
150 | } | ||
diff --git a/vendor/google.golang.org/appengine/internal/main.go b/vendor/google.golang.org/appengine/internal/main.go new file mode 100644 index 0000000..1e76531 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/main.go | |||
@@ -0,0 +1,16 @@ | |||
1 | // Copyright 2011 Google Inc. All rights reserved. | ||
2 | // Use of this source code is governed by the Apache 2.0 | ||
3 | // license that can be found in the LICENSE file. | ||
4 | |||
5 | // +build appengine | ||
6 | |||
7 | package internal | ||
8 | |||
9 | import ( | ||
10 | "appengine_internal" | ||
11 | ) | ||
12 | |||
13 | func Main() { | ||
14 | MainPath = "" | ||
15 | appengine_internal.Main() | ||
16 | } | ||
diff --git a/vendor/google.golang.org/appengine/internal/main_common.go b/vendor/google.golang.org/appengine/internal/main_common.go new file mode 100644 index 0000000..357dce4 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/main_common.go | |||
@@ -0,0 +1,7 @@ | |||
1 | package internal | ||
2 | |||
3 | // MainPath stores the file path of the main package. On App Engine Standard | ||
4 | // using Go version 1.9 and below, this will be unset. On App Engine Flex and | ||
5 | // App Engine Standard second-gen (Go 1.11 and above), this will be the | ||
6 | // filepath to package main. | ||
7 | var MainPath string | ||
diff --git a/vendor/google.golang.org/appengine/internal/main_vm.go b/vendor/google.golang.org/appengine/internal/main_vm.go new file mode 100644 index 0000000..ddb79a3 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/main_vm.go | |||
@@ -0,0 +1,69 @@ | |||
1 | // Copyright 2011 Google Inc. All rights reserved. | ||
2 | // Use of this source code is governed by the Apache 2.0 | ||
3 | // license that can be found in the LICENSE file. | ||
4 | |||
5 | // +build !appengine | ||
6 | |||
7 | package internal | ||
8 | |||
9 | import ( | ||
10 | "io" | ||
11 | "log" | ||
12 | "net/http" | ||
13 | "net/url" | ||
14 | "os" | ||
15 | "path/filepath" | ||
16 | "runtime" | ||
17 | ) | ||
18 | |||
19 | func Main() { | ||
20 | MainPath = filepath.Dir(findMainPath()) | ||
21 | installHealthChecker(http.DefaultServeMux) | ||
22 | |||
23 | port := "8080" | ||
24 | if s := os.Getenv("PORT"); s != "" { | ||
25 | port = s | ||
26 | } | ||
27 | |||
28 | host := "" | ||
29 | if IsDevAppServer() { | ||
30 | host = "127.0.0.1" | ||
31 | } | ||
32 | if err := http.ListenAndServe(host+":"+port, http.HandlerFunc(handleHTTP)); err != nil { | ||
33 | log.Fatalf("http.ListenAndServe: %v", err) | ||
34 | } | ||
35 | } | ||
36 | |||
37 | // Find the path to package main by looking at the root Caller. | ||
38 | func findMainPath() string { | ||
39 | pc := make([]uintptr, 100) | ||
40 | n := runtime.Callers(2, pc) | ||
41 | frames := runtime.CallersFrames(pc[:n]) | ||
42 | for { | ||
43 | frame, more := frames.Next() | ||
44 | // Tests won't have package main, instead they have testing.tRunner | ||
45 | if frame.Function == "main.main" || frame.Function == "testing.tRunner" { | ||
46 | return frame.File | ||
47 | } | ||
48 | if !more { | ||
49 | break | ||
50 | } | ||
51 | } | ||
52 | return "" | ||
53 | } | ||
54 | |||
55 | func installHealthChecker(mux *http.ServeMux) { | ||
56 | // If no health check handler has been installed by this point, add a trivial one. | ||
57 | const healthPath = "/_ah/health" | ||
58 | hreq := &http.Request{ | ||
59 | Method: "GET", | ||
60 | URL: &url.URL{ | ||
61 | Path: healthPath, | ||
62 | }, | ||
63 | } | ||
64 | if _, pat := mux.Handler(hreq); pat != healthPath { | ||
65 | mux.HandleFunc(healthPath, func(w http.ResponseWriter, r *http.Request) { | ||
66 | io.WriteString(w, "ok") | ||
67 | }) | ||
68 | } | ||
69 | } | ||
diff --git a/vendor/google.golang.org/appengine/internal/metadata.go b/vendor/google.golang.org/appengine/internal/metadata.go new file mode 100644 index 0000000..c4ba63b --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/metadata.go | |||
@@ -0,0 +1,60 @@ | |||
1 | // Copyright 2014 Google Inc. All rights reserved. | ||
2 | // Use of this source code is governed by the Apache 2.0 | ||
3 | // license that can be found in the LICENSE file. | ||
4 | |||
5 | package internal | ||
6 | |||
7 | // This file has code for accessing metadata. | ||
8 | // | ||
9 | // References: | ||
10 | // https://cloud.google.com/compute/docs/metadata | ||
11 | |||
12 | import ( | ||
13 | "fmt" | ||
14 | "io/ioutil" | ||
15 | "net/http" | ||
16 | "net/url" | ||
17 | ) | ||
18 | |||
19 | const ( | ||
20 | metadataHost = "metadata" | ||
21 | metadataPath = "/computeMetadata/v1/" | ||
22 | ) | ||
23 | |||
24 | var ( | ||
25 | metadataRequestHeaders = http.Header{ | ||
26 | "Metadata-Flavor": []string{"Google"}, | ||
27 | } | ||
28 | ) | ||
29 | |||
30 | // TODO(dsymonds): Do we need to support default values, like Python? | ||
31 | func mustGetMetadata(key string) []byte { | ||
32 | b, err := getMetadata(key) | ||
33 | if err != nil { | ||
34 | panic(fmt.Sprintf("Metadata fetch failed for '%s': %v", key, err)) | ||
35 | } | ||
36 | return b | ||
37 | } | ||
38 | |||
39 | func getMetadata(key string) ([]byte, error) { | ||
40 | // TODO(dsymonds): May need to use url.Parse to support keys with query args. | ||
41 | req := &http.Request{ | ||
42 | Method: "GET", | ||
43 | URL: &url.URL{ | ||
44 | Scheme: "http", | ||
45 | Host: metadataHost, | ||
46 | Path: metadataPath + key, | ||
47 | }, | ||
48 | Header: metadataRequestHeaders, | ||
49 | Host: metadataHost, | ||
50 | } | ||
51 | resp, err := http.DefaultClient.Do(req) | ||
52 | if err != nil { | ||
53 | return nil, err | ||
54 | } | ||
55 | defer resp.Body.Close() | ||
56 | if resp.StatusCode != 200 { | ||
57 | return nil, fmt.Errorf("metadata server returned HTTP %d", resp.StatusCode) | ||
58 | } | ||
59 | return ioutil.ReadAll(resp.Body) | ||
60 | } | ||
diff --git a/vendor/google.golang.org/appengine/internal/modules/modules_service.pb.go b/vendor/google.golang.org/appengine/internal/modules/modules_service.pb.go new file mode 100644 index 0000000..ddfc0c0 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/modules/modules_service.pb.go | |||
@@ -0,0 +1,786 @@ | |||
1 | // Code generated by protoc-gen-go. DO NOT EDIT. | ||
2 | // source: google.golang.org/appengine/internal/modules/modules_service.proto | ||
3 | |||
4 | package modules | ||
5 | |||
6 | import proto "github.com/golang/protobuf/proto" | ||
7 | import fmt "fmt" | ||
8 | import math "math" | ||
9 | |||
10 | // Reference imports to suppress errors if they are not otherwise used. | ||
11 | var _ = proto.Marshal | ||
12 | var _ = fmt.Errorf | ||
13 | var _ = math.Inf | ||
14 | |||
15 | // This is a compile-time assertion to ensure that this generated file | ||
16 | // is compatible with the proto package it is being compiled against. | ||
17 | // A compilation error at this line likely means your copy of the | ||
18 | // proto package needs to be updated. | ||
19 | const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package | ||
20 | |||
21 | type ModulesServiceError_ErrorCode int32 | ||
22 | |||
23 | const ( | ||
24 | ModulesServiceError_OK ModulesServiceError_ErrorCode = 0 | ||
25 | ModulesServiceError_INVALID_MODULE ModulesServiceError_ErrorCode = 1 | ||
26 | ModulesServiceError_INVALID_VERSION ModulesServiceError_ErrorCode = 2 | ||
27 | ModulesServiceError_INVALID_INSTANCES ModulesServiceError_ErrorCode = 3 | ||
28 | ModulesServiceError_TRANSIENT_ERROR ModulesServiceError_ErrorCode = 4 | ||
29 | ModulesServiceError_UNEXPECTED_STATE ModulesServiceError_ErrorCode = 5 | ||
30 | ) | ||
31 | |||
32 | var ModulesServiceError_ErrorCode_name = map[int32]string{ | ||
33 | 0: "OK", | ||
34 | 1: "INVALID_MODULE", | ||
35 | 2: "INVALID_VERSION", | ||
36 | 3: "INVALID_INSTANCES", | ||
37 | 4: "TRANSIENT_ERROR", | ||
38 | 5: "UNEXPECTED_STATE", | ||
39 | } | ||
40 | var ModulesServiceError_ErrorCode_value = map[string]int32{ | ||
41 | "OK": 0, | ||
42 | "INVALID_MODULE": 1, | ||
43 | "INVALID_VERSION": 2, | ||
44 | "INVALID_INSTANCES": 3, | ||
45 | "TRANSIENT_ERROR": 4, | ||
46 | "UNEXPECTED_STATE": 5, | ||
47 | } | ||
48 | |||
49 | func (x ModulesServiceError_ErrorCode) Enum() *ModulesServiceError_ErrorCode { | ||
50 | p := new(ModulesServiceError_ErrorCode) | ||
51 | *p = x | ||
52 | return p | ||
53 | } | ||
54 | func (x ModulesServiceError_ErrorCode) String() string { | ||
55 | return proto.EnumName(ModulesServiceError_ErrorCode_name, int32(x)) | ||
56 | } | ||
57 | func (x *ModulesServiceError_ErrorCode) UnmarshalJSON(data []byte) error { | ||
58 | value, err := proto.UnmarshalJSONEnum(ModulesServiceError_ErrorCode_value, data, "ModulesServiceError_ErrorCode") | ||
59 | if err != nil { | ||
60 | return err | ||
61 | } | ||
62 | *x = ModulesServiceError_ErrorCode(value) | ||
63 | return nil | ||
64 | } | ||
65 | func (ModulesServiceError_ErrorCode) EnumDescriptor() ([]byte, []int) { | ||
66 | return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{0, 0} | ||
67 | } | ||
68 | |||
69 | type ModulesServiceError struct { | ||
70 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
71 | XXX_unrecognized []byte `json:"-"` | ||
72 | XXX_sizecache int32 `json:"-"` | ||
73 | } | ||
74 | |||
75 | func (m *ModulesServiceError) Reset() { *m = ModulesServiceError{} } | ||
76 | func (m *ModulesServiceError) String() string { return proto.CompactTextString(m) } | ||
77 | func (*ModulesServiceError) ProtoMessage() {} | ||
78 | func (*ModulesServiceError) Descriptor() ([]byte, []int) { | ||
79 | return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{0} | ||
80 | } | ||
81 | func (m *ModulesServiceError) XXX_Unmarshal(b []byte) error { | ||
82 | return xxx_messageInfo_ModulesServiceError.Unmarshal(m, b) | ||
83 | } | ||
84 | func (m *ModulesServiceError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
85 | return xxx_messageInfo_ModulesServiceError.Marshal(b, m, deterministic) | ||
86 | } | ||
87 | func (dst *ModulesServiceError) XXX_Merge(src proto.Message) { | ||
88 | xxx_messageInfo_ModulesServiceError.Merge(dst, src) | ||
89 | } | ||
90 | func (m *ModulesServiceError) XXX_Size() int { | ||
91 | return xxx_messageInfo_ModulesServiceError.Size(m) | ||
92 | } | ||
93 | func (m *ModulesServiceError) XXX_DiscardUnknown() { | ||
94 | xxx_messageInfo_ModulesServiceError.DiscardUnknown(m) | ||
95 | } | ||
96 | |||
97 | var xxx_messageInfo_ModulesServiceError proto.InternalMessageInfo | ||
98 | |||
99 | type GetModulesRequest struct { | ||
100 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
101 | XXX_unrecognized []byte `json:"-"` | ||
102 | XXX_sizecache int32 `json:"-"` | ||
103 | } | ||
104 | |||
105 | func (m *GetModulesRequest) Reset() { *m = GetModulesRequest{} } | ||
106 | func (m *GetModulesRequest) String() string { return proto.CompactTextString(m) } | ||
107 | func (*GetModulesRequest) ProtoMessage() {} | ||
108 | func (*GetModulesRequest) Descriptor() ([]byte, []int) { | ||
109 | return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{1} | ||
110 | } | ||
111 | func (m *GetModulesRequest) XXX_Unmarshal(b []byte) error { | ||
112 | return xxx_messageInfo_GetModulesRequest.Unmarshal(m, b) | ||
113 | } | ||
114 | func (m *GetModulesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
115 | return xxx_messageInfo_GetModulesRequest.Marshal(b, m, deterministic) | ||
116 | } | ||
117 | func (dst *GetModulesRequest) XXX_Merge(src proto.Message) { | ||
118 | xxx_messageInfo_GetModulesRequest.Merge(dst, src) | ||
119 | } | ||
120 | func (m *GetModulesRequest) XXX_Size() int { | ||
121 | return xxx_messageInfo_GetModulesRequest.Size(m) | ||
122 | } | ||
123 | func (m *GetModulesRequest) XXX_DiscardUnknown() { | ||
124 | xxx_messageInfo_GetModulesRequest.DiscardUnknown(m) | ||
125 | } | ||
126 | |||
127 | var xxx_messageInfo_GetModulesRequest proto.InternalMessageInfo | ||
128 | |||
129 | type GetModulesResponse struct { | ||
130 | Module []string `protobuf:"bytes,1,rep,name=module" json:"module,omitempty"` | ||
131 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
132 | XXX_unrecognized []byte `json:"-"` | ||
133 | XXX_sizecache int32 `json:"-"` | ||
134 | } | ||
135 | |||
136 | func (m *GetModulesResponse) Reset() { *m = GetModulesResponse{} } | ||
137 | func (m *GetModulesResponse) String() string { return proto.CompactTextString(m) } | ||
138 | func (*GetModulesResponse) ProtoMessage() {} | ||
139 | func (*GetModulesResponse) Descriptor() ([]byte, []int) { | ||
140 | return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{2} | ||
141 | } | ||
142 | func (m *GetModulesResponse) XXX_Unmarshal(b []byte) error { | ||
143 | return xxx_messageInfo_GetModulesResponse.Unmarshal(m, b) | ||
144 | } | ||
145 | func (m *GetModulesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
146 | return xxx_messageInfo_GetModulesResponse.Marshal(b, m, deterministic) | ||
147 | } | ||
148 | func (dst *GetModulesResponse) XXX_Merge(src proto.Message) { | ||
149 | xxx_messageInfo_GetModulesResponse.Merge(dst, src) | ||
150 | } | ||
151 | func (m *GetModulesResponse) XXX_Size() int { | ||
152 | return xxx_messageInfo_GetModulesResponse.Size(m) | ||
153 | } | ||
154 | func (m *GetModulesResponse) XXX_DiscardUnknown() { | ||
155 | xxx_messageInfo_GetModulesResponse.DiscardUnknown(m) | ||
156 | } | ||
157 | |||
158 | var xxx_messageInfo_GetModulesResponse proto.InternalMessageInfo | ||
159 | |||
160 | func (m *GetModulesResponse) GetModule() []string { | ||
161 | if m != nil { | ||
162 | return m.Module | ||
163 | } | ||
164 | return nil | ||
165 | } | ||
166 | |||
167 | type GetVersionsRequest struct { | ||
168 | Module *string `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"` | ||
169 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
170 | XXX_unrecognized []byte `json:"-"` | ||
171 | XXX_sizecache int32 `json:"-"` | ||
172 | } | ||
173 | |||
174 | func (m *GetVersionsRequest) Reset() { *m = GetVersionsRequest{} } | ||
175 | func (m *GetVersionsRequest) String() string { return proto.CompactTextString(m) } | ||
176 | func (*GetVersionsRequest) ProtoMessage() {} | ||
177 | func (*GetVersionsRequest) Descriptor() ([]byte, []int) { | ||
178 | return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{3} | ||
179 | } | ||
180 | func (m *GetVersionsRequest) XXX_Unmarshal(b []byte) error { | ||
181 | return xxx_messageInfo_GetVersionsRequest.Unmarshal(m, b) | ||
182 | } | ||
183 | func (m *GetVersionsRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
184 | return xxx_messageInfo_GetVersionsRequest.Marshal(b, m, deterministic) | ||
185 | } | ||
186 | func (dst *GetVersionsRequest) XXX_Merge(src proto.Message) { | ||
187 | xxx_messageInfo_GetVersionsRequest.Merge(dst, src) | ||
188 | } | ||
189 | func (m *GetVersionsRequest) XXX_Size() int { | ||
190 | return xxx_messageInfo_GetVersionsRequest.Size(m) | ||
191 | } | ||
192 | func (m *GetVersionsRequest) XXX_DiscardUnknown() { | ||
193 | xxx_messageInfo_GetVersionsRequest.DiscardUnknown(m) | ||
194 | } | ||
195 | |||
196 | var xxx_messageInfo_GetVersionsRequest proto.InternalMessageInfo | ||
197 | |||
198 | func (m *GetVersionsRequest) GetModule() string { | ||
199 | if m != nil && m.Module != nil { | ||
200 | return *m.Module | ||
201 | } | ||
202 | return "" | ||
203 | } | ||
204 | |||
205 | type GetVersionsResponse struct { | ||
206 | Version []string `protobuf:"bytes,1,rep,name=version" json:"version,omitempty"` | ||
207 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
208 | XXX_unrecognized []byte `json:"-"` | ||
209 | XXX_sizecache int32 `json:"-"` | ||
210 | } | ||
211 | |||
212 | func (m *GetVersionsResponse) Reset() { *m = GetVersionsResponse{} } | ||
213 | func (m *GetVersionsResponse) String() string { return proto.CompactTextString(m) } | ||
214 | func (*GetVersionsResponse) ProtoMessage() {} | ||
215 | func (*GetVersionsResponse) Descriptor() ([]byte, []int) { | ||
216 | return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{4} | ||
217 | } | ||
218 | func (m *GetVersionsResponse) XXX_Unmarshal(b []byte) error { | ||
219 | return xxx_messageInfo_GetVersionsResponse.Unmarshal(m, b) | ||
220 | } | ||
221 | func (m *GetVersionsResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
222 | return xxx_messageInfo_GetVersionsResponse.Marshal(b, m, deterministic) | ||
223 | } | ||
224 | func (dst *GetVersionsResponse) XXX_Merge(src proto.Message) { | ||
225 | xxx_messageInfo_GetVersionsResponse.Merge(dst, src) | ||
226 | } | ||
227 | func (m *GetVersionsResponse) XXX_Size() int { | ||
228 | return xxx_messageInfo_GetVersionsResponse.Size(m) | ||
229 | } | ||
230 | func (m *GetVersionsResponse) XXX_DiscardUnknown() { | ||
231 | xxx_messageInfo_GetVersionsResponse.DiscardUnknown(m) | ||
232 | } | ||
233 | |||
234 | var xxx_messageInfo_GetVersionsResponse proto.InternalMessageInfo | ||
235 | |||
236 | func (m *GetVersionsResponse) GetVersion() []string { | ||
237 | if m != nil { | ||
238 | return m.Version | ||
239 | } | ||
240 | return nil | ||
241 | } | ||
242 | |||
243 | type GetDefaultVersionRequest struct { | ||
244 | Module *string `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"` | ||
245 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
246 | XXX_unrecognized []byte `json:"-"` | ||
247 | XXX_sizecache int32 `json:"-"` | ||
248 | } | ||
249 | |||
250 | func (m *GetDefaultVersionRequest) Reset() { *m = GetDefaultVersionRequest{} } | ||
251 | func (m *GetDefaultVersionRequest) String() string { return proto.CompactTextString(m) } | ||
252 | func (*GetDefaultVersionRequest) ProtoMessage() {} | ||
253 | func (*GetDefaultVersionRequest) Descriptor() ([]byte, []int) { | ||
254 | return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{5} | ||
255 | } | ||
256 | func (m *GetDefaultVersionRequest) XXX_Unmarshal(b []byte) error { | ||
257 | return xxx_messageInfo_GetDefaultVersionRequest.Unmarshal(m, b) | ||
258 | } | ||
259 | func (m *GetDefaultVersionRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
260 | return xxx_messageInfo_GetDefaultVersionRequest.Marshal(b, m, deterministic) | ||
261 | } | ||
262 | func (dst *GetDefaultVersionRequest) XXX_Merge(src proto.Message) { | ||
263 | xxx_messageInfo_GetDefaultVersionRequest.Merge(dst, src) | ||
264 | } | ||
265 | func (m *GetDefaultVersionRequest) XXX_Size() int { | ||
266 | return xxx_messageInfo_GetDefaultVersionRequest.Size(m) | ||
267 | } | ||
268 | func (m *GetDefaultVersionRequest) XXX_DiscardUnknown() { | ||
269 | xxx_messageInfo_GetDefaultVersionRequest.DiscardUnknown(m) | ||
270 | } | ||
271 | |||
272 | var xxx_messageInfo_GetDefaultVersionRequest proto.InternalMessageInfo | ||
273 | |||
274 | func (m *GetDefaultVersionRequest) GetModule() string { | ||
275 | if m != nil && m.Module != nil { | ||
276 | return *m.Module | ||
277 | } | ||
278 | return "" | ||
279 | } | ||
280 | |||
281 | type GetDefaultVersionResponse struct { | ||
282 | Version *string `protobuf:"bytes,1,req,name=version" json:"version,omitempty"` | ||
283 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
284 | XXX_unrecognized []byte `json:"-"` | ||
285 | XXX_sizecache int32 `json:"-"` | ||
286 | } | ||
287 | |||
288 | func (m *GetDefaultVersionResponse) Reset() { *m = GetDefaultVersionResponse{} } | ||
289 | func (m *GetDefaultVersionResponse) String() string { return proto.CompactTextString(m) } | ||
290 | func (*GetDefaultVersionResponse) ProtoMessage() {} | ||
291 | func (*GetDefaultVersionResponse) Descriptor() ([]byte, []int) { | ||
292 | return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{6} | ||
293 | } | ||
294 | func (m *GetDefaultVersionResponse) XXX_Unmarshal(b []byte) error { | ||
295 | return xxx_messageInfo_GetDefaultVersionResponse.Unmarshal(m, b) | ||
296 | } | ||
297 | func (m *GetDefaultVersionResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
298 | return xxx_messageInfo_GetDefaultVersionResponse.Marshal(b, m, deterministic) | ||
299 | } | ||
300 | func (dst *GetDefaultVersionResponse) XXX_Merge(src proto.Message) { | ||
301 | xxx_messageInfo_GetDefaultVersionResponse.Merge(dst, src) | ||
302 | } | ||
303 | func (m *GetDefaultVersionResponse) XXX_Size() int { | ||
304 | return xxx_messageInfo_GetDefaultVersionResponse.Size(m) | ||
305 | } | ||
306 | func (m *GetDefaultVersionResponse) XXX_DiscardUnknown() { | ||
307 | xxx_messageInfo_GetDefaultVersionResponse.DiscardUnknown(m) | ||
308 | } | ||
309 | |||
310 | var xxx_messageInfo_GetDefaultVersionResponse proto.InternalMessageInfo | ||
311 | |||
312 | func (m *GetDefaultVersionResponse) GetVersion() string { | ||
313 | if m != nil && m.Version != nil { | ||
314 | return *m.Version | ||
315 | } | ||
316 | return "" | ||
317 | } | ||
318 | |||
319 | type GetNumInstancesRequest struct { | ||
320 | Module *string `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"` | ||
321 | Version *string `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"` | ||
322 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
323 | XXX_unrecognized []byte `json:"-"` | ||
324 | XXX_sizecache int32 `json:"-"` | ||
325 | } | ||
326 | |||
327 | func (m *GetNumInstancesRequest) Reset() { *m = GetNumInstancesRequest{} } | ||
328 | func (m *GetNumInstancesRequest) String() string { return proto.CompactTextString(m) } | ||
329 | func (*GetNumInstancesRequest) ProtoMessage() {} | ||
330 | func (*GetNumInstancesRequest) Descriptor() ([]byte, []int) { | ||
331 | return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{7} | ||
332 | } | ||
333 | func (m *GetNumInstancesRequest) XXX_Unmarshal(b []byte) error { | ||
334 | return xxx_messageInfo_GetNumInstancesRequest.Unmarshal(m, b) | ||
335 | } | ||
336 | func (m *GetNumInstancesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
337 | return xxx_messageInfo_GetNumInstancesRequest.Marshal(b, m, deterministic) | ||
338 | } | ||
339 | func (dst *GetNumInstancesRequest) XXX_Merge(src proto.Message) { | ||
340 | xxx_messageInfo_GetNumInstancesRequest.Merge(dst, src) | ||
341 | } | ||
342 | func (m *GetNumInstancesRequest) XXX_Size() int { | ||
343 | return xxx_messageInfo_GetNumInstancesRequest.Size(m) | ||
344 | } | ||
345 | func (m *GetNumInstancesRequest) XXX_DiscardUnknown() { | ||
346 | xxx_messageInfo_GetNumInstancesRequest.DiscardUnknown(m) | ||
347 | } | ||
348 | |||
349 | var xxx_messageInfo_GetNumInstancesRequest proto.InternalMessageInfo | ||
350 | |||
351 | func (m *GetNumInstancesRequest) GetModule() string { | ||
352 | if m != nil && m.Module != nil { | ||
353 | return *m.Module | ||
354 | } | ||
355 | return "" | ||
356 | } | ||
357 | |||
358 | func (m *GetNumInstancesRequest) GetVersion() string { | ||
359 | if m != nil && m.Version != nil { | ||
360 | return *m.Version | ||
361 | } | ||
362 | return "" | ||
363 | } | ||
364 | |||
365 | type GetNumInstancesResponse struct { | ||
366 | Instances *int64 `protobuf:"varint,1,req,name=instances" json:"instances,omitempty"` | ||
367 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
368 | XXX_unrecognized []byte `json:"-"` | ||
369 | XXX_sizecache int32 `json:"-"` | ||
370 | } | ||
371 | |||
372 | func (m *GetNumInstancesResponse) Reset() { *m = GetNumInstancesResponse{} } | ||
373 | func (m *GetNumInstancesResponse) String() string { return proto.CompactTextString(m) } | ||
374 | func (*GetNumInstancesResponse) ProtoMessage() {} | ||
375 | func (*GetNumInstancesResponse) Descriptor() ([]byte, []int) { | ||
376 | return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{8} | ||
377 | } | ||
378 | func (m *GetNumInstancesResponse) XXX_Unmarshal(b []byte) error { | ||
379 | return xxx_messageInfo_GetNumInstancesResponse.Unmarshal(m, b) | ||
380 | } | ||
381 | func (m *GetNumInstancesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
382 | return xxx_messageInfo_GetNumInstancesResponse.Marshal(b, m, deterministic) | ||
383 | } | ||
384 | func (dst *GetNumInstancesResponse) XXX_Merge(src proto.Message) { | ||
385 | xxx_messageInfo_GetNumInstancesResponse.Merge(dst, src) | ||
386 | } | ||
387 | func (m *GetNumInstancesResponse) XXX_Size() int { | ||
388 | return xxx_messageInfo_GetNumInstancesResponse.Size(m) | ||
389 | } | ||
390 | func (m *GetNumInstancesResponse) XXX_DiscardUnknown() { | ||
391 | xxx_messageInfo_GetNumInstancesResponse.DiscardUnknown(m) | ||
392 | } | ||
393 | |||
394 | var xxx_messageInfo_GetNumInstancesResponse proto.InternalMessageInfo | ||
395 | |||
396 | func (m *GetNumInstancesResponse) GetInstances() int64 { | ||
397 | if m != nil && m.Instances != nil { | ||
398 | return *m.Instances | ||
399 | } | ||
400 | return 0 | ||
401 | } | ||
402 | |||
403 | type SetNumInstancesRequest struct { | ||
404 | Module *string `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"` | ||
405 | Version *string `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"` | ||
406 | Instances *int64 `protobuf:"varint,3,req,name=instances" json:"instances,omitempty"` | ||
407 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
408 | XXX_unrecognized []byte `json:"-"` | ||
409 | XXX_sizecache int32 `json:"-"` | ||
410 | } | ||
411 | |||
412 | func (m *SetNumInstancesRequest) Reset() { *m = SetNumInstancesRequest{} } | ||
413 | func (m *SetNumInstancesRequest) String() string { return proto.CompactTextString(m) } | ||
414 | func (*SetNumInstancesRequest) ProtoMessage() {} | ||
415 | func (*SetNumInstancesRequest) Descriptor() ([]byte, []int) { | ||
416 | return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{9} | ||
417 | } | ||
418 | func (m *SetNumInstancesRequest) XXX_Unmarshal(b []byte) error { | ||
419 | return xxx_messageInfo_SetNumInstancesRequest.Unmarshal(m, b) | ||
420 | } | ||
421 | func (m *SetNumInstancesRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
422 | return xxx_messageInfo_SetNumInstancesRequest.Marshal(b, m, deterministic) | ||
423 | } | ||
424 | func (dst *SetNumInstancesRequest) XXX_Merge(src proto.Message) { | ||
425 | xxx_messageInfo_SetNumInstancesRequest.Merge(dst, src) | ||
426 | } | ||
427 | func (m *SetNumInstancesRequest) XXX_Size() int { | ||
428 | return xxx_messageInfo_SetNumInstancesRequest.Size(m) | ||
429 | } | ||
430 | func (m *SetNumInstancesRequest) XXX_DiscardUnknown() { | ||
431 | xxx_messageInfo_SetNumInstancesRequest.DiscardUnknown(m) | ||
432 | } | ||
433 | |||
434 | var xxx_messageInfo_SetNumInstancesRequest proto.InternalMessageInfo | ||
435 | |||
436 | func (m *SetNumInstancesRequest) GetModule() string { | ||
437 | if m != nil && m.Module != nil { | ||
438 | return *m.Module | ||
439 | } | ||
440 | return "" | ||
441 | } | ||
442 | |||
443 | func (m *SetNumInstancesRequest) GetVersion() string { | ||
444 | if m != nil && m.Version != nil { | ||
445 | return *m.Version | ||
446 | } | ||
447 | return "" | ||
448 | } | ||
449 | |||
450 | func (m *SetNumInstancesRequest) GetInstances() int64 { | ||
451 | if m != nil && m.Instances != nil { | ||
452 | return *m.Instances | ||
453 | } | ||
454 | return 0 | ||
455 | } | ||
456 | |||
457 | type SetNumInstancesResponse struct { | ||
458 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
459 | XXX_unrecognized []byte `json:"-"` | ||
460 | XXX_sizecache int32 `json:"-"` | ||
461 | } | ||
462 | |||
463 | func (m *SetNumInstancesResponse) Reset() { *m = SetNumInstancesResponse{} } | ||
464 | func (m *SetNumInstancesResponse) String() string { return proto.CompactTextString(m) } | ||
465 | func (*SetNumInstancesResponse) ProtoMessage() {} | ||
466 | func (*SetNumInstancesResponse) Descriptor() ([]byte, []int) { | ||
467 | return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{10} | ||
468 | } | ||
469 | func (m *SetNumInstancesResponse) XXX_Unmarshal(b []byte) error { | ||
470 | return xxx_messageInfo_SetNumInstancesResponse.Unmarshal(m, b) | ||
471 | } | ||
472 | func (m *SetNumInstancesResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
473 | return xxx_messageInfo_SetNumInstancesResponse.Marshal(b, m, deterministic) | ||
474 | } | ||
475 | func (dst *SetNumInstancesResponse) XXX_Merge(src proto.Message) { | ||
476 | xxx_messageInfo_SetNumInstancesResponse.Merge(dst, src) | ||
477 | } | ||
478 | func (m *SetNumInstancesResponse) XXX_Size() int { | ||
479 | return xxx_messageInfo_SetNumInstancesResponse.Size(m) | ||
480 | } | ||
481 | func (m *SetNumInstancesResponse) XXX_DiscardUnknown() { | ||
482 | xxx_messageInfo_SetNumInstancesResponse.DiscardUnknown(m) | ||
483 | } | ||
484 | |||
485 | var xxx_messageInfo_SetNumInstancesResponse proto.InternalMessageInfo | ||
486 | |||
487 | type StartModuleRequest struct { | ||
488 | Module *string `protobuf:"bytes,1,req,name=module" json:"module,omitempty"` | ||
489 | Version *string `protobuf:"bytes,2,req,name=version" json:"version,omitempty"` | ||
490 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
491 | XXX_unrecognized []byte `json:"-"` | ||
492 | XXX_sizecache int32 `json:"-"` | ||
493 | } | ||
494 | |||
495 | func (m *StartModuleRequest) Reset() { *m = StartModuleRequest{} } | ||
496 | func (m *StartModuleRequest) String() string { return proto.CompactTextString(m) } | ||
497 | func (*StartModuleRequest) ProtoMessage() {} | ||
498 | func (*StartModuleRequest) Descriptor() ([]byte, []int) { | ||
499 | return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{11} | ||
500 | } | ||
501 | func (m *StartModuleRequest) XXX_Unmarshal(b []byte) error { | ||
502 | return xxx_messageInfo_StartModuleRequest.Unmarshal(m, b) | ||
503 | } | ||
504 | func (m *StartModuleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
505 | return xxx_messageInfo_StartModuleRequest.Marshal(b, m, deterministic) | ||
506 | } | ||
507 | func (dst *StartModuleRequest) XXX_Merge(src proto.Message) { | ||
508 | xxx_messageInfo_StartModuleRequest.Merge(dst, src) | ||
509 | } | ||
510 | func (m *StartModuleRequest) XXX_Size() int { | ||
511 | return xxx_messageInfo_StartModuleRequest.Size(m) | ||
512 | } | ||
513 | func (m *StartModuleRequest) XXX_DiscardUnknown() { | ||
514 | xxx_messageInfo_StartModuleRequest.DiscardUnknown(m) | ||
515 | } | ||
516 | |||
517 | var xxx_messageInfo_StartModuleRequest proto.InternalMessageInfo | ||
518 | |||
519 | func (m *StartModuleRequest) GetModule() string { | ||
520 | if m != nil && m.Module != nil { | ||
521 | return *m.Module | ||
522 | } | ||
523 | return "" | ||
524 | } | ||
525 | |||
526 | func (m *StartModuleRequest) GetVersion() string { | ||
527 | if m != nil && m.Version != nil { | ||
528 | return *m.Version | ||
529 | } | ||
530 | return "" | ||
531 | } | ||
532 | |||
533 | type StartModuleResponse struct { | ||
534 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
535 | XXX_unrecognized []byte `json:"-"` | ||
536 | XXX_sizecache int32 `json:"-"` | ||
537 | } | ||
538 | |||
539 | func (m *StartModuleResponse) Reset() { *m = StartModuleResponse{} } | ||
540 | func (m *StartModuleResponse) String() string { return proto.CompactTextString(m) } | ||
541 | func (*StartModuleResponse) ProtoMessage() {} | ||
542 | func (*StartModuleResponse) Descriptor() ([]byte, []int) { | ||
543 | return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{12} | ||
544 | } | ||
545 | func (m *StartModuleResponse) XXX_Unmarshal(b []byte) error { | ||
546 | return xxx_messageInfo_StartModuleResponse.Unmarshal(m, b) | ||
547 | } | ||
548 | func (m *StartModuleResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
549 | return xxx_messageInfo_StartModuleResponse.Marshal(b, m, deterministic) | ||
550 | } | ||
551 | func (dst *StartModuleResponse) XXX_Merge(src proto.Message) { | ||
552 | xxx_messageInfo_StartModuleResponse.Merge(dst, src) | ||
553 | } | ||
554 | func (m *StartModuleResponse) XXX_Size() int { | ||
555 | return xxx_messageInfo_StartModuleResponse.Size(m) | ||
556 | } | ||
557 | func (m *StartModuleResponse) XXX_DiscardUnknown() { | ||
558 | xxx_messageInfo_StartModuleResponse.DiscardUnknown(m) | ||
559 | } | ||
560 | |||
561 | var xxx_messageInfo_StartModuleResponse proto.InternalMessageInfo | ||
562 | |||
563 | type StopModuleRequest struct { | ||
564 | Module *string `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"` | ||
565 | Version *string `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"` | ||
566 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
567 | XXX_unrecognized []byte `json:"-"` | ||
568 | XXX_sizecache int32 `json:"-"` | ||
569 | } | ||
570 | |||
571 | func (m *StopModuleRequest) Reset() { *m = StopModuleRequest{} } | ||
572 | func (m *StopModuleRequest) String() string { return proto.CompactTextString(m) } | ||
573 | func (*StopModuleRequest) ProtoMessage() {} | ||
574 | func (*StopModuleRequest) Descriptor() ([]byte, []int) { | ||
575 | return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{13} | ||
576 | } | ||
577 | func (m *StopModuleRequest) XXX_Unmarshal(b []byte) error { | ||
578 | return xxx_messageInfo_StopModuleRequest.Unmarshal(m, b) | ||
579 | } | ||
580 | func (m *StopModuleRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
581 | return xxx_messageInfo_StopModuleRequest.Marshal(b, m, deterministic) | ||
582 | } | ||
583 | func (dst *StopModuleRequest) XXX_Merge(src proto.Message) { | ||
584 | xxx_messageInfo_StopModuleRequest.Merge(dst, src) | ||
585 | } | ||
586 | func (m *StopModuleRequest) XXX_Size() int { | ||
587 | return xxx_messageInfo_StopModuleRequest.Size(m) | ||
588 | } | ||
589 | func (m *StopModuleRequest) XXX_DiscardUnknown() { | ||
590 | xxx_messageInfo_StopModuleRequest.DiscardUnknown(m) | ||
591 | } | ||
592 | |||
593 | var xxx_messageInfo_StopModuleRequest proto.InternalMessageInfo | ||
594 | |||
595 | func (m *StopModuleRequest) GetModule() string { | ||
596 | if m != nil && m.Module != nil { | ||
597 | return *m.Module | ||
598 | } | ||
599 | return "" | ||
600 | } | ||
601 | |||
602 | func (m *StopModuleRequest) GetVersion() string { | ||
603 | if m != nil && m.Version != nil { | ||
604 | return *m.Version | ||
605 | } | ||
606 | return "" | ||
607 | } | ||
608 | |||
609 | type StopModuleResponse struct { | ||
610 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
611 | XXX_unrecognized []byte `json:"-"` | ||
612 | XXX_sizecache int32 `json:"-"` | ||
613 | } | ||
614 | |||
615 | func (m *StopModuleResponse) Reset() { *m = StopModuleResponse{} } | ||
616 | func (m *StopModuleResponse) String() string { return proto.CompactTextString(m) } | ||
617 | func (*StopModuleResponse) ProtoMessage() {} | ||
618 | func (*StopModuleResponse) Descriptor() ([]byte, []int) { | ||
619 | return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{14} | ||
620 | } | ||
621 | func (m *StopModuleResponse) XXX_Unmarshal(b []byte) error { | ||
622 | return xxx_messageInfo_StopModuleResponse.Unmarshal(m, b) | ||
623 | } | ||
624 | func (m *StopModuleResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
625 | return xxx_messageInfo_StopModuleResponse.Marshal(b, m, deterministic) | ||
626 | } | ||
627 | func (dst *StopModuleResponse) XXX_Merge(src proto.Message) { | ||
628 | xxx_messageInfo_StopModuleResponse.Merge(dst, src) | ||
629 | } | ||
630 | func (m *StopModuleResponse) XXX_Size() int { | ||
631 | return xxx_messageInfo_StopModuleResponse.Size(m) | ||
632 | } | ||
633 | func (m *StopModuleResponse) XXX_DiscardUnknown() { | ||
634 | xxx_messageInfo_StopModuleResponse.DiscardUnknown(m) | ||
635 | } | ||
636 | |||
637 | var xxx_messageInfo_StopModuleResponse proto.InternalMessageInfo | ||
638 | |||
639 | type GetHostnameRequest struct { | ||
640 | Module *string `protobuf:"bytes,1,opt,name=module" json:"module,omitempty"` | ||
641 | Version *string `protobuf:"bytes,2,opt,name=version" json:"version,omitempty"` | ||
642 | Instance *string `protobuf:"bytes,3,opt,name=instance" json:"instance,omitempty"` | ||
643 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
644 | XXX_unrecognized []byte `json:"-"` | ||
645 | XXX_sizecache int32 `json:"-"` | ||
646 | } | ||
647 | |||
648 | func (m *GetHostnameRequest) Reset() { *m = GetHostnameRequest{} } | ||
649 | func (m *GetHostnameRequest) String() string { return proto.CompactTextString(m) } | ||
650 | func (*GetHostnameRequest) ProtoMessage() {} | ||
651 | func (*GetHostnameRequest) Descriptor() ([]byte, []int) { | ||
652 | return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{15} | ||
653 | } | ||
654 | func (m *GetHostnameRequest) XXX_Unmarshal(b []byte) error { | ||
655 | return xxx_messageInfo_GetHostnameRequest.Unmarshal(m, b) | ||
656 | } | ||
657 | func (m *GetHostnameRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
658 | return xxx_messageInfo_GetHostnameRequest.Marshal(b, m, deterministic) | ||
659 | } | ||
660 | func (dst *GetHostnameRequest) XXX_Merge(src proto.Message) { | ||
661 | xxx_messageInfo_GetHostnameRequest.Merge(dst, src) | ||
662 | } | ||
663 | func (m *GetHostnameRequest) XXX_Size() int { | ||
664 | return xxx_messageInfo_GetHostnameRequest.Size(m) | ||
665 | } | ||
666 | func (m *GetHostnameRequest) XXX_DiscardUnknown() { | ||
667 | xxx_messageInfo_GetHostnameRequest.DiscardUnknown(m) | ||
668 | } | ||
669 | |||
670 | var xxx_messageInfo_GetHostnameRequest proto.InternalMessageInfo | ||
671 | |||
672 | func (m *GetHostnameRequest) GetModule() string { | ||
673 | if m != nil && m.Module != nil { | ||
674 | return *m.Module | ||
675 | } | ||
676 | return "" | ||
677 | } | ||
678 | |||
679 | func (m *GetHostnameRequest) GetVersion() string { | ||
680 | if m != nil && m.Version != nil { | ||
681 | return *m.Version | ||
682 | } | ||
683 | return "" | ||
684 | } | ||
685 | |||
686 | func (m *GetHostnameRequest) GetInstance() string { | ||
687 | if m != nil && m.Instance != nil { | ||
688 | return *m.Instance | ||
689 | } | ||
690 | return "" | ||
691 | } | ||
692 | |||
693 | type GetHostnameResponse struct { | ||
694 | Hostname *string `protobuf:"bytes,1,req,name=hostname" json:"hostname,omitempty"` | ||
695 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
696 | XXX_unrecognized []byte `json:"-"` | ||
697 | XXX_sizecache int32 `json:"-"` | ||
698 | } | ||
699 | |||
700 | func (m *GetHostnameResponse) Reset() { *m = GetHostnameResponse{} } | ||
701 | func (m *GetHostnameResponse) String() string { return proto.CompactTextString(m) } | ||
702 | func (*GetHostnameResponse) ProtoMessage() {} | ||
703 | func (*GetHostnameResponse) Descriptor() ([]byte, []int) { | ||
704 | return fileDescriptor_modules_service_9cd3bffe4e91c59a, []int{16} | ||
705 | } | ||
706 | func (m *GetHostnameResponse) XXX_Unmarshal(b []byte) error { | ||
707 | return xxx_messageInfo_GetHostnameResponse.Unmarshal(m, b) | ||
708 | } | ||
709 | func (m *GetHostnameResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
710 | return xxx_messageInfo_GetHostnameResponse.Marshal(b, m, deterministic) | ||
711 | } | ||
712 | func (dst *GetHostnameResponse) XXX_Merge(src proto.Message) { | ||
713 | xxx_messageInfo_GetHostnameResponse.Merge(dst, src) | ||
714 | } | ||
715 | func (m *GetHostnameResponse) XXX_Size() int { | ||
716 | return xxx_messageInfo_GetHostnameResponse.Size(m) | ||
717 | } | ||
718 | func (m *GetHostnameResponse) XXX_DiscardUnknown() { | ||
719 | xxx_messageInfo_GetHostnameResponse.DiscardUnknown(m) | ||
720 | } | ||
721 | |||
722 | var xxx_messageInfo_GetHostnameResponse proto.InternalMessageInfo | ||
723 | |||
724 | func (m *GetHostnameResponse) GetHostname() string { | ||
725 | if m != nil && m.Hostname != nil { | ||
726 | return *m.Hostname | ||
727 | } | ||
728 | return "" | ||
729 | } | ||
730 | |||
731 | func init() { | ||
732 | proto.RegisterType((*ModulesServiceError)(nil), "appengine.ModulesServiceError") | ||
733 | proto.RegisterType((*GetModulesRequest)(nil), "appengine.GetModulesRequest") | ||
734 | proto.RegisterType((*GetModulesResponse)(nil), "appengine.GetModulesResponse") | ||
735 | proto.RegisterType((*GetVersionsRequest)(nil), "appengine.GetVersionsRequest") | ||
736 | proto.RegisterType((*GetVersionsResponse)(nil), "appengine.GetVersionsResponse") | ||
737 | proto.RegisterType((*GetDefaultVersionRequest)(nil), "appengine.GetDefaultVersionRequest") | ||
738 | proto.RegisterType((*GetDefaultVersionResponse)(nil), "appengine.GetDefaultVersionResponse") | ||
739 | proto.RegisterType((*GetNumInstancesRequest)(nil), "appengine.GetNumInstancesRequest") | ||
740 | proto.RegisterType((*GetNumInstancesResponse)(nil), "appengine.GetNumInstancesResponse") | ||
741 | proto.RegisterType((*SetNumInstancesRequest)(nil), "appengine.SetNumInstancesRequest") | ||
742 | proto.RegisterType((*SetNumInstancesResponse)(nil), "appengine.SetNumInstancesResponse") | ||
743 | proto.RegisterType((*StartModuleRequest)(nil), "appengine.StartModuleRequest") | ||
744 | proto.RegisterType((*StartModuleResponse)(nil), "appengine.StartModuleResponse") | ||
745 | proto.RegisterType((*StopModuleRequest)(nil), "appengine.StopModuleRequest") | ||
746 | proto.RegisterType((*StopModuleResponse)(nil), "appengine.StopModuleResponse") | ||
747 | proto.RegisterType((*GetHostnameRequest)(nil), "appengine.GetHostnameRequest") | ||
748 | proto.RegisterType((*GetHostnameResponse)(nil), "appengine.GetHostnameResponse") | ||
749 | } | ||
750 | |||
751 | func init() { | ||
752 | proto.RegisterFile("google.golang.org/appengine/internal/modules/modules_service.proto", fileDescriptor_modules_service_9cd3bffe4e91c59a) | ||
753 | } | ||
754 | |||
755 | var fileDescriptor_modules_service_9cd3bffe4e91c59a = []byte{ | ||
756 | // 457 bytes of a gzipped FileDescriptorProto | ||
757 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x94, 0xc1, 0x6f, 0xd3, 0x30, | ||
758 | 0x14, 0xc6, 0x69, 0x02, 0xdb, 0xf2, 0x0e, 0x90, 0x3a, 0x5b, 0xd7, 0x4d, 0x1c, 0x50, 0x4e, 0x1c, | ||
759 | 0x50, 0x2b, 0x90, 0x10, 0xe7, 0xae, 0x35, 0x25, 0xb0, 0xa5, 0x28, 0xce, 0x2a, 0xc4, 0xa5, 0x0a, | ||
760 | 0xdb, 0x23, 0x8b, 0x94, 0xda, 0xc1, 0x76, 0x77, 0xe4, 0xbf, 0xe0, 0xff, 0x45, 0x4b, 0xed, 0xb6, | ||
761 | 0x81, 0x4e, 0x45, 0x68, 0xa7, 0xe4, 0x7d, 0xfe, 0xfc, 0x7b, 0x9f, 0x5f, 0xac, 0xc0, 0x59, 0x2e, | ||
762 | 0x44, 0x5e, 0x62, 0x2f, 0x17, 0x65, 0xc6, 0xf3, 0x9e, 0x90, 0x79, 0x3f, 0xab, 0x2a, 0xe4, 0x79, | ||
763 | 0xc1, 0xb1, 0x5f, 0x70, 0x8d, 0x92, 0x67, 0x65, 0x7f, 0x2e, 0xae, 0x17, 0x25, 0x2a, 0xfb, 0x9c, | ||
764 | 0x29, 0x94, 0xb7, 0xc5, 0x15, 0xf6, 0x2a, 0x29, 0xb4, 0x20, 0xde, 0x6a, 0x47, 0xf8, 0xab, 0x05, | ||
765 | 0xc1, 0xc5, 0xd2, 0xc4, 0x96, 0x1e, 0x2a, 0xa5, 0x90, 0xe1, 0x4f, 0xf0, 0xea, 0x97, 0xa1, 0xb8, | ||
766 | 0x46, 0xb2, 0x07, 0xce, 0xe4, 0x93, 0xff, 0x88, 0x10, 0x78, 0x1a, 0xc5, 0xd3, 0xc1, 0x79, 0x34, | ||
767 | 0x9a, 0x5d, 0x4c, 0x46, 0x97, 0xe7, 0xd4, 0x6f, 0x91, 0x00, 0x9e, 0x59, 0x6d, 0x4a, 0x13, 0x16, | ||
768 | 0x4d, 0x62, 0xdf, 0x21, 0x47, 0xd0, 0xb6, 0x62, 0x14, 0xb3, 0x74, 0x10, 0x0f, 0x29, 0xf3, 0xdd, | ||
769 | 0x3b, 0x6f, 0x9a, 0x0c, 0x62, 0x16, 0xd1, 0x38, 0x9d, 0xd1, 0x24, 0x99, 0x24, 0xfe, 0x63, 0x72, | ||
770 | 0x08, 0xfe, 0x65, 0x4c, 0xbf, 0x7c, 0xa6, 0xc3, 0x94, 0x8e, 0x66, 0x2c, 0x1d, 0xa4, 0xd4, 0x7f, | ||
771 | 0x12, 0x06, 0xd0, 0x1e, 0xa3, 0x36, 0xc9, 0x12, 0xfc, 0xb1, 0x40, 0xa5, 0xc3, 0x57, 0x40, 0x36, | ||
772 | 0x45, 0x55, 0x09, 0xae, 0x90, 0x74, 0x60, 0x6f, 0x79, 0xcc, 0x6e, 0xeb, 0x85, 0xfb, 0xd2, 0x4b, | ||
773 | 0x4c, 0x65, 0xdc, 0x53, 0x94, 0xaa, 0x10, 0xdc, 0x32, 0x1a, 0xee, 0xd6, 0x86, 0xbb, 0x0f, 0x41, | ||
774 | 0xc3, 0x6d, 0xe0, 0x5d, 0xd8, 0xbf, 0x5d, 0x6a, 0x86, 0x6e, 0xcb, 0xf0, 0x0d, 0x74, 0xc7, 0xa8, | ||
775 | 0x47, 0xf8, 0x3d, 0x5b, 0x94, 0x76, 0xdf, 0xae, 0x26, 0x6f, 0xe1, 0x64, 0xcb, 0x9e, 0x6d, 0xad, | ||
776 | 0x9c, 0xcd, 0x56, 0x1f, 0xa1, 0x33, 0x46, 0x1d, 0x2f, 0xe6, 0x11, 0x57, 0x3a, 0xe3, 0x57, 0xb8, | ||
777 | 0xeb, 0x34, 0x9b, 0x2c, 0xa7, 0x5e, 0x58, 0xb1, 0xde, 0xc1, 0xf1, 0x5f, 0x2c, 0x13, 0xe0, 0x39, | ||
778 | 0x78, 0x85, 0x15, 0xeb, 0x08, 0x6e, 0xb2, 0x16, 0xc2, 0x1b, 0xe8, 0xb0, 0x07, 0x0a, 0xd1, 0xec, | ||
779 | 0xe4, 0xfe, 0xd9, 0xe9, 0x04, 0x8e, 0xd9, 0xf6, 0x88, 0xe1, 0x7b, 0x20, 0x4c, 0x67, 0xd2, 0xdc, | ||
780 | 0x81, 0x6d, 0x01, 0x9c, 0xfb, 0x02, 0x34, 0x26, 0x7a, 0x04, 0x41, 0x83, 0x63, 0xf0, 0x14, 0xda, | ||
781 | 0x4c, 0x8b, 0xea, 0x7e, 0xfa, 0xbf, 0xcd, 0xf8, 0xf0, 0x2e, 0xe5, 0x1a, 0x63, 0xe0, 0xdf, 0xea, | ||
782 | 0xfb, 0xf8, 0x41, 0x28, 0xcd, 0xb3, 0xf9, 0xff, 0xd3, 0xc9, 0x29, 0x1c, 0xd8, 0x59, 0x75, 0xdd, | ||
783 | 0x7a, 0x69, 0x55, 0x87, 0xaf, 0xeb, 0x5b, 0xbc, 0xee, 0x61, 0xbe, 0xec, 0x29, 0x1c, 0xdc, 0x18, | ||
784 | 0xcd, 0x8c, 0x68, 0x55, 0x9f, 0x79, 0x5f, 0xf7, 0xcd, 0x5f, 0xe2, 0x77, 0x00, 0x00, 0x00, 0xff, | ||
785 | 0xff, 0x6e, 0xbc, 0xe0, 0x61, 0x5c, 0x04, 0x00, 0x00, | ||
786 | } | ||
diff --git a/vendor/google.golang.org/appengine/internal/modules/modules_service.proto b/vendor/google.golang.org/appengine/internal/modules/modules_service.proto new file mode 100644 index 0000000..d29f006 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/modules/modules_service.proto | |||
@@ -0,0 +1,80 @@ | |||
1 | syntax = "proto2"; | ||
2 | option go_package = "modules"; | ||
3 | |||
4 | package appengine; | ||
5 | |||
6 | message ModulesServiceError { | ||
7 | enum ErrorCode { | ||
8 | OK = 0; | ||
9 | INVALID_MODULE = 1; | ||
10 | INVALID_VERSION = 2; | ||
11 | INVALID_INSTANCES = 3; | ||
12 | TRANSIENT_ERROR = 4; | ||
13 | UNEXPECTED_STATE = 5; | ||
14 | } | ||
15 | } | ||
16 | |||
17 | message GetModulesRequest { | ||
18 | } | ||
19 | |||
20 | message GetModulesResponse { | ||
21 | repeated string module = 1; | ||
22 | } | ||
23 | |||
24 | message GetVersionsRequest { | ||
25 | optional string module = 1; | ||
26 | } | ||
27 | |||
28 | message GetVersionsResponse { | ||
29 | repeated string version = 1; | ||
30 | } | ||
31 | |||
32 | message GetDefaultVersionRequest { | ||
33 | optional string module = 1; | ||
34 | } | ||
35 | |||
36 | message GetDefaultVersionResponse { | ||
37 | required string version = 1; | ||
38 | } | ||
39 | |||
40 | message GetNumInstancesRequest { | ||
41 | optional string module = 1; | ||
42 | optional string version = 2; | ||
43 | } | ||
44 | |||
45 | message GetNumInstancesResponse { | ||
46 | required int64 instances = 1; | ||
47 | } | ||
48 | |||
49 | message SetNumInstancesRequest { | ||
50 | optional string module = 1; | ||
51 | optional string version = 2; | ||
52 | required int64 instances = 3; | ||
53 | } | ||
54 | |||
55 | message SetNumInstancesResponse {} | ||
56 | |||
57 | message StartModuleRequest { | ||
58 | required string module = 1; | ||
59 | required string version = 2; | ||
60 | } | ||
61 | |||
62 | message StartModuleResponse {} | ||
63 | |||
64 | message StopModuleRequest { | ||
65 | optional string module = 1; | ||
66 | optional string version = 2; | ||
67 | } | ||
68 | |||
69 | message StopModuleResponse {} | ||
70 | |||
71 | message GetHostnameRequest { | ||
72 | optional string module = 1; | ||
73 | optional string version = 2; | ||
74 | optional string instance = 3; | ||
75 | } | ||
76 | |||
77 | message GetHostnameResponse { | ||
78 | required string hostname = 1; | ||
79 | } | ||
80 | |||
diff --git a/vendor/google.golang.org/appengine/internal/net.go b/vendor/google.golang.org/appengine/internal/net.go new file mode 100644 index 0000000..3b94cf0 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/net.go | |||
@@ -0,0 +1,56 @@ | |||
1 | // Copyright 2014 Google Inc. All rights reserved. | ||
2 | // Use of this source code is governed by the Apache 2.0 | ||
3 | // license that can be found in the LICENSE file. | ||
4 | |||
5 | package internal | ||
6 | |||
7 | // This file implements a network dialer that limits the number of concurrent connections. | ||
8 | // It is only used for API calls. | ||
9 | |||
10 | import ( | ||
11 | "log" | ||
12 | "net" | ||
13 | "runtime" | ||
14 | "sync" | ||
15 | "time" | ||
16 | ) | ||
17 | |||
18 | var limitSem = make(chan int, 100) // TODO(dsymonds): Use environment variable. | ||
19 | |||
20 | func limitRelease() { | ||
21 | // non-blocking | ||
22 | select { | ||
23 | case <-limitSem: | ||
24 | default: | ||
25 | // This should not normally happen. | ||
26 | log.Print("appengine: unbalanced limitSem release!") | ||
27 | } | ||
28 | } | ||
29 | |||
30 | func limitDial(network, addr string) (net.Conn, error) { | ||
31 | limitSem <- 1 | ||
32 | |||
33 | // Dial with a timeout in case the API host is MIA. | ||
34 | // The connection should normally be very fast. | ||
35 | conn, err := net.DialTimeout(network, addr, 500*time.Millisecond) | ||
36 | if err != nil { | ||
37 | limitRelease() | ||
38 | return nil, err | ||
39 | } | ||
40 | lc := &limitConn{Conn: conn} | ||
41 | runtime.SetFinalizer(lc, (*limitConn).Close) // shouldn't usually be required | ||
42 | return lc, nil | ||
43 | } | ||
44 | |||
45 | type limitConn struct { | ||
46 | close sync.Once | ||
47 | net.Conn | ||
48 | } | ||
49 | |||
50 | func (lc *limitConn) Close() error { | ||
51 | defer lc.close.Do(func() { | ||
52 | limitRelease() | ||
53 | runtime.SetFinalizer(lc, nil) | ||
54 | }) | ||
55 | return lc.Conn.Close() | ||
56 | } | ||
diff --git a/vendor/google.golang.org/appengine/internal/regen.sh b/vendor/google.golang.org/appengine/internal/regen.sh new file mode 100644 index 0000000..2fdb546 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/regen.sh | |||
@@ -0,0 +1,40 @@ | |||
1 | #!/bin/bash -e | ||
2 | # | ||
3 | # This script rebuilds the generated code for the protocol buffers. | ||
4 | # To run this you will need protoc and goprotobuf installed; | ||
5 | # see https://github.com/golang/protobuf for instructions. | ||
6 | |||
7 | PKG=google.golang.org/appengine | ||
8 | |||
9 | function die() { | ||
10 | echo 1>&2 $* | ||
11 | exit 1 | ||
12 | } | ||
13 | |||
14 | # Sanity check that the right tools are accessible. | ||
15 | for tool in go protoc protoc-gen-go; do | ||
16 | q=$(which $tool) || die "didn't find $tool" | ||
17 | echo 1>&2 "$tool: $q" | ||
18 | done | ||
19 | |||
20 | echo -n 1>&2 "finding package dir... " | ||
21 | pkgdir=$(go list -f '{{.Dir}}' $PKG) | ||
22 | echo 1>&2 $pkgdir | ||
23 | base=$(echo $pkgdir | sed "s,/$PKG\$,,") | ||
24 | echo 1>&2 "base: $base" | ||
25 | cd $base | ||
26 | |||
27 | # Run protoc once per package. | ||
28 | for dir in $(find $PKG/internal -name '*.proto' | xargs dirname | sort | uniq); do | ||
29 | echo 1>&2 "* $dir" | ||
30 | protoc --go_out=. $dir/*.proto | ||
31 | done | ||
32 | |||
33 | for f in $(find $PKG/internal -name '*.pb.go'); do | ||
34 | # Remove proto.RegisterEnum calls. | ||
35 | # These cause duplicate registration panics when these packages | ||
36 | # are used on classic App Engine. proto.RegisterEnum only affects | ||
37 | # parsing the text format; we don't care about that. | ||
38 | # https://code.google.com/p/googleappengine/issues/detail?id=11670#c17 | ||
39 | sed -i '/proto.RegisterEnum/d' $f | ||
40 | done | ||
diff --git a/vendor/google.golang.org/appengine/internal/remote_api/remote_api.pb.go b/vendor/google.golang.org/appengine/internal/remote_api/remote_api.pb.go new file mode 100644 index 0000000..8d782a3 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/remote_api/remote_api.pb.go | |||
@@ -0,0 +1,361 @@ | |||
1 | // Code generated by protoc-gen-go. DO NOT EDIT. | ||
2 | // source: google.golang.org/appengine/internal/remote_api/remote_api.proto | ||
3 | |||
4 | package remote_api | ||
5 | |||
6 | import proto "github.com/golang/protobuf/proto" | ||
7 | import fmt "fmt" | ||
8 | import math "math" | ||
9 | |||
10 | // Reference imports to suppress errors if they are not otherwise used. | ||
11 | var _ = proto.Marshal | ||
12 | var _ = fmt.Errorf | ||
13 | var _ = math.Inf | ||
14 | |||
15 | // This is a compile-time assertion to ensure that this generated file | ||
16 | // is compatible with the proto package it is being compiled against. | ||
17 | // A compilation error at this line likely means your copy of the | ||
18 | // proto package needs to be updated. | ||
19 | const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package | ||
20 | |||
21 | type RpcError_ErrorCode int32 | ||
22 | |||
23 | const ( | ||
24 | RpcError_UNKNOWN RpcError_ErrorCode = 0 | ||
25 | RpcError_CALL_NOT_FOUND RpcError_ErrorCode = 1 | ||
26 | RpcError_PARSE_ERROR RpcError_ErrorCode = 2 | ||
27 | RpcError_SECURITY_VIOLATION RpcError_ErrorCode = 3 | ||
28 | RpcError_OVER_QUOTA RpcError_ErrorCode = 4 | ||
29 | RpcError_REQUEST_TOO_LARGE RpcError_ErrorCode = 5 | ||
30 | RpcError_CAPABILITY_DISABLED RpcError_ErrorCode = 6 | ||
31 | RpcError_FEATURE_DISABLED RpcError_ErrorCode = 7 | ||
32 | RpcError_BAD_REQUEST RpcError_ErrorCode = 8 | ||
33 | RpcError_RESPONSE_TOO_LARGE RpcError_ErrorCode = 9 | ||
34 | RpcError_CANCELLED RpcError_ErrorCode = 10 | ||
35 | RpcError_REPLAY_ERROR RpcError_ErrorCode = 11 | ||
36 | RpcError_DEADLINE_EXCEEDED RpcError_ErrorCode = 12 | ||
37 | ) | ||
38 | |||
39 | var RpcError_ErrorCode_name = map[int32]string{ | ||
40 | 0: "UNKNOWN", | ||
41 | 1: "CALL_NOT_FOUND", | ||
42 | 2: "PARSE_ERROR", | ||
43 | 3: "SECURITY_VIOLATION", | ||
44 | 4: "OVER_QUOTA", | ||
45 | 5: "REQUEST_TOO_LARGE", | ||
46 | 6: "CAPABILITY_DISABLED", | ||
47 | 7: "FEATURE_DISABLED", | ||
48 | 8: "BAD_REQUEST", | ||
49 | 9: "RESPONSE_TOO_LARGE", | ||
50 | 10: "CANCELLED", | ||
51 | 11: "REPLAY_ERROR", | ||
52 | 12: "DEADLINE_EXCEEDED", | ||
53 | } | ||
54 | var RpcError_ErrorCode_value = map[string]int32{ | ||
55 | "UNKNOWN": 0, | ||
56 | "CALL_NOT_FOUND": 1, | ||
57 | "PARSE_ERROR": 2, | ||
58 | "SECURITY_VIOLATION": 3, | ||
59 | "OVER_QUOTA": 4, | ||
60 | "REQUEST_TOO_LARGE": 5, | ||
61 | "CAPABILITY_DISABLED": 6, | ||
62 | "FEATURE_DISABLED": 7, | ||
63 | "BAD_REQUEST": 8, | ||
64 | "RESPONSE_TOO_LARGE": 9, | ||
65 | "CANCELLED": 10, | ||
66 | "REPLAY_ERROR": 11, | ||
67 | "DEADLINE_EXCEEDED": 12, | ||
68 | } | ||
69 | |||
70 | func (x RpcError_ErrorCode) Enum() *RpcError_ErrorCode { | ||
71 | p := new(RpcError_ErrorCode) | ||
72 | *p = x | ||
73 | return p | ||
74 | } | ||
75 | func (x RpcError_ErrorCode) String() string { | ||
76 | return proto.EnumName(RpcError_ErrorCode_name, int32(x)) | ||
77 | } | ||
78 | func (x *RpcError_ErrorCode) UnmarshalJSON(data []byte) error { | ||
79 | value, err := proto.UnmarshalJSONEnum(RpcError_ErrorCode_value, data, "RpcError_ErrorCode") | ||
80 | if err != nil { | ||
81 | return err | ||
82 | } | ||
83 | *x = RpcError_ErrorCode(value) | ||
84 | return nil | ||
85 | } | ||
86 | func (RpcError_ErrorCode) EnumDescriptor() ([]byte, []int) { | ||
87 | return fileDescriptor_remote_api_1978114ec33a273d, []int{2, 0} | ||
88 | } | ||
89 | |||
90 | type Request struct { | ||
91 | ServiceName *string `protobuf:"bytes,2,req,name=service_name,json=serviceName" json:"service_name,omitempty"` | ||
92 | Method *string `protobuf:"bytes,3,req,name=method" json:"method,omitempty"` | ||
93 | Request []byte `protobuf:"bytes,4,req,name=request" json:"request,omitempty"` | ||
94 | RequestId *string `protobuf:"bytes,5,opt,name=request_id,json=requestId" json:"request_id,omitempty"` | ||
95 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
96 | XXX_unrecognized []byte `json:"-"` | ||
97 | XXX_sizecache int32 `json:"-"` | ||
98 | } | ||
99 | |||
100 | func (m *Request) Reset() { *m = Request{} } | ||
101 | func (m *Request) String() string { return proto.CompactTextString(m) } | ||
102 | func (*Request) ProtoMessage() {} | ||
103 | func (*Request) Descriptor() ([]byte, []int) { | ||
104 | return fileDescriptor_remote_api_1978114ec33a273d, []int{0} | ||
105 | } | ||
106 | func (m *Request) XXX_Unmarshal(b []byte) error { | ||
107 | return xxx_messageInfo_Request.Unmarshal(m, b) | ||
108 | } | ||
109 | func (m *Request) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
110 | return xxx_messageInfo_Request.Marshal(b, m, deterministic) | ||
111 | } | ||
112 | func (dst *Request) XXX_Merge(src proto.Message) { | ||
113 | xxx_messageInfo_Request.Merge(dst, src) | ||
114 | } | ||
115 | func (m *Request) XXX_Size() int { | ||
116 | return xxx_messageInfo_Request.Size(m) | ||
117 | } | ||
118 | func (m *Request) XXX_DiscardUnknown() { | ||
119 | xxx_messageInfo_Request.DiscardUnknown(m) | ||
120 | } | ||
121 | |||
122 | var xxx_messageInfo_Request proto.InternalMessageInfo | ||
123 | |||
124 | func (m *Request) GetServiceName() string { | ||
125 | if m != nil && m.ServiceName != nil { | ||
126 | return *m.ServiceName | ||
127 | } | ||
128 | return "" | ||
129 | } | ||
130 | |||
131 | func (m *Request) GetMethod() string { | ||
132 | if m != nil && m.Method != nil { | ||
133 | return *m.Method | ||
134 | } | ||
135 | return "" | ||
136 | } | ||
137 | |||
138 | func (m *Request) GetRequest() []byte { | ||
139 | if m != nil { | ||
140 | return m.Request | ||
141 | } | ||
142 | return nil | ||
143 | } | ||
144 | |||
145 | func (m *Request) GetRequestId() string { | ||
146 | if m != nil && m.RequestId != nil { | ||
147 | return *m.RequestId | ||
148 | } | ||
149 | return "" | ||
150 | } | ||
151 | |||
152 | type ApplicationError struct { | ||
153 | Code *int32 `protobuf:"varint,1,req,name=code" json:"code,omitempty"` | ||
154 | Detail *string `protobuf:"bytes,2,req,name=detail" json:"detail,omitempty"` | ||
155 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
156 | XXX_unrecognized []byte `json:"-"` | ||
157 | XXX_sizecache int32 `json:"-"` | ||
158 | } | ||
159 | |||
160 | func (m *ApplicationError) Reset() { *m = ApplicationError{} } | ||
161 | func (m *ApplicationError) String() string { return proto.CompactTextString(m) } | ||
162 | func (*ApplicationError) ProtoMessage() {} | ||
163 | func (*ApplicationError) Descriptor() ([]byte, []int) { | ||
164 | return fileDescriptor_remote_api_1978114ec33a273d, []int{1} | ||
165 | } | ||
166 | func (m *ApplicationError) XXX_Unmarshal(b []byte) error { | ||
167 | return xxx_messageInfo_ApplicationError.Unmarshal(m, b) | ||
168 | } | ||
169 | func (m *ApplicationError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
170 | return xxx_messageInfo_ApplicationError.Marshal(b, m, deterministic) | ||
171 | } | ||
172 | func (dst *ApplicationError) XXX_Merge(src proto.Message) { | ||
173 | xxx_messageInfo_ApplicationError.Merge(dst, src) | ||
174 | } | ||
175 | func (m *ApplicationError) XXX_Size() int { | ||
176 | return xxx_messageInfo_ApplicationError.Size(m) | ||
177 | } | ||
178 | func (m *ApplicationError) XXX_DiscardUnknown() { | ||
179 | xxx_messageInfo_ApplicationError.DiscardUnknown(m) | ||
180 | } | ||
181 | |||
182 | var xxx_messageInfo_ApplicationError proto.InternalMessageInfo | ||
183 | |||
184 | func (m *ApplicationError) GetCode() int32 { | ||
185 | if m != nil && m.Code != nil { | ||
186 | return *m.Code | ||
187 | } | ||
188 | return 0 | ||
189 | } | ||
190 | |||
191 | func (m *ApplicationError) GetDetail() string { | ||
192 | if m != nil && m.Detail != nil { | ||
193 | return *m.Detail | ||
194 | } | ||
195 | return "" | ||
196 | } | ||
197 | |||
198 | type RpcError struct { | ||
199 | Code *int32 `protobuf:"varint,1,req,name=code" json:"code,omitempty"` | ||
200 | Detail *string `protobuf:"bytes,2,opt,name=detail" json:"detail,omitempty"` | ||
201 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
202 | XXX_unrecognized []byte `json:"-"` | ||
203 | XXX_sizecache int32 `json:"-"` | ||
204 | } | ||
205 | |||
206 | func (m *RpcError) Reset() { *m = RpcError{} } | ||
207 | func (m *RpcError) String() string { return proto.CompactTextString(m) } | ||
208 | func (*RpcError) ProtoMessage() {} | ||
209 | func (*RpcError) Descriptor() ([]byte, []int) { | ||
210 | return fileDescriptor_remote_api_1978114ec33a273d, []int{2} | ||
211 | } | ||
212 | func (m *RpcError) XXX_Unmarshal(b []byte) error { | ||
213 | return xxx_messageInfo_RpcError.Unmarshal(m, b) | ||
214 | } | ||
215 | func (m *RpcError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
216 | return xxx_messageInfo_RpcError.Marshal(b, m, deterministic) | ||
217 | } | ||
218 | func (dst *RpcError) XXX_Merge(src proto.Message) { | ||
219 | xxx_messageInfo_RpcError.Merge(dst, src) | ||
220 | } | ||
221 | func (m *RpcError) XXX_Size() int { | ||
222 | return xxx_messageInfo_RpcError.Size(m) | ||
223 | } | ||
224 | func (m *RpcError) XXX_DiscardUnknown() { | ||
225 | xxx_messageInfo_RpcError.DiscardUnknown(m) | ||
226 | } | ||
227 | |||
228 | var xxx_messageInfo_RpcError proto.InternalMessageInfo | ||
229 | |||
230 | func (m *RpcError) GetCode() int32 { | ||
231 | if m != nil && m.Code != nil { | ||
232 | return *m.Code | ||
233 | } | ||
234 | return 0 | ||
235 | } | ||
236 | |||
237 | func (m *RpcError) GetDetail() string { | ||
238 | if m != nil && m.Detail != nil { | ||
239 | return *m.Detail | ||
240 | } | ||
241 | return "" | ||
242 | } | ||
243 | |||
244 | type Response struct { | ||
245 | Response []byte `protobuf:"bytes,1,opt,name=response" json:"response,omitempty"` | ||
246 | Exception []byte `protobuf:"bytes,2,opt,name=exception" json:"exception,omitempty"` | ||
247 | ApplicationError *ApplicationError `protobuf:"bytes,3,opt,name=application_error,json=applicationError" json:"application_error,omitempty"` | ||
248 | JavaException []byte `protobuf:"bytes,4,opt,name=java_exception,json=javaException" json:"java_exception,omitempty"` | ||
249 | RpcError *RpcError `protobuf:"bytes,5,opt,name=rpc_error,json=rpcError" json:"rpc_error,omitempty"` | ||
250 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
251 | XXX_unrecognized []byte `json:"-"` | ||
252 | XXX_sizecache int32 `json:"-"` | ||
253 | } | ||
254 | |||
255 | func (m *Response) Reset() { *m = Response{} } | ||
256 | func (m *Response) String() string { return proto.CompactTextString(m) } | ||
257 | func (*Response) ProtoMessage() {} | ||
258 | func (*Response) Descriptor() ([]byte, []int) { | ||
259 | return fileDescriptor_remote_api_1978114ec33a273d, []int{3} | ||
260 | } | ||
261 | func (m *Response) XXX_Unmarshal(b []byte) error { | ||
262 | return xxx_messageInfo_Response.Unmarshal(m, b) | ||
263 | } | ||
264 | func (m *Response) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
265 | return xxx_messageInfo_Response.Marshal(b, m, deterministic) | ||
266 | } | ||
267 | func (dst *Response) XXX_Merge(src proto.Message) { | ||
268 | xxx_messageInfo_Response.Merge(dst, src) | ||
269 | } | ||
270 | func (m *Response) XXX_Size() int { | ||
271 | return xxx_messageInfo_Response.Size(m) | ||
272 | } | ||
273 | func (m *Response) XXX_DiscardUnknown() { | ||
274 | xxx_messageInfo_Response.DiscardUnknown(m) | ||
275 | } | ||
276 | |||
277 | var xxx_messageInfo_Response proto.InternalMessageInfo | ||
278 | |||
279 | func (m *Response) GetResponse() []byte { | ||
280 | if m != nil { | ||
281 | return m.Response | ||
282 | } | ||
283 | return nil | ||
284 | } | ||
285 | |||
286 | func (m *Response) GetException() []byte { | ||
287 | if m != nil { | ||
288 | return m.Exception | ||
289 | } | ||
290 | return nil | ||
291 | } | ||
292 | |||
293 | func (m *Response) GetApplicationError() *ApplicationError { | ||
294 | if m != nil { | ||
295 | return m.ApplicationError | ||
296 | } | ||
297 | return nil | ||
298 | } | ||
299 | |||
300 | func (m *Response) GetJavaException() []byte { | ||
301 | if m != nil { | ||
302 | return m.JavaException | ||
303 | } | ||
304 | return nil | ||
305 | } | ||
306 | |||
307 | func (m *Response) GetRpcError() *RpcError { | ||
308 | if m != nil { | ||
309 | return m.RpcError | ||
310 | } | ||
311 | return nil | ||
312 | } | ||
313 | |||
314 | func init() { | ||
315 | proto.RegisterType((*Request)(nil), "remote_api.Request") | ||
316 | proto.RegisterType((*ApplicationError)(nil), "remote_api.ApplicationError") | ||
317 | proto.RegisterType((*RpcError)(nil), "remote_api.RpcError") | ||
318 | proto.RegisterType((*Response)(nil), "remote_api.Response") | ||
319 | } | ||
320 | |||
321 | func init() { | ||
322 | proto.RegisterFile("google.golang.org/appengine/internal/remote_api/remote_api.proto", fileDescriptor_remote_api_1978114ec33a273d) | ||
323 | } | ||
324 | |||
325 | var fileDescriptor_remote_api_1978114ec33a273d = []byte{ | ||
326 | // 531 bytes of a gzipped FileDescriptorProto | ||
327 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x8c, 0x93, 0x51, 0x6e, 0xd3, 0x40, | ||
328 | 0x10, 0x86, 0xb1, 0x9b, 0x34, 0xf1, 0xc4, 0x2d, 0xdb, 0xa5, 0x14, 0x0b, 0x15, 0x29, 0x44, 0x42, | ||
329 | 0xca, 0x53, 0x2a, 0x38, 0x00, 0x62, 0x63, 0x6f, 0x91, 0x85, 0x65, 0xa7, 0x6b, 0xbb, 0x50, 0x5e, | ||
330 | 0x56, 0x2b, 0x67, 0x65, 0x8c, 0x12, 0xaf, 0xd9, 0x98, 0x8a, 0x17, 0x6e, 0xc0, 0xb5, 0x38, 0x0c, | ||
331 | 0xb7, 0x40, 0x36, 0x6e, 0x63, 0xf5, 0x89, 0xb7, 0x7f, 0x7e, 0x7b, 0xe6, 0x1b, 0xcd, 0xcc, 0xc2, | ||
332 | 0xbb, 0x5c, 0xa9, 0x7c, 0x23, 0x17, 0xb9, 0xda, 0x88, 0x32, 0x5f, 0x28, 0x9d, 0x5f, 0x88, 0xaa, | ||
333 | 0x92, 0x65, 0x5e, 0x94, 0xf2, 0xa2, 0x28, 0x6b, 0xa9, 0x4b, 0xb1, 0xb9, 0xd0, 0x72, 0xab, 0x6a, | ||
334 | 0xc9, 0x45, 0x55, 0xf4, 0xe4, 0xa2, 0xd2, 0xaa, 0x56, 0x18, 0xf6, 0xce, 0xec, 0x27, 0x8c, 0x98, | ||
335 | 0xfc, 0xf6, 0x5d, 0xee, 0x6a, 0xfc, 0x12, 0xec, 0x9d, 0xd4, 0xb7, 0x45, 0x26, 0x79, 0x29, 0xb6, | ||
336 | 0xd2, 0x31, 0xa7, 0xe6, 0xdc, 0x62, 0x93, 0xce, 0x0b, 0xc5, 0x56, 0xe2, 0x33, 0x38, 0xdc, 0xca, | ||
337 | 0xfa, 0x8b, 0x5a, 0x3b, 0x07, 0xed, 0xc7, 0x2e, 0xc2, 0x0e, 0x8c, 0xf4, 0xbf, 0x2a, 0xce, 0x60, | ||
338 | 0x6a, 0xce, 0x6d, 0x76, 0x17, 0xe2, 0x17, 0x00, 0x9d, 0xe4, 0xc5, 0xda, 0x19, 0x4e, 0x8d, 0xb9, | ||
339 | 0xc5, 0xac, 0xce, 0xf1, 0xd7, 0xb3, 0xb7, 0x80, 0x48, 0x55, 0x6d, 0x8a, 0x4c, 0xd4, 0x85, 0x2a, | ||
340 | 0xa9, 0xd6, 0x4a, 0x63, 0x0c, 0x83, 0x4c, 0xad, 0xa5, 0x63, 0x4c, 0xcd, 0xf9, 0x90, 0xb5, 0xba, | ||
341 | 0x01, 0xaf, 0x65, 0x2d, 0x8a, 0x4d, 0xd7, 0x55, 0x17, 0xcd, 0x7e, 0x9b, 0x30, 0x66, 0x55, 0xf6, | ||
342 | 0x7f, 0x89, 0x46, 0x2f, 0xf1, 0x97, 0x09, 0x56, 0x9b, 0xe5, 0x36, 0x7f, 0x4d, 0x60, 0x94, 0x86, | ||
343 | 0x1f, 0xc2, 0xe8, 0x63, 0x88, 0x1e, 0x61, 0x0c, 0xc7, 0x2e, 0x09, 0x02, 0x1e, 0x46, 0x09, 0xbf, | ||
344 | 0x8c, 0xd2, 0xd0, 0x43, 0x06, 0x7e, 0x0c, 0x93, 0x15, 0x61, 0x31, 0xe5, 0x94, 0xb1, 0x88, 0x21, | ||
345 | 0x13, 0x9f, 0x01, 0x8e, 0xa9, 0x9b, 0x32, 0x3f, 0xb9, 0xe1, 0xd7, 0x7e, 0x14, 0x90, 0xc4, 0x8f, | ||
346 | 0x42, 0x74, 0x80, 0x8f, 0x01, 0xa2, 0x6b, 0xca, 0xf8, 0x55, 0x1a, 0x25, 0x04, 0x0d, 0xf0, 0x53, | ||
347 | 0x38, 0x61, 0xf4, 0x2a, 0xa5, 0x71, 0xc2, 0x93, 0x28, 0xe2, 0x01, 0x61, 0xef, 0x29, 0x1a, 0xe2, | ||
348 | 0x67, 0xf0, 0xc4, 0x25, 0x2b, 0xb2, 0xf4, 0x83, 0xa6, 0x80, 0xe7, 0xc7, 0x64, 0x19, 0x50, 0x0f, | ||
349 | 0x1d, 0xe2, 0x53, 0x40, 0x97, 0x94, 0x24, 0x29, 0xa3, 0x7b, 0x77, 0xd4, 0xe0, 0x97, 0xc4, 0xe3, | ||
350 | 0x5d, 0x25, 0x34, 0x6e, 0xf0, 0x8c, 0xc6, 0xab, 0x28, 0x8c, 0x69, 0xaf, 0xae, 0x85, 0x8f, 0xc0, | ||
351 | 0x72, 0x49, 0xe8, 0xd2, 0xa0, 0xc9, 0x03, 0x8c, 0xc0, 0x66, 0x74, 0x15, 0x90, 0x9b, 0xae, 0xef, | ||
352 | 0x49, 0xd3, 0x8f, 0x47, 0x89, 0x17, 0xf8, 0x21, 0xe5, 0xf4, 0x93, 0x4b, 0xa9, 0x47, 0x3d, 0x64, | ||
353 | 0xcf, 0xfe, 0x18, 0x30, 0x66, 0x72, 0x57, 0xa9, 0x72, 0x27, 0xf1, 0x73, 0x18, 0xeb, 0x4e, 0x3b, | ||
354 | 0xc6, 0xd4, 0x98, 0xdb, 0xec, 0x3e, 0xc6, 0xe7, 0x60, 0xc9, 0x1f, 0x99, 0xac, 0x9a, 0x75, 0xb5, | ||
355 | 0x23, 0xb5, 0xd9, 0xde, 0xc0, 0x3e, 0x9c, 0x88, 0xfd, 0x3a, 0xb9, 0x6c, 0x06, 0xec, 0x1c, 0x4c, | ||
356 | 0x8d, 0xf9, 0xe4, 0xcd, 0xf9, 0xa2, 0x77, 0x87, 0x0f, 0x77, 0xce, 0x90, 0x78, 0x78, 0x05, 0xaf, | ||
357 | 0xe0, 0xf8, 0xab, 0xb8, 0x15, 0x7c, 0x4f, 0x1b, 0xb4, 0xb4, 0xa3, 0xc6, 0xa5, 0xf7, 0xc4, 0xd7, | ||
358 | 0x60, 0xe9, 0x2a, 0xeb, 0x48, 0xc3, 0x96, 0x74, 0xda, 0x27, 0xdd, 0x1d, 0x07, 0x1b, 0xeb, 0x4e, | ||
359 | 0x2d, 0xed, 0xcf, 0xbd, 0x07, 0xf0, 0x37, 0x00, 0x00, 0xff, 0xff, 0x38, 0xd1, 0x0f, 0x22, 0x4f, | ||
360 | 0x03, 0x00, 0x00, | ||
361 | } | ||
diff --git a/vendor/google.golang.org/appengine/internal/remote_api/remote_api.proto b/vendor/google.golang.org/appengine/internal/remote_api/remote_api.proto new file mode 100644 index 0000000..f21763a --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/remote_api/remote_api.proto | |||
@@ -0,0 +1,44 @@ | |||
1 | syntax = "proto2"; | ||
2 | option go_package = "remote_api"; | ||
3 | |||
4 | package remote_api; | ||
5 | |||
6 | message Request { | ||
7 | required string service_name = 2; | ||
8 | required string method = 3; | ||
9 | required bytes request = 4; | ||
10 | optional string request_id = 5; | ||
11 | } | ||
12 | |||
13 | message ApplicationError { | ||
14 | required int32 code = 1; | ||
15 | required string detail = 2; | ||
16 | } | ||
17 | |||
18 | message RpcError { | ||
19 | enum ErrorCode { | ||
20 | UNKNOWN = 0; | ||
21 | CALL_NOT_FOUND = 1; | ||
22 | PARSE_ERROR = 2; | ||
23 | SECURITY_VIOLATION = 3; | ||
24 | OVER_QUOTA = 4; | ||
25 | REQUEST_TOO_LARGE = 5; | ||
26 | CAPABILITY_DISABLED = 6; | ||
27 | FEATURE_DISABLED = 7; | ||
28 | BAD_REQUEST = 8; | ||
29 | RESPONSE_TOO_LARGE = 9; | ||
30 | CANCELLED = 10; | ||
31 | REPLAY_ERROR = 11; | ||
32 | DEADLINE_EXCEEDED = 12; | ||
33 | } | ||
34 | required int32 code = 1; | ||
35 | optional string detail = 2; | ||
36 | } | ||
37 | |||
38 | message Response { | ||
39 | optional bytes response = 1; | ||
40 | optional bytes exception = 2; | ||
41 | optional ApplicationError application_error = 3; | ||
42 | optional bytes java_exception = 4; | ||
43 | optional RpcError rpc_error = 5; | ||
44 | } | ||
diff --git a/vendor/google.golang.org/appengine/internal/transaction.go b/vendor/google.golang.org/appengine/internal/transaction.go new file mode 100644 index 0000000..9006ae6 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/transaction.go | |||
@@ -0,0 +1,115 @@ | |||
1 | // Copyright 2014 Google Inc. All rights reserved. | ||
2 | // Use of this source code is governed by the Apache 2.0 | ||
3 | // license that can be found in the LICENSE file. | ||
4 | |||
5 | package internal | ||
6 | |||
7 | // This file implements hooks for applying datastore transactions. | ||
8 | |||
9 | import ( | ||
10 | "errors" | ||
11 | "reflect" | ||
12 | |||
13 | "github.com/golang/protobuf/proto" | ||
14 | netcontext "golang.org/x/net/context" | ||
15 | |||
16 | basepb "google.golang.org/appengine/internal/base" | ||
17 | pb "google.golang.org/appengine/internal/datastore" | ||
18 | ) | ||
19 | |||
20 | var transactionSetters = make(map[reflect.Type]reflect.Value) | ||
21 | |||
22 | // RegisterTransactionSetter registers a function that sets transaction information | ||
23 | // in a protocol buffer message. f should be a function with two arguments, | ||
24 | // the first being a protocol buffer type, and the second being *datastore.Transaction. | ||
25 | func RegisterTransactionSetter(f interface{}) { | ||
26 | v := reflect.ValueOf(f) | ||
27 | transactionSetters[v.Type().In(0)] = v | ||
28 | } | ||
29 | |||
30 | // applyTransaction applies the transaction t to message pb | ||
31 | // by using the relevant setter passed to RegisterTransactionSetter. | ||
32 | func applyTransaction(pb proto.Message, t *pb.Transaction) { | ||
33 | v := reflect.ValueOf(pb) | ||
34 | if f, ok := transactionSetters[v.Type()]; ok { | ||
35 | f.Call([]reflect.Value{v, reflect.ValueOf(t)}) | ||
36 | } | ||
37 | } | ||
38 | |||
39 | var transactionKey = "used for *Transaction" | ||
40 | |||
41 | func transactionFromContext(ctx netcontext.Context) *transaction { | ||
42 | t, _ := ctx.Value(&transactionKey).(*transaction) | ||
43 | return t | ||
44 | } | ||
45 | |||
46 | func withTransaction(ctx netcontext.Context, t *transaction) netcontext.Context { | ||
47 | return netcontext.WithValue(ctx, &transactionKey, t) | ||
48 | } | ||
49 | |||
50 | type transaction struct { | ||
51 | transaction pb.Transaction | ||
52 | finished bool | ||
53 | } | ||
54 | |||
55 | var ErrConcurrentTransaction = errors.New("internal: concurrent transaction") | ||
56 | |||
57 | func RunTransactionOnce(c netcontext.Context, f func(netcontext.Context) error, xg bool, readOnly bool, previousTransaction *pb.Transaction) (*pb.Transaction, error) { | ||
58 | if transactionFromContext(c) != nil { | ||
59 | return nil, errors.New("nested transactions are not supported") | ||
60 | } | ||
61 | |||
62 | // Begin the transaction. | ||
63 | t := &transaction{} | ||
64 | req := &pb.BeginTransactionRequest{ | ||
65 | App: proto.String(FullyQualifiedAppID(c)), | ||
66 | } | ||
67 | if xg { | ||
68 | req.AllowMultipleEg = proto.Bool(true) | ||
69 | } | ||
70 | if previousTransaction != nil { | ||
71 | req.PreviousTransaction = previousTransaction | ||
72 | } | ||
73 | if readOnly { | ||
74 | req.Mode = pb.BeginTransactionRequest_READ_ONLY.Enum() | ||
75 | } else { | ||
76 | req.Mode = pb.BeginTransactionRequest_READ_WRITE.Enum() | ||
77 | } | ||
78 | if err := Call(c, "datastore_v3", "BeginTransaction", req, &t.transaction); err != nil { | ||
79 | return nil, err | ||
80 | } | ||
81 | |||
82 | // Call f, rolling back the transaction if f returns a non-nil error, or panics. | ||
83 | // The panic is not recovered. | ||
84 | defer func() { | ||
85 | if t.finished { | ||
86 | return | ||
87 | } | ||
88 | t.finished = true | ||
89 | // Ignore the error return value, since we are already returning a non-nil | ||
90 | // error (or we're panicking). | ||
91 | Call(c, "datastore_v3", "Rollback", &t.transaction, &basepb.VoidProto{}) | ||
92 | }() | ||
93 | if err := f(withTransaction(c, t)); err != nil { | ||
94 | return &t.transaction, err | ||
95 | } | ||
96 | t.finished = true | ||
97 | |||
98 | // Commit the transaction. | ||
99 | res := &pb.CommitResponse{} | ||
100 | err := Call(c, "datastore_v3", "Commit", &t.transaction, res) | ||
101 | if ae, ok := err.(*APIError); ok { | ||
102 | /* TODO: restore this conditional | ||
103 | if appengine.IsDevAppServer() { | ||
104 | */ | ||
105 | // The Python Dev AppServer raises an ApplicationError with error code 2 (which is | ||
106 | // Error.CONCURRENT_TRANSACTION) and message "Concurrency exception.". | ||
107 | if ae.Code == int32(pb.Error_BAD_REQUEST) && ae.Detail == "ApplicationError: 2 Concurrency exception." { | ||
108 | return &t.transaction, ErrConcurrentTransaction | ||
109 | } | ||
110 | if ae.Code == int32(pb.Error_CONCURRENT_TRANSACTION) { | ||
111 | return &t.transaction, ErrConcurrentTransaction | ||
112 | } | ||
113 | } | ||
114 | return &t.transaction, err | ||
115 | } | ||
diff --git a/vendor/google.golang.org/appengine/internal/urlfetch/urlfetch_service.pb.go b/vendor/google.golang.org/appengine/internal/urlfetch/urlfetch_service.pb.go new file mode 100644 index 0000000..5f72775 --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/urlfetch/urlfetch_service.pb.go | |||
@@ -0,0 +1,527 @@ | |||
1 | // Code generated by protoc-gen-go. DO NOT EDIT. | ||
2 | // source: google.golang.org/appengine/internal/urlfetch/urlfetch_service.proto | ||
3 | |||
4 | package urlfetch | ||
5 | |||
6 | import proto "github.com/golang/protobuf/proto" | ||
7 | import fmt "fmt" | ||
8 | import math "math" | ||
9 | |||
10 | // Reference imports to suppress errors if they are not otherwise used. | ||
11 | var _ = proto.Marshal | ||
12 | var _ = fmt.Errorf | ||
13 | var _ = math.Inf | ||
14 | |||
15 | // This is a compile-time assertion to ensure that this generated file | ||
16 | // is compatible with the proto package it is being compiled against. | ||
17 | // A compilation error at this line likely means your copy of the | ||
18 | // proto package needs to be updated. | ||
19 | const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package | ||
20 | |||
21 | type URLFetchServiceError_ErrorCode int32 | ||
22 | |||
23 | const ( | ||
24 | URLFetchServiceError_OK URLFetchServiceError_ErrorCode = 0 | ||
25 | URLFetchServiceError_INVALID_URL URLFetchServiceError_ErrorCode = 1 | ||
26 | URLFetchServiceError_FETCH_ERROR URLFetchServiceError_ErrorCode = 2 | ||
27 | URLFetchServiceError_UNSPECIFIED_ERROR URLFetchServiceError_ErrorCode = 3 | ||
28 | URLFetchServiceError_RESPONSE_TOO_LARGE URLFetchServiceError_ErrorCode = 4 | ||
29 | URLFetchServiceError_DEADLINE_EXCEEDED URLFetchServiceError_ErrorCode = 5 | ||
30 | URLFetchServiceError_SSL_CERTIFICATE_ERROR URLFetchServiceError_ErrorCode = 6 | ||
31 | URLFetchServiceError_DNS_ERROR URLFetchServiceError_ErrorCode = 7 | ||
32 | URLFetchServiceError_CLOSED URLFetchServiceError_ErrorCode = 8 | ||
33 | URLFetchServiceError_INTERNAL_TRANSIENT_ERROR URLFetchServiceError_ErrorCode = 9 | ||
34 | URLFetchServiceError_TOO_MANY_REDIRECTS URLFetchServiceError_ErrorCode = 10 | ||
35 | URLFetchServiceError_MALFORMED_REPLY URLFetchServiceError_ErrorCode = 11 | ||
36 | URLFetchServiceError_CONNECTION_ERROR URLFetchServiceError_ErrorCode = 12 | ||
37 | ) | ||
38 | |||
39 | var URLFetchServiceError_ErrorCode_name = map[int32]string{ | ||
40 | 0: "OK", | ||
41 | 1: "INVALID_URL", | ||
42 | 2: "FETCH_ERROR", | ||
43 | 3: "UNSPECIFIED_ERROR", | ||
44 | 4: "RESPONSE_TOO_LARGE", | ||
45 | 5: "DEADLINE_EXCEEDED", | ||
46 | 6: "SSL_CERTIFICATE_ERROR", | ||
47 | 7: "DNS_ERROR", | ||
48 | 8: "CLOSED", | ||
49 | 9: "INTERNAL_TRANSIENT_ERROR", | ||
50 | 10: "TOO_MANY_REDIRECTS", | ||
51 | 11: "MALFORMED_REPLY", | ||
52 | 12: "CONNECTION_ERROR", | ||
53 | } | ||
54 | var URLFetchServiceError_ErrorCode_value = map[string]int32{ | ||
55 | "OK": 0, | ||
56 | "INVALID_URL": 1, | ||
57 | "FETCH_ERROR": 2, | ||
58 | "UNSPECIFIED_ERROR": 3, | ||
59 | "RESPONSE_TOO_LARGE": 4, | ||
60 | "DEADLINE_EXCEEDED": 5, | ||
61 | "SSL_CERTIFICATE_ERROR": 6, | ||
62 | "DNS_ERROR": 7, | ||
63 | "CLOSED": 8, | ||
64 | "INTERNAL_TRANSIENT_ERROR": 9, | ||
65 | "TOO_MANY_REDIRECTS": 10, | ||
66 | "MALFORMED_REPLY": 11, | ||
67 | "CONNECTION_ERROR": 12, | ||
68 | } | ||
69 | |||
70 | func (x URLFetchServiceError_ErrorCode) Enum() *URLFetchServiceError_ErrorCode { | ||
71 | p := new(URLFetchServiceError_ErrorCode) | ||
72 | *p = x | ||
73 | return p | ||
74 | } | ||
75 | func (x URLFetchServiceError_ErrorCode) String() string { | ||
76 | return proto.EnumName(URLFetchServiceError_ErrorCode_name, int32(x)) | ||
77 | } | ||
78 | func (x *URLFetchServiceError_ErrorCode) UnmarshalJSON(data []byte) error { | ||
79 | value, err := proto.UnmarshalJSONEnum(URLFetchServiceError_ErrorCode_value, data, "URLFetchServiceError_ErrorCode") | ||
80 | if err != nil { | ||
81 | return err | ||
82 | } | ||
83 | *x = URLFetchServiceError_ErrorCode(value) | ||
84 | return nil | ||
85 | } | ||
86 | func (URLFetchServiceError_ErrorCode) EnumDescriptor() ([]byte, []int) { | ||
87 | return fileDescriptor_urlfetch_service_b245a7065f33bced, []int{0, 0} | ||
88 | } | ||
89 | |||
90 | type URLFetchRequest_RequestMethod int32 | ||
91 | |||
92 | const ( | ||
93 | URLFetchRequest_GET URLFetchRequest_RequestMethod = 1 | ||
94 | URLFetchRequest_POST URLFetchRequest_RequestMethod = 2 | ||
95 | URLFetchRequest_HEAD URLFetchRequest_RequestMethod = 3 | ||
96 | URLFetchRequest_PUT URLFetchRequest_RequestMethod = 4 | ||
97 | URLFetchRequest_DELETE URLFetchRequest_RequestMethod = 5 | ||
98 | URLFetchRequest_PATCH URLFetchRequest_RequestMethod = 6 | ||
99 | ) | ||
100 | |||
101 | var URLFetchRequest_RequestMethod_name = map[int32]string{ | ||
102 | 1: "GET", | ||
103 | 2: "POST", | ||
104 | 3: "HEAD", | ||
105 | 4: "PUT", | ||
106 | 5: "DELETE", | ||
107 | 6: "PATCH", | ||
108 | } | ||
109 | var URLFetchRequest_RequestMethod_value = map[string]int32{ | ||
110 | "GET": 1, | ||
111 | "POST": 2, | ||
112 | "HEAD": 3, | ||
113 | "PUT": 4, | ||
114 | "DELETE": 5, | ||
115 | "PATCH": 6, | ||
116 | } | ||
117 | |||
118 | func (x URLFetchRequest_RequestMethod) Enum() *URLFetchRequest_RequestMethod { | ||
119 | p := new(URLFetchRequest_RequestMethod) | ||
120 | *p = x | ||
121 | return p | ||
122 | } | ||
123 | func (x URLFetchRequest_RequestMethod) String() string { | ||
124 | return proto.EnumName(URLFetchRequest_RequestMethod_name, int32(x)) | ||
125 | } | ||
126 | func (x *URLFetchRequest_RequestMethod) UnmarshalJSON(data []byte) error { | ||
127 | value, err := proto.UnmarshalJSONEnum(URLFetchRequest_RequestMethod_value, data, "URLFetchRequest_RequestMethod") | ||
128 | if err != nil { | ||
129 | return err | ||
130 | } | ||
131 | *x = URLFetchRequest_RequestMethod(value) | ||
132 | return nil | ||
133 | } | ||
134 | func (URLFetchRequest_RequestMethod) EnumDescriptor() ([]byte, []int) { | ||
135 | return fileDescriptor_urlfetch_service_b245a7065f33bced, []int{1, 0} | ||
136 | } | ||
137 | |||
138 | type URLFetchServiceError struct { | ||
139 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
140 | XXX_unrecognized []byte `json:"-"` | ||
141 | XXX_sizecache int32 `json:"-"` | ||
142 | } | ||
143 | |||
144 | func (m *URLFetchServiceError) Reset() { *m = URLFetchServiceError{} } | ||
145 | func (m *URLFetchServiceError) String() string { return proto.CompactTextString(m) } | ||
146 | func (*URLFetchServiceError) ProtoMessage() {} | ||
147 | func (*URLFetchServiceError) Descriptor() ([]byte, []int) { | ||
148 | return fileDescriptor_urlfetch_service_b245a7065f33bced, []int{0} | ||
149 | } | ||
150 | func (m *URLFetchServiceError) XXX_Unmarshal(b []byte) error { | ||
151 | return xxx_messageInfo_URLFetchServiceError.Unmarshal(m, b) | ||
152 | } | ||
153 | func (m *URLFetchServiceError) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
154 | return xxx_messageInfo_URLFetchServiceError.Marshal(b, m, deterministic) | ||
155 | } | ||
156 | func (dst *URLFetchServiceError) XXX_Merge(src proto.Message) { | ||
157 | xxx_messageInfo_URLFetchServiceError.Merge(dst, src) | ||
158 | } | ||
159 | func (m *URLFetchServiceError) XXX_Size() int { | ||
160 | return xxx_messageInfo_URLFetchServiceError.Size(m) | ||
161 | } | ||
162 | func (m *URLFetchServiceError) XXX_DiscardUnknown() { | ||
163 | xxx_messageInfo_URLFetchServiceError.DiscardUnknown(m) | ||
164 | } | ||
165 | |||
166 | var xxx_messageInfo_URLFetchServiceError proto.InternalMessageInfo | ||
167 | |||
168 | type URLFetchRequest struct { | ||
169 | Method *URLFetchRequest_RequestMethod `protobuf:"varint,1,req,name=Method,enum=appengine.URLFetchRequest_RequestMethod" json:"Method,omitempty"` | ||
170 | Url *string `protobuf:"bytes,2,req,name=Url" json:"Url,omitempty"` | ||
171 | Header []*URLFetchRequest_Header `protobuf:"group,3,rep,name=Header,json=header" json:"header,omitempty"` | ||
172 | Payload []byte `protobuf:"bytes,6,opt,name=Payload" json:"Payload,omitempty"` | ||
173 | FollowRedirects *bool `protobuf:"varint,7,opt,name=FollowRedirects,def=1" json:"FollowRedirects,omitempty"` | ||
174 | Deadline *float64 `protobuf:"fixed64,8,opt,name=Deadline" json:"Deadline,omitempty"` | ||
175 | MustValidateServerCertificate *bool `protobuf:"varint,9,opt,name=MustValidateServerCertificate,def=1" json:"MustValidateServerCertificate,omitempty"` | ||
176 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
177 | XXX_unrecognized []byte `json:"-"` | ||
178 | XXX_sizecache int32 `json:"-"` | ||
179 | } | ||
180 | |||
181 | func (m *URLFetchRequest) Reset() { *m = URLFetchRequest{} } | ||
182 | func (m *URLFetchRequest) String() string { return proto.CompactTextString(m) } | ||
183 | func (*URLFetchRequest) ProtoMessage() {} | ||
184 | func (*URLFetchRequest) Descriptor() ([]byte, []int) { | ||
185 | return fileDescriptor_urlfetch_service_b245a7065f33bced, []int{1} | ||
186 | } | ||
187 | func (m *URLFetchRequest) XXX_Unmarshal(b []byte) error { | ||
188 | return xxx_messageInfo_URLFetchRequest.Unmarshal(m, b) | ||
189 | } | ||
190 | func (m *URLFetchRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
191 | return xxx_messageInfo_URLFetchRequest.Marshal(b, m, deterministic) | ||
192 | } | ||
193 | func (dst *URLFetchRequest) XXX_Merge(src proto.Message) { | ||
194 | xxx_messageInfo_URLFetchRequest.Merge(dst, src) | ||
195 | } | ||
196 | func (m *URLFetchRequest) XXX_Size() int { | ||
197 | return xxx_messageInfo_URLFetchRequest.Size(m) | ||
198 | } | ||
199 | func (m *URLFetchRequest) XXX_DiscardUnknown() { | ||
200 | xxx_messageInfo_URLFetchRequest.DiscardUnknown(m) | ||
201 | } | ||
202 | |||
203 | var xxx_messageInfo_URLFetchRequest proto.InternalMessageInfo | ||
204 | |||
205 | const Default_URLFetchRequest_FollowRedirects bool = true | ||
206 | const Default_URLFetchRequest_MustValidateServerCertificate bool = true | ||
207 | |||
208 | func (m *URLFetchRequest) GetMethod() URLFetchRequest_RequestMethod { | ||
209 | if m != nil && m.Method != nil { | ||
210 | return *m.Method | ||
211 | } | ||
212 | return URLFetchRequest_GET | ||
213 | } | ||
214 | |||
215 | func (m *URLFetchRequest) GetUrl() string { | ||
216 | if m != nil && m.Url != nil { | ||
217 | return *m.Url | ||
218 | } | ||
219 | return "" | ||
220 | } | ||
221 | |||
222 | func (m *URLFetchRequest) GetHeader() []*URLFetchRequest_Header { | ||
223 | if m != nil { | ||
224 | return m.Header | ||
225 | } | ||
226 | return nil | ||
227 | } | ||
228 | |||
229 | func (m *URLFetchRequest) GetPayload() []byte { | ||
230 | if m != nil { | ||
231 | return m.Payload | ||
232 | } | ||
233 | return nil | ||
234 | } | ||
235 | |||
236 | func (m *URLFetchRequest) GetFollowRedirects() bool { | ||
237 | if m != nil && m.FollowRedirects != nil { | ||
238 | return *m.FollowRedirects | ||
239 | } | ||
240 | return Default_URLFetchRequest_FollowRedirects | ||
241 | } | ||
242 | |||
243 | func (m *URLFetchRequest) GetDeadline() float64 { | ||
244 | if m != nil && m.Deadline != nil { | ||
245 | return *m.Deadline | ||
246 | } | ||
247 | return 0 | ||
248 | } | ||
249 | |||
250 | func (m *URLFetchRequest) GetMustValidateServerCertificate() bool { | ||
251 | if m != nil && m.MustValidateServerCertificate != nil { | ||
252 | return *m.MustValidateServerCertificate | ||
253 | } | ||
254 | return Default_URLFetchRequest_MustValidateServerCertificate | ||
255 | } | ||
256 | |||
257 | type URLFetchRequest_Header struct { | ||
258 | Key *string `protobuf:"bytes,4,req,name=Key" json:"Key,omitempty"` | ||
259 | Value *string `protobuf:"bytes,5,req,name=Value" json:"Value,omitempty"` | ||
260 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
261 | XXX_unrecognized []byte `json:"-"` | ||
262 | XXX_sizecache int32 `json:"-"` | ||
263 | } | ||
264 | |||
265 | func (m *URLFetchRequest_Header) Reset() { *m = URLFetchRequest_Header{} } | ||
266 | func (m *URLFetchRequest_Header) String() string { return proto.CompactTextString(m) } | ||
267 | func (*URLFetchRequest_Header) ProtoMessage() {} | ||
268 | func (*URLFetchRequest_Header) Descriptor() ([]byte, []int) { | ||
269 | return fileDescriptor_urlfetch_service_b245a7065f33bced, []int{1, 0} | ||
270 | } | ||
271 | func (m *URLFetchRequest_Header) XXX_Unmarshal(b []byte) error { | ||
272 | return xxx_messageInfo_URLFetchRequest_Header.Unmarshal(m, b) | ||
273 | } | ||
274 | func (m *URLFetchRequest_Header) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
275 | return xxx_messageInfo_URLFetchRequest_Header.Marshal(b, m, deterministic) | ||
276 | } | ||
277 | func (dst *URLFetchRequest_Header) XXX_Merge(src proto.Message) { | ||
278 | xxx_messageInfo_URLFetchRequest_Header.Merge(dst, src) | ||
279 | } | ||
280 | func (m *URLFetchRequest_Header) XXX_Size() int { | ||
281 | return xxx_messageInfo_URLFetchRequest_Header.Size(m) | ||
282 | } | ||
283 | func (m *URLFetchRequest_Header) XXX_DiscardUnknown() { | ||
284 | xxx_messageInfo_URLFetchRequest_Header.DiscardUnknown(m) | ||
285 | } | ||
286 | |||
287 | var xxx_messageInfo_URLFetchRequest_Header proto.InternalMessageInfo | ||
288 | |||
289 | func (m *URLFetchRequest_Header) GetKey() string { | ||
290 | if m != nil && m.Key != nil { | ||
291 | return *m.Key | ||
292 | } | ||
293 | return "" | ||
294 | } | ||
295 | |||
296 | func (m *URLFetchRequest_Header) GetValue() string { | ||
297 | if m != nil && m.Value != nil { | ||
298 | return *m.Value | ||
299 | } | ||
300 | return "" | ||
301 | } | ||
302 | |||
303 | type URLFetchResponse struct { | ||
304 | Content []byte `protobuf:"bytes,1,opt,name=Content" json:"Content,omitempty"` | ||
305 | StatusCode *int32 `protobuf:"varint,2,req,name=StatusCode" json:"StatusCode,omitempty"` | ||
306 | Header []*URLFetchResponse_Header `protobuf:"group,3,rep,name=Header,json=header" json:"header,omitempty"` | ||
307 | ContentWasTruncated *bool `protobuf:"varint,6,opt,name=ContentWasTruncated,def=0" json:"ContentWasTruncated,omitempty"` | ||
308 | ExternalBytesSent *int64 `protobuf:"varint,7,opt,name=ExternalBytesSent" json:"ExternalBytesSent,omitempty"` | ||
309 | ExternalBytesReceived *int64 `protobuf:"varint,8,opt,name=ExternalBytesReceived" json:"ExternalBytesReceived,omitempty"` | ||
310 | FinalUrl *string `protobuf:"bytes,9,opt,name=FinalUrl" json:"FinalUrl,omitempty"` | ||
311 | ApiCpuMilliseconds *int64 `protobuf:"varint,10,opt,name=ApiCpuMilliseconds,def=0" json:"ApiCpuMilliseconds,omitempty"` | ||
312 | ApiBytesSent *int64 `protobuf:"varint,11,opt,name=ApiBytesSent,def=0" json:"ApiBytesSent,omitempty"` | ||
313 | ApiBytesReceived *int64 `protobuf:"varint,12,opt,name=ApiBytesReceived,def=0" json:"ApiBytesReceived,omitempty"` | ||
314 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
315 | XXX_unrecognized []byte `json:"-"` | ||
316 | XXX_sizecache int32 `json:"-"` | ||
317 | } | ||
318 | |||
319 | func (m *URLFetchResponse) Reset() { *m = URLFetchResponse{} } | ||
320 | func (m *URLFetchResponse) String() string { return proto.CompactTextString(m) } | ||
321 | func (*URLFetchResponse) ProtoMessage() {} | ||
322 | func (*URLFetchResponse) Descriptor() ([]byte, []int) { | ||
323 | return fileDescriptor_urlfetch_service_b245a7065f33bced, []int{2} | ||
324 | } | ||
325 | func (m *URLFetchResponse) XXX_Unmarshal(b []byte) error { | ||
326 | return xxx_messageInfo_URLFetchResponse.Unmarshal(m, b) | ||
327 | } | ||
328 | func (m *URLFetchResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
329 | return xxx_messageInfo_URLFetchResponse.Marshal(b, m, deterministic) | ||
330 | } | ||
331 | func (dst *URLFetchResponse) XXX_Merge(src proto.Message) { | ||
332 | xxx_messageInfo_URLFetchResponse.Merge(dst, src) | ||
333 | } | ||
334 | func (m *URLFetchResponse) XXX_Size() int { | ||
335 | return xxx_messageInfo_URLFetchResponse.Size(m) | ||
336 | } | ||
337 | func (m *URLFetchResponse) XXX_DiscardUnknown() { | ||
338 | xxx_messageInfo_URLFetchResponse.DiscardUnknown(m) | ||
339 | } | ||
340 | |||
341 | var xxx_messageInfo_URLFetchResponse proto.InternalMessageInfo | ||
342 | |||
343 | const Default_URLFetchResponse_ContentWasTruncated bool = false | ||
344 | const Default_URLFetchResponse_ApiCpuMilliseconds int64 = 0 | ||
345 | const Default_URLFetchResponse_ApiBytesSent int64 = 0 | ||
346 | const Default_URLFetchResponse_ApiBytesReceived int64 = 0 | ||
347 | |||
348 | func (m *URLFetchResponse) GetContent() []byte { | ||
349 | if m != nil { | ||
350 | return m.Content | ||
351 | } | ||
352 | return nil | ||
353 | } | ||
354 | |||
355 | func (m *URLFetchResponse) GetStatusCode() int32 { | ||
356 | if m != nil && m.StatusCode != nil { | ||
357 | return *m.StatusCode | ||
358 | } | ||
359 | return 0 | ||
360 | } | ||
361 | |||
362 | func (m *URLFetchResponse) GetHeader() []*URLFetchResponse_Header { | ||
363 | if m != nil { | ||
364 | return m.Header | ||
365 | } | ||
366 | return nil | ||
367 | } | ||
368 | |||
369 | func (m *URLFetchResponse) GetContentWasTruncated() bool { | ||
370 | if m != nil && m.ContentWasTruncated != nil { | ||
371 | return *m.ContentWasTruncated | ||
372 | } | ||
373 | return Default_URLFetchResponse_ContentWasTruncated | ||
374 | } | ||
375 | |||
376 | func (m *URLFetchResponse) GetExternalBytesSent() int64 { | ||
377 | if m != nil && m.ExternalBytesSent != nil { | ||
378 | return *m.ExternalBytesSent | ||
379 | } | ||
380 | return 0 | ||
381 | } | ||
382 | |||
383 | func (m *URLFetchResponse) GetExternalBytesReceived() int64 { | ||
384 | if m != nil && m.ExternalBytesReceived != nil { | ||
385 | return *m.ExternalBytesReceived | ||
386 | } | ||
387 | return 0 | ||
388 | } | ||
389 | |||
390 | func (m *URLFetchResponse) GetFinalUrl() string { | ||
391 | if m != nil && m.FinalUrl != nil { | ||
392 | return *m.FinalUrl | ||
393 | } | ||
394 | return "" | ||
395 | } | ||
396 | |||
397 | func (m *URLFetchResponse) GetApiCpuMilliseconds() int64 { | ||
398 | if m != nil && m.ApiCpuMilliseconds != nil { | ||
399 | return *m.ApiCpuMilliseconds | ||
400 | } | ||
401 | return Default_URLFetchResponse_ApiCpuMilliseconds | ||
402 | } | ||
403 | |||
404 | func (m *URLFetchResponse) GetApiBytesSent() int64 { | ||
405 | if m != nil && m.ApiBytesSent != nil { | ||
406 | return *m.ApiBytesSent | ||
407 | } | ||
408 | return Default_URLFetchResponse_ApiBytesSent | ||
409 | } | ||
410 | |||
411 | func (m *URLFetchResponse) GetApiBytesReceived() int64 { | ||
412 | if m != nil && m.ApiBytesReceived != nil { | ||
413 | return *m.ApiBytesReceived | ||
414 | } | ||
415 | return Default_URLFetchResponse_ApiBytesReceived | ||
416 | } | ||
417 | |||
418 | type URLFetchResponse_Header struct { | ||
419 | Key *string `protobuf:"bytes,4,req,name=Key" json:"Key,omitempty"` | ||
420 | Value *string `protobuf:"bytes,5,req,name=Value" json:"Value,omitempty"` | ||
421 | XXX_NoUnkeyedLiteral struct{} `json:"-"` | ||
422 | XXX_unrecognized []byte `json:"-"` | ||
423 | XXX_sizecache int32 `json:"-"` | ||
424 | } | ||
425 | |||
426 | func (m *URLFetchResponse_Header) Reset() { *m = URLFetchResponse_Header{} } | ||
427 | func (m *URLFetchResponse_Header) String() string { return proto.CompactTextString(m) } | ||
428 | func (*URLFetchResponse_Header) ProtoMessage() {} | ||
429 | func (*URLFetchResponse_Header) Descriptor() ([]byte, []int) { | ||
430 | return fileDescriptor_urlfetch_service_b245a7065f33bced, []int{2, 0} | ||
431 | } | ||
432 | func (m *URLFetchResponse_Header) XXX_Unmarshal(b []byte) error { | ||
433 | return xxx_messageInfo_URLFetchResponse_Header.Unmarshal(m, b) | ||
434 | } | ||
435 | func (m *URLFetchResponse_Header) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) { | ||
436 | return xxx_messageInfo_URLFetchResponse_Header.Marshal(b, m, deterministic) | ||
437 | } | ||
438 | func (dst *URLFetchResponse_Header) XXX_Merge(src proto.Message) { | ||
439 | xxx_messageInfo_URLFetchResponse_Header.Merge(dst, src) | ||
440 | } | ||
441 | func (m *URLFetchResponse_Header) XXX_Size() int { | ||
442 | return xxx_messageInfo_URLFetchResponse_Header.Size(m) | ||
443 | } | ||
444 | func (m *URLFetchResponse_Header) XXX_DiscardUnknown() { | ||
445 | xxx_messageInfo_URLFetchResponse_Header.DiscardUnknown(m) | ||
446 | } | ||
447 | |||
448 | var xxx_messageInfo_URLFetchResponse_Header proto.InternalMessageInfo | ||
449 | |||
450 | func (m *URLFetchResponse_Header) GetKey() string { | ||
451 | if m != nil && m.Key != nil { | ||
452 | return *m.Key | ||
453 | } | ||
454 | return "" | ||
455 | } | ||
456 | |||
457 | func (m *URLFetchResponse_Header) GetValue() string { | ||
458 | if m != nil && m.Value != nil { | ||
459 | return *m.Value | ||
460 | } | ||
461 | return "" | ||
462 | } | ||
463 | |||
464 | func init() { | ||
465 | proto.RegisterType((*URLFetchServiceError)(nil), "appengine.URLFetchServiceError") | ||
466 | proto.RegisterType((*URLFetchRequest)(nil), "appengine.URLFetchRequest") | ||
467 | proto.RegisterType((*URLFetchRequest_Header)(nil), "appengine.URLFetchRequest.Header") | ||
468 | proto.RegisterType((*URLFetchResponse)(nil), "appengine.URLFetchResponse") | ||
469 | proto.RegisterType((*URLFetchResponse_Header)(nil), "appengine.URLFetchResponse.Header") | ||
470 | } | ||
471 | |||
472 | func init() { | ||
473 | proto.RegisterFile("google.golang.org/appengine/internal/urlfetch/urlfetch_service.proto", fileDescriptor_urlfetch_service_b245a7065f33bced) | ||
474 | } | ||
475 | |||
476 | var fileDescriptor_urlfetch_service_b245a7065f33bced = []byte{ | ||
477 | // 770 bytes of a gzipped FileDescriptorProto | ||
478 | 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x94, 0x54, 0xdd, 0x6e, 0xe3, 0x54, | ||
479 | 0x10, 0xc6, 0x76, 0x7e, 0xa7, 0x5d, 0x7a, 0x76, 0xb6, 0x45, 0x66, 0xb5, 0xa0, 0x10, 0x09, 0x29, | ||
480 | 0x17, 0x90, 0x2e, 0x2b, 0x24, 0x44, 0xaf, 0x70, 0xed, 0x93, 0xad, 0xa9, 0x63, 0x47, 0xc7, 0x4e, | ||
481 | 0x61, 0xb9, 0xb1, 0xac, 0x78, 0x9a, 0x5a, 0xb2, 0xec, 0x60, 0x9f, 0x2c, 0xf4, 0x35, 0x78, 0x0d, | ||
482 | 0xde, 0x87, 0xa7, 0xe1, 0x02, 0x9d, 0xc4, 0xc9, 0x6e, 0xbb, 0xd1, 0x4a, 0x5c, 0x65, 0xe6, 0x9b, | ||
483 | 0xef, 0xcc, 0x99, 0x7c, 0xdf, 0xf8, 0x80, 0xb3, 0x2c, 0xcb, 0x65, 0x4e, 0xe3, 0x65, 0x99, 0x27, | ||
484 | 0xc5, 0x72, 0x5c, 0x56, 0xcb, 0xf3, 0x64, 0xb5, 0xa2, 0x62, 0x99, 0x15, 0x74, 0x9e, 0x15, 0x92, | ||
485 | 0xaa, 0x22, 0xc9, 0xcf, 0xd7, 0x55, 0x7e, 0x4b, 0x72, 0x71, 0xb7, 0x0f, 0xe2, 0x9a, 0xaa, 0xb7, | ||
486 | 0xd9, 0x82, 0xc6, 0xab, 0xaa, 0x94, 0x25, 0xf6, 0xf7, 0x67, 0x86, 0x7f, 0xeb, 0x70, 0x3a, 0x17, | ||
487 | 0xde, 0x44, 0xb1, 0xc2, 0x2d, 0x89, 0x57, 0x55, 0x59, 0x0d, 0xff, 0xd2, 0xa1, 0xbf, 0x89, 0xec, | ||
488 | 0x32, 0x25, 0xec, 0x80, 0x1e, 0x5c, 0xb3, 0x4f, 0xf0, 0x04, 0x8e, 0x5c, 0xff, 0xc6, 0xf2, 0x5c, | ||
489 | 0x27, 0x9e, 0x0b, 0x8f, 0x69, 0x0a, 0x98, 0xf0, 0xc8, 0xbe, 0x8a, 0xb9, 0x10, 0x81, 0x60, 0x3a, | ||
490 | 0x9e, 0xc1, 0xd3, 0xb9, 0x1f, 0xce, 0xb8, 0xed, 0x4e, 0x5c, 0xee, 0x34, 0xb0, 0x81, 0x9f, 0x01, | ||
491 | 0x0a, 0x1e, 0xce, 0x02, 0x3f, 0xe4, 0x71, 0x14, 0x04, 0xb1, 0x67, 0x89, 0xd7, 0x9c, 0xb5, 0x14, | ||
492 | 0xdd, 0xe1, 0x96, 0xe3, 0xb9, 0x3e, 0x8f, 0xf9, 0xaf, 0x36, 0xe7, 0x0e, 0x77, 0x58, 0x1b, 0x3f, | ||
493 | 0x87, 0xb3, 0x30, 0xf4, 0x62, 0x9b, 0x8b, 0xc8, 0x9d, 0xb8, 0xb6, 0x15, 0xf1, 0xa6, 0x53, 0x07, | ||
494 | 0x9f, 0x40, 0xdf, 0xf1, 0xc3, 0x26, 0xed, 0x22, 0x40, 0xc7, 0xf6, 0x82, 0x90, 0x3b, 0xac, 0x87, | ||
495 | 0x2f, 0xc0, 0x74, 0xfd, 0x88, 0x0b, 0xdf, 0xf2, 0xe2, 0x48, 0x58, 0x7e, 0xe8, 0x72, 0x3f, 0x6a, | ||
496 | 0x98, 0x7d, 0x35, 0x82, 0xba, 0x79, 0x6a, 0xf9, 0x6f, 0x62, 0xc1, 0x1d, 0x57, 0x70, 0x3b, 0x0a, | ||
497 | 0x19, 0xe0, 0x33, 0x38, 0x99, 0x5a, 0xde, 0x24, 0x10, 0x53, 0xee, 0xc4, 0x82, 0xcf, 0xbc, 0x37, | ||
498 | 0xec, 0x08, 0x4f, 0x81, 0xd9, 0x81, 0xef, 0x73, 0x3b, 0x72, 0x03, 0xbf, 0x69, 0x71, 0x3c, 0xfc, | ||
499 | 0xc7, 0x80, 0x93, 0x9d, 0x5a, 0x82, 0x7e, 0x5f, 0x53, 0x2d, 0xf1, 0x27, 0xe8, 0x4c, 0x49, 0xde, | ||
500 | 0x95, 0xa9, 0xa9, 0x0d, 0xf4, 0xd1, 0xa7, 0xaf, 0x46, 0xe3, 0xbd, 0xba, 0xe3, 0x47, 0xdc, 0x71, | ||
501 | 0xf3, 0xbb, 0xe5, 0x8b, 0xe6, 0x1c, 0x32, 0x30, 0xe6, 0x55, 0x6e, 0xea, 0x03, 0x7d, 0xd4, 0x17, | ||
502 | 0x2a, 0xc4, 0x1f, 0xa1, 0x73, 0x47, 0x49, 0x4a, 0x95, 0x69, 0x0c, 0x8c, 0x11, 0xbc, 0xfa, 0xea, | ||
503 | 0x23, 0x3d, 0xaf, 0x36, 0x44, 0xd1, 0x1c, 0xc0, 0x17, 0xd0, 0x9d, 0x25, 0xf7, 0x79, 0x99, 0xa4, | ||
504 | 0x66, 0x67, 0xa0, 0x8d, 0x8e, 0x2f, 0xf5, 0x9e, 0x26, 0x76, 0x10, 0x8e, 0xe1, 0x64, 0x52, 0xe6, | ||
505 | 0x79, 0xf9, 0x87, 0xa0, 0x34, 0xab, 0x68, 0x21, 0x6b, 0xb3, 0x3b, 0xd0, 0x46, 0xbd, 0x8b, 0x96, | ||
506 | 0xac, 0xd6, 0x24, 0x1e, 0x17, 0xf1, 0x39, 0xf4, 0x1c, 0x4a, 0xd2, 0x3c, 0x2b, 0xc8, 0xec, 0x0d, | ||
507 | 0xb4, 0x91, 0x26, 0xf6, 0x39, 0xfe, 0x0c, 0x5f, 0x4c, 0xd7, 0xb5, 0xbc, 0x49, 0xf2, 0x2c, 0x4d, | ||
508 | 0x24, 0xa9, 0xed, 0xa1, 0xca, 0xa6, 0x4a, 0x66, 0xb7, 0xd9, 0x22, 0x91, 0x64, 0xf6, 0xdf, 0xeb, | ||
509 | 0xfc, 0x71, 0xea, 0xf3, 0x97, 0xd0, 0xd9, 0xfe, 0x0f, 0x25, 0xc6, 0x35, 0xdd, 0x9b, 0xad, 0xad, | ||
510 | 0x18, 0xd7, 0x74, 0x8f, 0xa7, 0xd0, 0xbe, 0x49, 0xf2, 0x35, 0x99, 0xed, 0x0d, 0xb6, 0x4d, 0x86, | ||
511 | 0x1e, 0x3c, 0x79, 0xa0, 0x26, 0x76, 0xc1, 0x78, 0xcd, 0x23, 0xa6, 0x61, 0x0f, 0x5a, 0xb3, 0x20, | ||
512 | 0x8c, 0x98, 0xae, 0xa2, 0x2b, 0x6e, 0x39, 0xcc, 0x50, 0xc5, 0xd9, 0x3c, 0x62, 0x2d, 0xb5, 0x2e, | ||
513 | 0x0e, 0xf7, 0x78, 0xc4, 0x59, 0x1b, 0xfb, 0xd0, 0x9e, 0x59, 0x91, 0x7d, 0xc5, 0x3a, 0xc3, 0x7f, | ||
514 | 0x0d, 0x60, 0xef, 0x84, 0xad, 0x57, 0x65, 0x51, 0x13, 0x9a, 0xd0, 0xb5, 0xcb, 0x42, 0x52, 0x21, | ||
515 | 0x4d, 0x4d, 0x49, 0x29, 0x76, 0x29, 0x7e, 0x09, 0x10, 0xca, 0x44, 0xae, 0x6b, 0xf5, 0x71, 0x6c, | ||
516 | 0x8c, 0x6b, 0x8b, 0xf7, 0x10, 0xbc, 0x78, 0xe4, 0xdf, 0xf0, 0xa0, 0x7f, 0xdb, 0x6b, 0x1e, 0x1b, | ||
517 | 0xf8, 0x03, 0x3c, 0x6b, 0xae, 0xf9, 0x25, 0xa9, 0xa3, 0x6a, 0x5d, 0x28, 0x81, 0xb6, 0x66, 0xf6, | ||
518 | 0x2e, 0xda, 0xb7, 0x49, 0x5e, 0x93, 0x38, 0xc4, 0xc0, 0x6f, 0xe0, 0x29, 0xff, 0x73, 0xfb, 0x02, | ||
519 | 0x5c, 0xde, 0x4b, 0xaa, 0x43, 0x35, 0xb8, 0x72, 0xd7, 0x10, 0x1f, 0x16, 0xf0, 0x7b, 0x38, 0x7b, | ||
520 | 0x00, 0x0a, 0x5a, 0x50, 0xf6, 0x96, 0xd2, 0x8d, 0xcd, 0x86, 0x38, 0x5c, 0x54, 0xfb, 0x30, 0xc9, | ||
521 | 0x8a, 0x24, 0x57, 0xfb, 0xaa, 0xec, 0xed, 0x8b, 0x7d, 0x8e, 0xdf, 0x01, 0x5a, 0xab, 0xcc, 0x5e, | ||
522 | 0xad, 0xa7, 0x59, 0x9e, 0x67, 0x35, 0x2d, 0xca, 0x22, 0xad, 0x4d, 0x50, 0xed, 0x2e, 0xb4, 0x97, | ||
523 | 0xe2, 0x40, 0x11, 0xbf, 0x86, 0x63, 0x6b, 0x95, 0xbd, 0x9b, 0xf6, 0x68, 0x47, 0x7e, 0x00, 0xe3, | ||
524 | 0xb7, 0xc0, 0x76, 0xf9, 0x7e, 0xcc, 0xe3, 0x1d, 0xf5, 0x83, 0xd2, 0xff, 0x5f, 0xa6, 0x4b, 0xf8, | ||
525 | 0xad, 0xb7, 0x7b, 0x2a, 0xff, 0x0b, 0x00, 0x00, 0xff, 0xff, 0x1d, 0x9f, 0x6d, 0x24, 0x63, 0x05, | ||
526 | 0x00, 0x00, | ||
527 | } | ||
diff --git a/vendor/google.golang.org/appengine/internal/urlfetch/urlfetch_service.proto b/vendor/google.golang.org/appengine/internal/urlfetch/urlfetch_service.proto new file mode 100644 index 0000000..f695edf --- /dev/null +++ b/vendor/google.golang.org/appengine/internal/urlfetch/urlfetch_service.proto | |||
@@ -0,0 +1,64 @@ | |||
1 | syntax = "proto2"; | ||
2 | option go_package = "urlfetch"; | ||
3 | |||
4 | package appengine; | ||
5 | |||
6 | message URLFetchServiceError { | ||
7 | enum ErrorCode { | ||
8 | OK = 0; | ||
9 | INVALID_URL = 1; | ||
10 | FETCH_ERROR = 2; | ||
11 | UNSPECIFIED_ERROR = 3; | ||
12 | RESPONSE_TOO_LARGE = 4; | ||
13 | DEADLINE_EXCEEDED = 5; | ||
14 | SSL_CERTIFICATE_ERROR = 6; | ||
15 | DNS_ERROR = 7; | ||
16 | CLOSED = 8; | ||
17 | INTERNAL_TRANSIENT_ERROR = 9; | ||
18 | TOO_MANY_REDIRECTS = 10; | ||
19 | MALFORMED_REPLY = 11; | ||
20 | CONNECTION_ERROR = 12; | ||
21 | } | ||
22 | } | ||
23 | |||
24 | message URLFetchRequest { | ||
25 | enum RequestMethod { | ||
26 | GET = 1; | ||
27 | POST = 2; | ||
28 | HEAD = 3; | ||
29 | PUT = 4; | ||
30 | DELETE = 5; | ||
31 | PATCH = 6; | ||
32 | } | ||
33 | required RequestMethod Method = 1; | ||
34 | required string Url = 2; | ||
35 | repeated group Header = 3 { | ||
36 | required string Key = 4; | ||
37 | required string Value = 5; | ||
38 | } | ||
39 | optional bytes Payload = 6 [ctype=CORD]; | ||
40 | |||
41 | optional bool FollowRedirects = 7 [default=true]; | ||
42 | |||
43 | optional double Deadline = 8; | ||
44 | |||
45 | optional bool MustValidateServerCertificate = 9 [default=true]; | ||
46 | } | ||
47 | |||
48 | message URLFetchResponse { | ||
49 | optional bytes Content = 1; | ||
50 | required int32 StatusCode = 2; | ||
51 | repeated group Header = 3 { | ||
52 | required string Key = 4; | ||
53 | required string Value = 5; | ||
54 | } | ||
55 | optional bool ContentWasTruncated = 6 [default=false]; | ||
56 | optional int64 ExternalBytesSent = 7; | ||
57 | optional int64 ExternalBytesReceived = 8; | ||
58 | |||
59 | optional string FinalUrl = 9; | ||
60 | |||
61 | optional int64 ApiCpuMilliseconds = 10 [default=0]; | ||
62 | optional int64 ApiBytesSent = 11 [default=0]; | ||
63 | optional int64 ApiBytesReceived = 12 [default=0]; | ||
64 | } | ||