#!/usr/bin/env python # # Copyright 2007 Google Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. # from google.net.proto import ProtocolBuffer import array import dummy_thread as thread __pychecker__ = """maxreturns=0 maxbranches=0 no-callinit unusednames=printElemNumber,debug_strs no-special""" if hasattr(ProtocolBuffer, 'ExtendableProtocolMessage'): _extension_runtime = True _ExtendableProtocolMessage = ProtocolBuffer.ExtendableProtocolMessage else: _extension_runtime = False _ExtendableProtocolMessage = ProtocolBuffer.ProtocolMessage class SystemServiceError(ProtocolBuffer.ProtocolMessage): OK = 0 INTERNAL_ERROR = 1 BACKEND_REQUIRED = 2 LIMIT_REACHED = 3 _ErrorCode_NAMES = { 0: "OK", 1: "INTERNAL_ERROR", 2: "BACKEND_REQUIRED", 3: "LIMIT_REACHED", } def ErrorCode_Name(cls, x): return cls._ErrorCode_NAMES.get(x, "") ErrorCode_Name = classmethod(ErrorCode_Name) def __init__(self, contents=None): pass if contents is not None: self.MergeFromString(contents) def MergeFrom(self, x): assert x is not self def Equals(self, x): if x is self: return 1 return 1 def IsInitialized(self, debug_strs=None): initialized = 1 return initialized def ByteSize(self): n = 0 return n def ByteSizePartial(self): n = 0 return n def Clear(self): pass def OutputUnchecked(self, out): pass def OutputPartial(self, out): pass def TryMerge(self, d): while d.avail() > 0: tt = d.getVarInt32() if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError d.skipData(tt) def __str__(self, prefix="", printElemNumber=0): res="" return res def _BuildTagLookupTable(sparse, maxtag, default=None): return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)]) _TEXT = _BuildTagLookupTable({ 0: "ErrorCode", }, 0) _TYPES = _BuildTagLookupTable({ 0: ProtocolBuffer.Encoder.NUMERIC, }, 0, ProtocolBuffer.Encoder.MAX_TYPE) _STYLE = """""" _STYLE_CONTENT_TYPE = """""" _PROTO_DESCRIPTOR_NAME = 'apphosting.SystemServiceError' class SystemStat(ProtocolBuffer.ProtocolMessage): has_current_ = 0 current_ = 0.0 has_average1m_ = 0 average1m_ = 0.0 has_average10m_ = 0 average10m_ = 0.0 has_total_ = 0 total_ = 0.0 has_rate1m_ = 0 rate1m_ = 0.0 has_rate10m_ = 0 rate10m_ = 0.0 def __init__(self, contents=None): if contents is not None: self.MergeFromString(contents) def current(self): return self.current_ def set_current(self, x): self.has_current_ = 1 self.current_ = x def clear_current(self): if self.has_current_: self.has_current_ = 0 self.current_ = 0.0 def has_current(self): return self.has_current_ def average1m(self): return self.average1m_ def set_average1m(self, x): self.has_average1m_ = 1 self.average1m_ = x def clear_average1m(self): if self.has_average1m_: self.has_average1m_ = 0 self.average1m_ = 0.0 def has_average1m(self): return self.has_average1m_ def average10m(self): return self.average10m_ def set_average10m(self, x): self.has_average10m_ = 1 self.average10m_ = x def clear_average10m(self): if self.has_average10m_: self.has_average10m_ = 0 self.average10m_ = 0.0 def has_average10m(self): return self.has_average10m_ def total(self): return self.total_ def set_total(self, x): self.has_total_ = 1 self.total_ = x def clear_total(self): if self.has_total_: self.has_total_ = 0 self.total_ = 0.0 def has_total(self): return self.has_total_ def rate1m(self): return self.rate1m_ def set_rate1m(self, x): self.has_rate1m_ = 1 self.rate1m_ = x def clear_rate1m(self): if self.has_rate1m_: self.has_rate1m_ = 0 self.rate1m_ = 0.0 def has_rate1m(self): return self.has_rate1m_ def rate10m(self): return self.rate10m_ def set_rate10m(self, x): self.has_rate10m_ = 1 self.rate10m_ = x def clear_rate10m(self): if self.has_rate10m_: self.has_rate10m_ = 0 self.rate10m_ = 0.0 def has_rate10m(self): return self.has_rate10m_ def MergeFrom(self, x): assert x is not self if (x.has_current()): self.set_current(x.current()) if (x.has_average1m()): self.set_average1m(x.average1m()) if (x.has_average10m()): self.set_average10m(x.average10m()) if (x.has_total()): self.set_total(x.total()) if (x.has_rate1m()): self.set_rate1m(x.rate1m()) if (x.has_rate10m()): self.set_rate10m(x.rate10m()) def Equals(self, x): if x is self: return 1 if self.has_current_ != x.has_current_: return 0 if self.has_current_ and self.current_ != x.current_: return 0 if self.has_average1m_ != x.has_average1m_: return 0 if self.has_average1m_ and self.average1m_ != x.average1m_: return 0 if self.has_average10m_ != x.has_average10m_: return 0 if self.has_average10m_ and self.average10m_ != x.average10m_: return 0 if self.has_total_ != x.has_total_: return 0 if self.has_total_ and self.total_ != x.total_: return 0 if self.has_rate1m_ != x.has_rate1m_: return 0 if self.has_rate1m_ and self.rate1m_ != x.rate1m_: return 0 if self.has_rate10m_ != x.has_rate10m_: return 0 if self.has_rate10m_ and self.rate10m_ != x.rate10m_: return 0 return 1 def IsInitialized(self, debug_strs=None): initialized = 1 return initialized def ByteSize(self): n = 0 if (self.has_current_): n += 9 if (self.has_average1m_): n += 9 if (self.has_average10m_): n += 9 if (self.has_total_): n += 9 if (self.has_rate1m_): n += 9 if (self.has_rate10m_): n += 9 return n def ByteSizePartial(self): n = 0 if (self.has_current_): n += 9 if (self.has_average1m_): n += 9 if (self.has_average10m_): n += 9 if (self.has_total_): n += 9 if (self.has_rate1m_): n += 9 if (self.has_rate10m_): n += 9 return n def Clear(self): self.clear_current() self.clear_average1m() self.clear_average10m() self.clear_total() self.clear_rate1m() self.clear_rate10m() def OutputUnchecked(self, out): if (self.has_current_): out.putVarInt32(9) out.putDouble(self.current_) if (self.has_total_): out.putVarInt32(17) out.putDouble(self.total_) if (self.has_average1m_): out.putVarInt32(25) out.putDouble(self.average1m_) if (self.has_average10m_): out.putVarInt32(33) out.putDouble(self.average10m_) if (self.has_rate1m_): out.putVarInt32(41) out.putDouble(self.rate1m_) if (self.has_rate10m_): out.putVarInt32(49) out.putDouble(self.rate10m_) def OutputPartial(self, out): if (self.has_current_): out.putVarInt32(9) out.putDouble(self.current_) if (self.has_total_): out.putVarInt32(17) out.putDouble(self.total_) if (self.has_average1m_): out.putVarInt32(25) out.putDouble(self.average1m_) if (self.has_average10m_): out.putVarInt32(33) out.putDouble(self.average10m_) if (self.has_rate1m_): out.putVarInt32(41) out.putDouble(self.rate1m_) if (self.has_rate10m_): out.putVarInt32(49) out.putDouble(self.rate10m_) def TryMerge(self, d): while d.avail() > 0: tt = d.getVarInt32() if tt == 9: self.set_current(d.getDouble()) continue if tt == 17: self.set_total(d.getDouble()) continue if tt == 25: self.set_average1m(d.getDouble()) continue if tt == 33: self.set_average10m(d.getDouble()) continue if tt == 41: self.set_rate1m(d.getDouble()) continue if tt == 49: self.set_rate10m(d.getDouble()) continue if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError d.skipData(tt) def __str__(self, prefix="", printElemNumber=0): res="" if self.has_current_: res+=prefix+("current: %s\n" % self.DebugFormat(self.current_)) if self.has_average1m_: res+=prefix+("average1m: %s\n" % self.DebugFormat(self.average1m_)) if self.has_average10m_: res+=prefix+("average10m: %s\n" % self.DebugFormat(self.average10m_)) if self.has_total_: res+=prefix+("total: %s\n" % self.DebugFormat(self.total_)) if self.has_rate1m_: res+=prefix+("rate1m: %s\n" % self.DebugFormat(self.rate1m_)) if self.has_rate10m_: res+=prefix+("rate10m: %s\n" % self.DebugFormat(self.rate10m_)) return res def _BuildTagLookupTable(sparse, maxtag, default=None): return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)]) kcurrent = 1 kaverage1m = 3 kaverage10m = 4 ktotal = 2 krate1m = 5 krate10m = 6 _TEXT = _BuildTagLookupTable({ 0: "ErrorCode", 1: "current", 2: "total", 3: "average1m", 4: "average10m", 5: "rate1m", 6: "rate10m", }, 6) _TYPES = _BuildTagLookupTable({ 0: ProtocolBuffer.Encoder.NUMERIC, 1: ProtocolBuffer.Encoder.DOUBLE, 2: ProtocolBuffer.Encoder.DOUBLE, 3: ProtocolBuffer.Encoder.DOUBLE, 4: ProtocolBuffer.Encoder.DOUBLE, 5: ProtocolBuffer.Encoder.DOUBLE, 6: ProtocolBuffer.Encoder.DOUBLE, }, 6, ProtocolBuffer.Encoder.MAX_TYPE) _STYLE = """""" _STYLE_CONTENT_TYPE = """""" _PROTO_DESCRIPTOR_NAME = 'apphosting.SystemStat' class GetSystemStatsRequest(ProtocolBuffer.ProtocolMessage): def __init__(self, contents=None): pass if contents is not None: self.MergeFromString(contents) def MergeFrom(self, x): assert x is not self def Equals(self, x): if x is self: return 1 return 1 def IsInitialized(self, debug_strs=None): initialized = 1 return initialized def ByteSize(self): n = 0 return n def ByteSizePartial(self): n = 0 return n def Clear(self): pass def OutputUnchecked(self, out): pass def OutputPartial(self, out): pass def TryMerge(self, d): while d.avail() > 0: tt = d.getVarInt32() if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError d.skipData(tt) def __str__(self, prefix="", printElemNumber=0): res="" return res def _BuildTagLookupTable(sparse, maxtag, default=None): return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)]) _TEXT = _BuildTagLookupTable({ 0: "ErrorCode", }, 0) _TYPES = _BuildTagLookupTable({ 0: ProtocolBuffer.Encoder.NUMERIC, }, 0, ProtocolBuffer.Encoder.MAX_TYPE) _STYLE = """""" _STYLE_CONTENT_TYPE = """""" _PROTO_DESCRIPTOR_NAME = 'apphosting.GetSystemStatsRequest' class GetSystemStatsResponse(ProtocolBuffer.ProtocolMessage): has_cpu_ = 0 cpu_ = None has_memory_ = 0 memory_ = None def __init__(self, contents=None): self.lazy_init_lock_ = thread.allocate_lock() if contents is not None: self.MergeFromString(contents) def cpu(self): if self.cpu_ is None: self.lazy_init_lock_.acquire() try: if self.cpu_ is None: self.cpu_ = SystemStat() finally: self.lazy_init_lock_.release() return self.cpu_ def mutable_cpu(self): self.has_cpu_ = 1; return self.cpu() def clear_cpu(self): if self.has_cpu_: self.has_cpu_ = 0; if self.cpu_ is not None: self.cpu_.Clear() def has_cpu(self): return self.has_cpu_ def memory(self): if self.memory_ is None: self.lazy_init_lock_.acquire() try: if self.memory_ is None: self.memory_ = SystemStat() finally: self.lazy_init_lock_.release() return self.memory_ def mutable_memory(self): self.has_memory_ = 1; return self.memory() def clear_memory(self): if self.has_memory_: self.has_memory_ = 0; if self.memory_ is not None: self.memory_.Clear() def has_memory(self): return self.has_memory_ def MergeFrom(self, x): assert x is not self if (x.has_cpu()): self.mutable_cpu().MergeFrom(x.cpu()) if (x.has_memory()): self.mutable_memory().MergeFrom(x.memory()) def Equals(self, x): if x is self: return 1 if self.has_cpu_ != x.has_cpu_: return 0 if self.has_cpu_ and self.cpu_ != x.cpu_: return 0 if self.has_memory_ != x.has_memory_: return 0 if self.has_memory_ and self.memory_ != x.memory_: return 0 return 1 def IsInitialized(self, debug_strs=None): initialized = 1 if (self.has_cpu_ and not self.cpu_.IsInitialized(debug_strs)): initialized = 0 if (self.has_memory_ and not self.memory_.IsInitialized(debug_strs)): initialized = 0 return initialized def ByteSize(self): n = 0 if (self.has_cpu_): n += 1 + self.lengthString(self.cpu_.ByteSize()) if (self.has_memory_): n += 1 + self.lengthString(self.memory_.ByteSize()) return n def ByteSizePartial(self): n = 0 if (self.has_cpu_): n += 1 + self.lengthString(self.cpu_.ByteSizePartial()) if (self.has_memory_): n += 1 + self.lengthString(self.memory_.ByteSizePartial()) return n def Clear(self): self.clear_cpu() self.clear_memory() def OutputUnchecked(self, out): if (self.has_cpu_): out.putVarInt32(10) out.putVarInt32(self.cpu_.ByteSize()) self.cpu_.OutputUnchecked(out) if (self.has_memory_): out.putVarInt32(18) out.putVarInt32(self.memory_.ByteSize()) self.memory_.OutputUnchecked(out) def OutputPartial(self, out): if (self.has_cpu_): out.putVarInt32(10) out.putVarInt32(self.cpu_.ByteSizePartial()) self.cpu_.OutputPartial(out) if (self.has_memory_): out.putVarInt32(18) out.putVarInt32(self.memory_.ByteSizePartial()) self.memory_.OutputPartial(out) def TryMerge(self, d): while d.avail() > 0: tt = d.getVarInt32() if tt == 10: length = d.getVarInt32() tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length) d.skip(length) self.mutable_cpu().TryMerge(tmp) continue if tt == 18: length = d.getVarInt32() tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length) d.skip(length) self.mutable_memory().TryMerge(tmp) continue if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError d.skipData(tt) def __str__(self, prefix="", printElemNumber=0): res="" if self.has_cpu_: res+=prefix+"cpu <\n" res+=self.cpu_.__str__(prefix + " ", printElemNumber) res+=prefix+">\n" if self.has_memory_: res+=prefix+"memory <\n" res+=self.memory_.__str__(prefix + " ", printElemNumber) res+=prefix+">\n" return res def _BuildTagLookupTable(sparse, maxtag, default=None): return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)]) kcpu = 1 kmemory = 2 _TEXT = _BuildTagLookupTable({ 0: "ErrorCode", 1: "cpu", 2: "memory", }, 2) _TYPES = _BuildTagLookupTable({ 0: ProtocolBuffer.Encoder.NUMERIC, 1: ProtocolBuffer.Encoder.STRING, 2: ProtocolBuffer.Encoder.STRING, }, 2, ProtocolBuffer.Encoder.MAX_TYPE) _STYLE = """""" _STYLE_CONTENT_TYPE = """""" _PROTO_DESCRIPTOR_NAME = 'apphosting.GetSystemStatsResponse' class StartBackgroundRequestRequest(ProtocolBuffer.ProtocolMessage): def __init__(self, contents=None): pass if contents is not None: self.MergeFromString(contents) def MergeFrom(self, x): assert x is not self def Equals(self, x): if x is self: return 1 return 1 def IsInitialized(self, debug_strs=None): initialized = 1 return initialized def ByteSize(self): n = 0 return n def ByteSizePartial(self): n = 0 return n def Clear(self): pass def OutputUnchecked(self, out): pass def OutputPartial(self, out): pass def TryMerge(self, d): while d.avail() > 0: tt = d.getVarInt32() if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError d.skipData(tt) def __str__(self, prefix="", printElemNumber=0): res="" return res def _BuildTagLookupTable(sparse, maxtag, default=None): return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)]) _TEXT = _BuildTagLookupTable({ 0: "ErrorCode", }, 0) _TYPES = _BuildTagLookupTable({ 0: ProtocolBuffer.Encoder.NUMERIC, }, 0, ProtocolBuffer.Encoder.MAX_TYPE) _STYLE = """""" _STYLE_CONTENT_TYPE = """""" _PROTO_DESCRIPTOR_NAME = 'apphosting.StartBackgroundRequestRequest' class StartBackgroundRequestResponse(ProtocolBuffer.ProtocolMessage): has_request_id_ = 0 request_id_ = "" def __init__(self, contents=None): if contents is not None: self.MergeFromString(contents) def request_id(self): return self.request_id_ def set_request_id(self, x): self.has_request_id_ = 1 self.request_id_ = x def clear_request_id(self): if self.has_request_id_: self.has_request_id_ = 0 self.request_id_ = "" def has_request_id(self): return self.has_request_id_ def MergeFrom(self, x): assert x is not self if (x.has_request_id()): self.set_request_id(x.request_id()) def Equals(self, x): if x is self: return 1 if self.has_request_id_ != x.has_request_id_: return 0 if self.has_request_id_ and self.request_id_ != x.request_id_: return 0 return 1 def IsInitialized(self, debug_strs=None): initialized = 1 return initialized def ByteSize(self): n = 0 if (self.has_request_id_): n += 1 + self.lengthString(len(self.request_id_)) return n def ByteSizePartial(self): n = 0 if (self.has_request_id_): n += 1 + self.lengthString(len(self.request_id_)) return n def Clear(self): self.clear_request_id() def OutputUnchecked(self, out): if (self.has_request_id_): out.putVarInt32(10) out.putPrefixedString(self.request_id_) def OutputPartial(self, out): if (self.has_request_id_): out.putVarInt32(10) out.putPrefixedString(self.request_id_) def TryMerge(self, d): while d.avail() > 0: tt = d.getVarInt32() if tt == 10: self.set_request_id(d.getPrefixedString()) continue if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError d.skipData(tt) def __str__(self, prefix="", printElemNumber=0): res="" if self.has_request_id_: res+=prefix+("request_id: %s\n" % self.DebugFormatString(self.request_id_)) return res def _BuildTagLookupTable(sparse, maxtag, default=None): return tuple([sparse.get(i, default) for i in xrange(0, 1+maxtag)]) krequest_id = 1 _TEXT = _BuildTagLookupTable({ 0: "ErrorCode", 1: "request_id", }, 1) _TYPES = _BuildTagLookupTable({ 0: ProtocolBuffer.Encoder.NUMERIC, 1: ProtocolBuffer.Encoder.STRING, }, 1, ProtocolBuffer.Encoder.MAX_TYPE) _STYLE = """""" _STYLE_CONTENT_TYPE = """""" _PROTO_DESCRIPTOR_NAME = 'apphosting.StartBackgroundRequestResponse' if _extension_runtime: pass __all__ = ['SystemServiceError','SystemStat','GetSystemStatsRequest','GetSystemStatsResponse','StartBackgroundRequestRequest','StartBackgroundRequestResponse']