1 #!/usr/bin/env python

     2 #

     3 # Copyright 2007 Google Inc.

     4 #

     5 # Licensed under the Apache License, Version 2.0 (the "License");

     6 # you may not use this file except in compliance with the License.

     7 # You may obtain a copy of the License at

     8 #

     9 #     http://www.apache.org/licenses/LICENSE-2.0

    10 #

    11 # Unless required by applicable law or agreed to in writing, software

    12 # distributed under the License is distributed on an "AS IS" BASIS,

    13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

    14 # See the License for the specific language governing permissions and

    15 # limitations under the License.

    16 #

    17 

    18 from google.net.proto import ProtocolBuffer

    19 import array

    20 import dummy_thread as thread

    21 

    22 __pychecker__ = """maxreturns=0 maxbranches=0 no-callinit

    23                    unusednames=printElemNumber,debug_strs no-special"""

    24 

    25 class TaskQueueServiceError(ProtocolBuffer.ProtocolMessage):

    26 

    27   OK           =    0

    28   UNKNOWN_QUEUE =    1

    29   TRANSIENT_ERROR =    2

    30   INTERNAL_ERROR =    3

    31   TASK_TOO_LARGE =    4

    32   INVALID_TASK_NAME =    5

    33   INVALID_QUEUE_NAME =    6

    34   INVALID_URL  =    7

    35   INVALID_QUEUE_RATE =    8

    36   PERMISSION_DENIED =    9

    37   TASK_ALREADY_EXISTS =   10

    38   TOMBSTONED_TASK =   11

    39   INVALID_ETA  =   12

    40 

    41   _ErrorCode_NAMES = {

    42     0: "OK",

    43     1: "UNKNOWN_QUEUE",

    44     2: "TRANSIENT_ERROR",

    45     3: "INTERNAL_ERROR",

    46     4: "TASK_TOO_LARGE",

    47     5: "INVALID_TASK_NAME",

    48     6: "INVALID_QUEUE_NAME",

    49     7: "INVALID_URL",

    50     8: "INVALID_QUEUE_RATE",

    51     9: "PERMISSION_DENIED",

    52     10: "TASK_ALREADY_EXISTS",

    53     11: "TOMBSTONED_TASK",

    54     12: "INVALID_ETA",

    55   }

    56 

    57   def ErrorCode_Name(cls, x): return cls._ErrorCode_NAMES.get(x, "")

    58   ErrorCode_Name = classmethod(ErrorCode_Name)

    59 

    60 

    61   def __init__(self, contents=None):

    62     pass

    63     if contents is not None: self.MergeFromString(contents)

    64 

    65 

    66   def MergeFrom(self, x):

    67     assert x is not self

    68 

    69   def Equals(self, x):

    70     if x is self: return 1

    71     return 1

    72 

    73   def IsInitialized(self, debug_strs=None):

    74     initialized = 1

    75     return initialized

    76 

    77   def ByteSize(self):

    78     n = 0

    79     return n + 0

    80 

    81   def Clear(self):

    82     pass

    83 

    84   def OutputUnchecked(self, out):

    85     pass

    86 

    87   def TryMerge(self, d):

    88     while d.avail() > 0:

    89       tt = d.getVarInt32()

    90       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError

    91       d.skipData(tt)

    92 

    93 

    94   def __str__(self, prefix="", printElemNumber=0):

    95     res=""

    96     return res

    97 

    98 

    99   _TEXT = (

   100    "ErrorCode",

   101   )

   102 

   103   _TYPES = (

   104    ProtocolBuffer.Encoder.NUMERIC,

   105   )

   106 

   107   _STYLE = """"""

   108   _STYLE_CONTENT_TYPE = """"""

   109 class TaskQueueAddRequest_Header(ProtocolBuffer.ProtocolMessage):

   110   has_key_ = 0

   111   key_ = ""

   112   has_value_ = 0

   113   value_ = ""

   114 

   115   def __init__(self, contents=None):

   116     if contents is not None: self.MergeFromString(contents)

   117 

   118   def key(self): return self.key_

   119 

   120   def set_key(self, x):

   121     self.has_key_ = 1

   122     self.key_ = x

   123 

   124   def clear_key(self):

   125     if self.has_key_:

   126       self.has_key_ = 0

   127       self.key_ = ""

   128 

   129   def has_key(self): return self.has_key_

   130 

   131   def value(self): return self.value_

   132 

   133   def set_value(self, x):

   134     self.has_value_ = 1

   135     self.value_ = x

   136 

   137   def clear_value(self):

   138     if self.has_value_:

   139       self.has_value_ = 0

   140       self.value_ = ""

   141 

   142   def has_value(self): return self.has_value_

   143 

   144 

   145   def MergeFrom(self, x):

   146     assert x is not self

   147     if (x.has_key()): self.set_key(x.key())

   148     if (x.has_value()): self.set_value(x.value())

   149 

   150   def Equals(self, x):

   151     if x is self: return 1

   152     if self.has_key_ != x.has_key_: return 0

   153     if self.has_key_ and self.key_ != x.key_: return 0

   154     if self.has_value_ != x.has_value_: return 0

   155     if self.has_value_ and self.value_ != x.value_: return 0

   156     return 1

   157 

   158   def IsInitialized(self, debug_strs=None):

   159     initialized = 1

   160     if (not self.has_key_):

   161       initialized = 0

   162       if debug_strs is not None:

   163         debug_strs.append('Required field: key not set.')

   164     if (not self.has_value_):

   165       initialized = 0

   166       if debug_strs is not None:

   167         debug_strs.append('Required field: value not set.')

   168     return initialized

   169 

   170   def ByteSize(self):

   171     n = 0

   172     n += self.lengthString(len(self.key_))

   173     n += self.lengthString(len(self.value_))

   174     return n + 2

   175 

   176   def Clear(self):

   177     self.clear_key()

   178     self.clear_value()

   179 

   180   def OutputUnchecked(self, out):

   181     out.putVarInt32(58)

   182     out.putPrefixedString(self.key_)

   183     out.putVarInt32(66)

   184     out.putPrefixedString(self.value_)

   185 

   186   def TryMerge(self, d):

   187     while 1:

   188       tt = d.getVarInt32()

   189       if tt == 52: break

   190       if tt == 58:

   191         self.set_key(d.getPrefixedString())

   192         continue

   193       if tt == 66:

   194         self.set_value(d.getPrefixedString())

   195         continue

   196       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError

   197       d.skipData(tt)

   198 

   199 

   200   def __str__(self, prefix="", printElemNumber=0):

   201     res=""

   202     if self.has_key_: res+=prefix+("key: %s\n" % self.DebugFormatString(self.key_))

   203     if self.has_value_: res+=prefix+("value: %s\n" % self.DebugFormatString(self.value_))

   204     return res

   205 

   206 class TaskQueueAddRequest(ProtocolBuffer.ProtocolMessage):

   207 

   208   GET          =    1

   209   POST         =    2

   210   HEAD         =    3

   211   PUT          =    4

   212   DELETE       =    5

   213 

   214   _RequestMethod_NAMES = {

   215     1: "GET",

   216     2: "POST",

   217     3: "HEAD",

   218     4: "PUT",

   219     5: "DELETE",

   220   }

   221 

   222   def RequestMethod_Name(cls, x): return cls._RequestMethod_NAMES.get(x, "")

   223   RequestMethod_Name = classmethod(RequestMethod_Name)

   224 

   225   has_queue_name_ = 0

   226   queue_name_ = ""

   227   has_task_name_ = 0

   228   task_name_ = ""

   229   has_eta_usec_ = 0

   230   eta_usec_ = 0

   231   has_method_ = 0

   232   method_ = 2

   233   has_url_ = 0

   234   url_ = ""

   235   has_body_ = 0

   236   body_ = ""

   237 

   238   def __init__(self, contents=None):

   239     self.header_ = []

   240     if contents is not None: self.MergeFromString(contents)

   241 

   242   def queue_name(self): return self.queue_name_

   243 

   244   def set_queue_name(self, x):

   245     self.has_queue_name_ = 1

   246     self.queue_name_ = x

   247 

   248   def clear_queue_name(self):

   249     if self.has_queue_name_:

   250       self.has_queue_name_ = 0

   251       self.queue_name_ = ""

   252 

   253   def has_queue_name(self): return self.has_queue_name_

   254 

   255   def task_name(self): return self.task_name_

   256 

   257   def set_task_name(self, x):

   258     self.has_task_name_ = 1

   259     self.task_name_ = x

   260 

   261   def clear_task_name(self):

   262     if self.has_task_name_:

   263       self.has_task_name_ = 0

   264       self.task_name_ = ""

   265 

   266   def has_task_name(self): return self.has_task_name_

   267 

   268   def eta_usec(self): return self.eta_usec_

   269 

   270   def set_eta_usec(self, x):

   271     self.has_eta_usec_ = 1

   272     self.eta_usec_ = x

   273 

   274   def clear_eta_usec(self):

   275     if self.has_eta_usec_:

   276       self.has_eta_usec_ = 0

   277       self.eta_usec_ = 0

   278 

   279   def has_eta_usec(self): return self.has_eta_usec_

   280 

   281   def method(self): return self.method_

   282 

   283   def set_method(self, x):

   284     self.has_method_ = 1

   285     self.method_ = x

   286 

   287   def clear_method(self):

   288     if self.has_method_:

   289       self.has_method_ = 0

   290       self.method_ = 2

   291 

   292   def has_method(self): return self.has_method_

   293 

   294   def url(self): return self.url_

   295 

   296   def set_url(self, x):

   297     self.has_url_ = 1

   298     self.url_ = x

   299 

   300   def clear_url(self):

   301     if self.has_url_:

   302       self.has_url_ = 0

   303       self.url_ = ""

   304 

   305   def has_url(self): return self.has_url_

   306 

   307   def header_size(self): return len(self.header_)

   308   def header_list(self): return self.header_

   309 

   310   def header(self, i):

   311     return self.header_[i]

   312 

   313   def mutable_header(self, i):

   314     return self.header_[i]

   315 

   316   def add_header(self):

   317     x = TaskQueueAddRequest_Header()

   318     self.header_.append(x)

   319     return x

   320 

   321   def clear_header(self):

   322     self.header_ = []

   323   def body(self): return self.body_

   324 

   325   def set_body(self, x):

   326     self.has_body_ = 1

   327     self.body_ = x

   328 

   329   def clear_body(self):

   330     if self.has_body_:

   331       self.has_body_ = 0

   332       self.body_ = ""

   333 

   334   def has_body(self): return self.has_body_

   335 

   336 

   337   def MergeFrom(self, x):

   338     assert x is not self

   339     if (x.has_queue_name()): self.set_queue_name(x.queue_name())

   340     if (x.has_task_name()): self.set_task_name(x.task_name())

   341     if (x.has_eta_usec()): self.set_eta_usec(x.eta_usec())

   342     if (x.has_method()): self.set_method(x.method())

   343     if (x.has_url()): self.set_url(x.url())

   344     for i in xrange(x.header_size()): self.add_header().CopyFrom(x.header(i))

   345     if (x.has_body()): self.set_body(x.body())

   346 

   347   def Equals(self, x):

   348     if x is self: return 1

   349     if self.has_queue_name_ != x.has_queue_name_: return 0

   350     if self.has_queue_name_ and self.queue_name_ != x.queue_name_: return 0

   351     if self.has_task_name_ != x.has_task_name_: return 0

   352     if self.has_task_name_ and self.task_name_ != x.task_name_: return 0

   353     if self.has_eta_usec_ != x.has_eta_usec_: return 0

   354     if self.has_eta_usec_ and self.eta_usec_ != x.eta_usec_: return 0

   355     if self.has_method_ != x.has_method_: return 0

   356     if self.has_method_ and self.method_ != x.method_: return 0

   357     if self.has_url_ != x.has_url_: return 0

   358     if self.has_url_ and self.url_ != x.url_: return 0

   359     if len(self.header_) != len(x.header_): return 0

   360     for e1, e2 in zip(self.header_, x.header_):

   361       if e1 != e2: return 0

   362     if self.has_body_ != x.has_body_: return 0

   363     if self.has_body_ and self.body_ != x.body_: return 0

   364     return 1

   365 

   366   def IsInitialized(self, debug_strs=None):

   367     initialized = 1

   368     if (not self.has_queue_name_):

   369       initialized = 0

   370       if debug_strs is not None:

   371         debug_strs.append('Required field: queue_name not set.')

   372     if (not self.has_task_name_):

   373       initialized = 0

   374       if debug_strs is not None:

   375         debug_strs.append('Required field: task_name not set.')

   376     if (not self.has_eta_usec_):

   377       initialized = 0

   378       if debug_strs is not None:

   379         debug_strs.append('Required field: eta_usec not set.')

   380     if (not self.has_url_):

   381       initialized = 0

   382       if debug_strs is not None:

   383         debug_strs.append('Required field: url not set.')

   384     for p in self.header_:

   385       if not p.IsInitialized(debug_strs): initialized=0

   386     return initialized

   387 

   388   def ByteSize(self):

   389     n = 0

   390     n += self.lengthString(len(self.queue_name_))

   391     n += self.lengthString(len(self.task_name_))

   392     n += self.lengthVarInt64(self.eta_usec_)

   393     if (self.has_method_): n += 1 + self.lengthVarInt64(self.method_)

   394     n += self.lengthString(len(self.url_))

   395     n += 2 * len(self.header_)

   396     for i in xrange(len(self.header_)): n += self.header_[i].ByteSize()

   397     if (self.has_body_): n += 1 + self.lengthString(len(self.body_))

   398     return n + 4

   399 

   400   def Clear(self):

   401     self.clear_queue_name()

   402     self.clear_task_name()

   403     self.clear_eta_usec()

   404     self.clear_method()

   405     self.clear_url()

   406     self.clear_header()

   407     self.clear_body()

   408 

   409   def OutputUnchecked(self, out):

   410     out.putVarInt32(10)

   411     out.putPrefixedString(self.queue_name_)

   412     out.putVarInt32(18)

   413     out.putPrefixedString(self.task_name_)

   414     out.putVarInt32(24)

   415     out.putVarInt64(self.eta_usec_)

   416     out.putVarInt32(34)

   417     out.putPrefixedString(self.url_)

   418     if (self.has_method_):

   419       out.putVarInt32(40)

   420       out.putVarInt32(self.method_)

   421     for i in xrange(len(self.header_)):

   422       out.putVarInt32(51)

   423       self.header_[i].OutputUnchecked(out)

   424       out.putVarInt32(52)

   425     if (self.has_body_):

   426       out.putVarInt32(74)

   427       out.putPrefixedString(self.body_)

   428 

   429   def TryMerge(self, d):

   430     while d.avail() > 0:

   431       tt = d.getVarInt32()

   432       if tt == 10:

   433         self.set_queue_name(d.getPrefixedString())

   434         continue

   435       if tt == 18:

   436         self.set_task_name(d.getPrefixedString())

   437         continue

   438       if tt == 24:

   439         self.set_eta_usec(d.getVarInt64())

   440         continue

   441       if tt == 34:

   442         self.set_url(d.getPrefixedString())

   443         continue

   444       if tt == 40:

   445         self.set_method(d.getVarInt32())

   446         continue

   447       if tt == 51:

   448         self.add_header().TryMerge(d)

   449         continue

   450       if tt == 74:

   451         self.set_body(d.getPrefixedString())

   452         continue

   453       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError

   454       d.skipData(tt)

   455 

   456 

   457   def __str__(self, prefix="", printElemNumber=0):

   458     res=""

   459     if self.has_queue_name_: res+=prefix+("queue_name: %s\n" % self.DebugFormatString(self.queue_name_))

   460     if self.has_task_name_: res+=prefix+("task_name: %s\n" % self.DebugFormatString(self.task_name_))

   461     if self.has_eta_usec_: res+=prefix+("eta_usec: %s\n" % self.DebugFormatInt64(self.eta_usec_))

   462     if self.has_method_: res+=prefix+("method: %s\n" % self.DebugFormatInt32(self.method_))

   463     if self.has_url_: res+=prefix+("url: %s\n" % self.DebugFormatString(self.url_))

   464     cnt=0

   465     for e in self.header_:

   466       elm=""

   467       if printElemNumber: elm="(%d)" % cnt

   468       res+=prefix+("Header%s {\n" % elm)

   469       res+=e.__str__(prefix + "  ", printElemNumber)

   470       res+=prefix+"}\n"

   471       cnt+=1

   472     if self.has_body_: res+=prefix+("body: %s\n" % self.DebugFormatString(self.body_))

   473     return res

   474 

   475   kqueue_name = 1

   476   ktask_name = 2

   477   keta_usec = 3

   478   kmethod = 5

   479   kurl = 4

   480   kHeaderGroup = 6

   481   kHeaderkey = 7

   482   kHeadervalue = 8

   483   kbody = 9

   484 

   485   _TEXT = (

   486    "ErrorCode",

   487    "queue_name",

   488    "task_name",

   489    "eta_usec",

   490    "url",

   491    "method",

   492    "Header",

   493    "key",

   494    "value",

   495    "body",

   496   )

   497 

   498   _TYPES = (

   499    ProtocolBuffer.Encoder.NUMERIC,

   500    ProtocolBuffer.Encoder.STRING,

   501 

   502    ProtocolBuffer.Encoder.STRING,

   503 

   504    ProtocolBuffer.Encoder.NUMERIC,

   505 

   506    ProtocolBuffer.Encoder.STRING,

   507 

   508    ProtocolBuffer.Encoder.NUMERIC,

   509 

   510    ProtocolBuffer.Encoder.STARTGROUP,

   511 

   512    ProtocolBuffer.Encoder.STRING,

   513 

   514    ProtocolBuffer.Encoder.STRING,

   515 

   516    ProtocolBuffer.Encoder.STRING,

   517 

   518   )

   519 

   520   _STYLE = """"""

   521   _STYLE_CONTENT_TYPE = """"""

   522 class TaskQueueAddResponse(ProtocolBuffer.ProtocolMessage):

   523   has_chosen_task_name_ = 0

   524   chosen_task_name_ = ""

   525 

   526   def __init__(self, contents=None):

   527     if contents is not None: self.MergeFromString(contents)

   528 

   529   def chosen_task_name(self): return self.chosen_task_name_

   530 

   531   def set_chosen_task_name(self, x):

   532     self.has_chosen_task_name_ = 1

   533     self.chosen_task_name_ = x

   534 

   535   def clear_chosen_task_name(self):

   536     if self.has_chosen_task_name_:

   537       self.has_chosen_task_name_ = 0

   538       self.chosen_task_name_ = ""

   539 

   540   def has_chosen_task_name(self): return self.has_chosen_task_name_

   541 

   542 

   543   def MergeFrom(self, x):

   544     assert x is not self

   545     if (x.has_chosen_task_name()): self.set_chosen_task_name(x.chosen_task_name())

   546 

   547   def Equals(self, x):

   548     if x is self: return 1

   549     if self.has_chosen_task_name_ != x.has_chosen_task_name_: return 0

   550     if self.has_chosen_task_name_ and self.chosen_task_name_ != x.chosen_task_name_: return 0

   551     return 1

   552 

   553   def IsInitialized(self, debug_strs=None):

   554     initialized = 1

   555     return initialized

   556 

   557   def ByteSize(self):

   558     n = 0

   559     if (self.has_chosen_task_name_): n += 1 + self.lengthString(len(self.chosen_task_name_))

   560     return n + 0

   561 

   562   def Clear(self):

   563     self.clear_chosen_task_name()

   564 

   565   def OutputUnchecked(self, out):

   566     if (self.has_chosen_task_name_):

   567       out.putVarInt32(10)

   568       out.putPrefixedString(self.chosen_task_name_)

   569 

   570   def TryMerge(self, d):

   571     while d.avail() > 0:

   572       tt = d.getVarInt32()

   573       if tt == 10:

   574         self.set_chosen_task_name(d.getPrefixedString())

   575         continue

   576       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError

   577       d.skipData(tt)

   578 

   579 

   580   def __str__(self, prefix="", printElemNumber=0):

   581     res=""

   582     if self.has_chosen_task_name_: res+=prefix+("chosen_task_name: %s\n" % self.DebugFormatString(self.chosen_task_name_))

   583     return res

   584 

   585   kchosen_task_name = 1

   586 

   587   _TEXT = (

   588    "ErrorCode",

   589    "chosen_task_name",

   590   )

   591 

   592   _TYPES = (

   593    ProtocolBuffer.Encoder.NUMERIC,

   594    ProtocolBuffer.Encoder.STRING,

   595 

   596   )

   597 

   598   _STYLE = """"""

   599   _STYLE_CONTENT_TYPE = """"""

   600 class TaskQueueUpdateQueueRequest(ProtocolBuffer.ProtocolMessage):

   601   has_app_id_ = 0

   602   app_id_ = ""

   603   has_queue_name_ = 0

   604   queue_name_ = ""

   605   has_bucket_refill_per_second_ = 0

   606   bucket_refill_per_second_ = 0.0

   607   has_bucket_capacity_ = 0

   608   bucket_capacity_ = 0

   609   has_user_specified_rate_ = 0

   610   user_specified_rate_ = ""

   611 

   612   def __init__(self, contents=None):

   613     if contents is not None: self.MergeFromString(contents)

   614 

   615   def app_id(self): return self.app_id_

   616 

   617   def set_app_id(self, x):

   618     self.has_app_id_ = 1

   619     self.app_id_ = x

   620 

   621   def clear_app_id(self):

   622     if self.has_app_id_:

   623       self.has_app_id_ = 0

   624       self.app_id_ = ""

   625 

   626   def has_app_id(self): return self.has_app_id_

   627 

   628   def queue_name(self): return self.queue_name_

   629 

   630   def set_queue_name(self, x):

   631     self.has_queue_name_ = 1

   632     self.queue_name_ = x

   633 

   634   def clear_queue_name(self):

   635     if self.has_queue_name_:

   636       self.has_queue_name_ = 0

   637       self.queue_name_ = ""

   638 

   639   def has_queue_name(self): return self.has_queue_name_

   640 

   641   def bucket_refill_per_second(self): return self.bucket_refill_per_second_

   642 

   643   def set_bucket_refill_per_second(self, x):

   644     self.has_bucket_refill_per_second_ = 1

   645     self.bucket_refill_per_second_ = x

   646 

   647   def clear_bucket_refill_per_second(self):

   648     if self.has_bucket_refill_per_second_:

   649       self.has_bucket_refill_per_second_ = 0

   650       self.bucket_refill_per_second_ = 0.0

   651 

   652   def has_bucket_refill_per_second(self): return self.has_bucket_refill_per_second_

   653 

   654   def bucket_capacity(self): return self.bucket_capacity_

   655 

   656   def set_bucket_capacity(self, x):

   657     self.has_bucket_capacity_ = 1

   658     self.bucket_capacity_ = x

   659 

   660   def clear_bucket_capacity(self):

   661     if self.has_bucket_capacity_:

   662       self.has_bucket_capacity_ = 0

   663       self.bucket_capacity_ = 0

   664 

   665   def has_bucket_capacity(self): return self.has_bucket_capacity_

   666 

   667   def user_specified_rate(self): return self.user_specified_rate_

   668 

   669   def set_user_specified_rate(self, x):

   670     self.has_user_specified_rate_ = 1

   671     self.user_specified_rate_ = x

   672 

   673   def clear_user_specified_rate(self):

   674     if self.has_user_specified_rate_:

   675       self.has_user_specified_rate_ = 0

   676       self.user_specified_rate_ = ""

   677 

   678   def has_user_specified_rate(self): return self.has_user_specified_rate_

   679 

   680 

   681   def MergeFrom(self, x):

   682     assert x is not self

   683     if (x.has_app_id()): self.set_app_id(x.app_id())

   684     if (x.has_queue_name()): self.set_queue_name(x.queue_name())

   685     if (x.has_bucket_refill_per_second()): self.set_bucket_refill_per_second(x.bucket_refill_per_second())

   686     if (x.has_bucket_capacity()): self.set_bucket_capacity(x.bucket_capacity())

   687     if (x.has_user_specified_rate()): self.set_user_specified_rate(x.user_specified_rate())

   688 

   689   def Equals(self, x):

   690     if x is self: return 1

   691     if self.has_app_id_ != x.has_app_id_: return 0

   692     if self.has_app_id_ and self.app_id_ != x.app_id_: return 0

   693     if self.has_queue_name_ != x.has_queue_name_: return 0

   694     if self.has_queue_name_ and self.queue_name_ != x.queue_name_: return 0

   695     if self.has_bucket_refill_per_second_ != x.has_bucket_refill_per_second_: return 0

   696     if self.has_bucket_refill_per_second_ and self.bucket_refill_per_second_ != x.bucket_refill_per_second_: return 0

   697     if self.has_bucket_capacity_ != x.has_bucket_capacity_: return 0

   698     if self.has_bucket_capacity_ and self.bucket_capacity_ != x.bucket_capacity_: return 0

   699     if self.has_user_specified_rate_ != x.has_user_specified_rate_: return 0

   700     if self.has_user_specified_rate_ and self.user_specified_rate_ != x.user_specified_rate_: return 0

   701     return 1

   702 

   703   def IsInitialized(self, debug_strs=None):

   704     initialized = 1

   705     if (not self.has_app_id_):

   706       initialized = 0

   707       if debug_strs is not None:

   708         debug_strs.append('Required field: app_id not set.')

   709     if (not self.has_queue_name_):

   710       initialized = 0

   711       if debug_strs is not None:

   712         debug_strs.append('Required field: queue_name not set.')

   713     if (not self.has_bucket_refill_per_second_):

   714       initialized = 0

   715       if debug_strs is not None:

   716         debug_strs.append('Required field: bucket_refill_per_second not set.')

   717     if (not self.has_bucket_capacity_):

   718       initialized = 0

   719       if debug_strs is not None:

   720         debug_strs.append('Required field: bucket_capacity not set.')

   721     return initialized

   722 

   723   def ByteSize(self):

   724     n = 0

   725     n += self.lengthString(len(self.app_id_))

   726     n += self.lengthString(len(self.queue_name_))

   727     n += self.lengthVarInt64(self.bucket_capacity_)

   728     if (self.has_user_specified_rate_): n += 1 + self.lengthString(len(self.user_specified_rate_))

   729     return n + 12

   730 

   731   def Clear(self):

   732     self.clear_app_id()

   733     self.clear_queue_name()

   734     self.clear_bucket_refill_per_second()

   735     self.clear_bucket_capacity()

   736     self.clear_user_specified_rate()

   737 

   738   def OutputUnchecked(self, out):

   739     out.putVarInt32(10)

   740     out.putPrefixedString(self.app_id_)

   741     out.putVarInt32(18)

   742     out.putPrefixedString(self.queue_name_)

   743     out.putVarInt32(25)

   744     out.putDouble(self.bucket_refill_per_second_)

   745     out.putVarInt32(32)

   746     out.putVarInt32(self.bucket_capacity_)

   747     if (self.has_user_specified_rate_):

   748       out.putVarInt32(42)

   749       out.putPrefixedString(self.user_specified_rate_)

   750 

   751   def TryMerge(self, d):

   752     while d.avail() > 0:

   753       tt = d.getVarInt32()

   754       if tt == 10:

   755         self.set_app_id(d.getPrefixedString())

   756         continue

   757       if tt == 18:

   758         self.set_queue_name(d.getPrefixedString())

   759         continue

   760       if tt == 25:

   761         self.set_bucket_refill_per_second(d.getDouble())

   762         continue

   763       if tt == 32:

   764         self.set_bucket_capacity(d.getVarInt32())

   765         continue

   766       if tt == 42:

   767         self.set_user_specified_rate(d.getPrefixedString())

   768         continue

   769       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError

   770       d.skipData(tt)

   771 

   772 

   773   def __str__(self, prefix="", printElemNumber=0):

   774     res=""

   775     if self.has_app_id_: res+=prefix+("app_id: %s\n" % self.DebugFormatString(self.app_id_))

   776     if self.has_queue_name_: res+=prefix+("queue_name: %s\n" % self.DebugFormatString(self.queue_name_))

   777     if self.has_bucket_refill_per_second_: res+=prefix+("bucket_refill_per_second: %s\n" % self.DebugFormat(self.bucket_refill_per_second_))

   778     if self.has_bucket_capacity_: res+=prefix+("bucket_capacity: %s\n" % self.DebugFormatInt32(self.bucket_capacity_))

   779     if self.has_user_specified_rate_: res+=prefix+("user_specified_rate: %s\n" % self.DebugFormatString(self.user_specified_rate_))

   780     return res

   781 

   782   kapp_id = 1

   783   kqueue_name = 2

   784   kbucket_refill_per_second = 3

   785   kbucket_capacity = 4

   786   kuser_specified_rate = 5

   787 

   788   _TEXT = (

   789    "ErrorCode",

   790    "app_id",

   791    "queue_name",

   792    "bucket_refill_per_second",

   793    "bucket_capacity",

   794    "user_specified_rate",

   795   )

   796 

   797   _TYPES = (

   798    ProtocolBuffer.Encoder.NUMERIC,

   799    ProtocolBuffer.Encoder.STRING,

   800 

   801    ProtocolBuffer.Encoder.STRING,

   802 

   803    ProtocolBuffer.Encoder.DOUBLE,

   804 

   805    ProtocolBuffer.Encoder.NUMERIC,

   806 

   807    ProtocolBuffer.Encoder.STRING,

   808 

   809   )

   810 

   811   _STYLE = """"""

   812   _STYLE_CONTENT_TYPE = """"""

   813 class TaskQueueUpdateQueueResponse(ProtocolBuffer.ProtocolMessage):

   814 

   815   def __init__(self, contents=None):

   816     pass

   817     if contents is not None: self.MergeFromString(contents)

   818 

   819 

   820   def MergeFrom(self, x):

   821     assert x is not self

   822 

   823   def Equals(self, x):

   824     if x is self: return 1

   825     return 1

   826 

   827   def IsInitialized(self, debug_strs=None):

   828     initialized = 1

   829     return initialized

   830 

   831   def ByteSize(self):

   832     n = 0

   833     return n + 0

   834 

   835   def Clear(self):

   836     pass

   837 

   838   def OutputUnchecked(self, out):

   839     pass

   840 

   841   def TryMerge(self, d):

   842     while d.avail() > 0:

   843       tt = d.getVarInt32()

   844       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError

   845       d.skipData(tt)

   846 

   847 

   848   def __str__(self, prefix="", printElemNumber=0):

   849     res=""

   850     return res

   851 

   852 

   853   _TEXT = (

   854    "ErrorCode",

   855   )

   856 

   857   _TYPES = (

   858    ProtocolBuffer.Encoder.NUMERIC,

   859   )

   860 

   861   _STYLE = """"""

   862   _STYLE_CONTENT_TYPE = """"""

   863 class TaskQueueFetchQueuesRequest(ProtocolBuffer.ProtocolMessage):

   864   has_app_id_ = 0

   865   app_id_ = ""

   866   has_max_rows_ = 0

   867   max_rows_ = 0

   868 

   869   def __init__(self, contents=None):

   870     if contents is not None: self.MergeFromString(contents)

   871 

   872   def app_id(self): return self.app_id_

   873 

   874   def set_app_id(self, x):

   875     self.has_app_id_ = 1

   876     self.app_id_ = x

   877 

   878   def clear_app_id(self):

   879     if self.has_app_id_:

   880       self.has_app_id_ = 0

   881       self.app_id_ = ""

   882 

   883   def has_app_id(self): return self.has_app_id_

   884 

   885   def max_rows(self): return self.max_rows_

   886 

   887   def set_max_rows(self, x):

   888     self.has_max_rows_ = 1

   889     self.max_rows_ = x

   890 

   891   def clear_max_rows(self):

   892     if self.has_max_rows_:

   893       self.has_max_rows_ = 0

   894       self.max_rows_ = 0

   895 

   896   def has_max_rows(self): return self.has_max_rows_

   897 

   898 

   899   def MergeFrom(self, x):

   900     assert x is not self

   901     if (x.has_app_id()): self.set_app_id(x.app_id())

   902     if (x.has_max_rows()): self.set_max_rows(x.max_rows())

   903 

   904   def Equals(self, x):

   905     if x is self: return 1

   906     if self.has_app_id_ != x.has_app_id_: return 0

   907     if self.has_app_id_ and self.app_id_ != x.app_id_: return 0

   908     if self.has_max_rows_ != x.has_max_rows_: return 0

   909     if self.has_max_rows_ and self.max_rows_ != x.max_rows_: return 0

   910     return 1

   911 

   912   def IsInitialized(self, debug_strs=None):

   913     initialized = 1

   914     if (not self.has_app_id_):

   915       initialized = 0

   916       if debug_strs is not None:

   917         debug_strs.append('Required field: app_id not set.')

   918     if (not self.has_max_rows_):

   919       initialized = 0

   920       if debug_strs is not None:

   921         debug_strs.append('Required field: max_rows not set.')

   922     return initialized

   923 

   924   def ByteSize(self):

   925     n = 0

   926     n += self.lengthString(len(self.app_id_))

   927     n += self.lengthVarInt64(self.max_rows_)

   928     return n + 2

   929 

   930   def Clear(self):

   931     self.clear_app_id()

   932     self.clear_max_rows()

   933 

   934   def OutputUnchecked(self, out):

   935     out.putVarInt32(10)

   936     out.putPrefixedString(self.app_id_)

   937     out.putVarInt32(16)

   938     out.putVarInt32(self.max_rows_)

   939 

   940   def TryMerge(self, d):

   941     while d.avail() > 0:

   942       tt = d.getVarInt32()

   943       if tt == 10:

   944         self.set_app_id(d.getPrefixedString())

   945         continue

   946       if tt == 16:

   947         self.set_max_rows(d.getVarInt32())

   948         continue

   949       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError

   950       d.skipData(tt)

   951 

   952 

   953   def __str__(self, prefix="", printElemNumber=0):

   954     res=""

   955     if self.has_app_id_: res+=prefix+("app_id: %s\n" % self.DebugFormatString(self.app_id_))

   956     if self.has_max_rows_: res+=prefix+("max_rows: %s\n" % self.DebugFormatInt32(self.max_rows_))

   957     return res

   958 

   959   kapp_id = 1

   960   kmax_rows = 2

   961 

   962   _TEXT = (

   963    "ErrorCode",

   964    "app_id",

   965    "max_rows",

   966   )

   967 

   968   _TYPES = (

   969    ProtocolBuffer.Encoder.NUMERIC,

   970    ProtocolBuffer.Encoder.STRING,

   971 

   972    ProtocolBuffer.Encoder.NUMERIC,

   973 

   974   )

   975 

   976   _STYLE = """"""

   977   _STYLE_CONTENT_TYPE = """"""

   978 class TaskQueueFetchQueuesResponse_Queue(ProtocolBuffer.ProtocolMessage):

   979   has_queue_name_ = 0

   980   queue_name_ = ""

   981   has_bucket_refill_per_second_ = 0

   982   bucket_refill_per_second_ = 0.0

   983   has_bucket_capacity_ = 0

   984   bucket_capacity_ = 0.0

   985   has_user_specified_rate_ = 0

   986   user_specified_rate_ = ""

   987 

   988   def __init__(self, contents=None):

   989     if contents is not None: self.MergeFromString(contents)

   990 

   991   def queue_name(self): return self.queue_name_

   992 

   993   def set_queue_name(self, x):

   994     self.has_queue_name_ = 1

   995     self.queue_name_ = x

   996 

   997   def clear_queue_name(self):

   998     if self.has_queue_name_:

   999       self.has_queue_name_ = 0

  1000       self.queue_name_ = ""

  1001 

  1002   def has_queue_name(self): return self.has_queue_name_

  1003 

  1004   def bucket_refill_per_second(self): return self.bucket_refill_per_second_

  1005 

  1006   def set_bucket_refill_per_second(self, x):

  1007     self.has_bucket_refill_per_second_ = 1

  1008     self.bucket_refill_per_second_ = x

  1009 

  1010   def clear_bucket_refill_per_second(self):

  1011     if self.has_bucket_refill_per_second_:

  1012       self.has_bucket_refill_per_second_ = 0

  1013       self.bucket_refill_per_second_ = 0.0

  1014 

  1015   def has_bucket_refill_per_second(self): return self.has_bucket_refill_per_second_

  1016 

  1017   def bucket_capacity(self): return self.bucket_capacity_

  1018 

  1019   def set_bucket_capacity(self, x):

  1020     self.has_bucket_capacity_ = 1

  1021     self.bucket_capacity_ = x

  1022 

  1023   def clear_bucket_capacity(self):

  1024     if self.has_bucket_capacity_:

  1025       self.has_bucket_capacity_ = 0

  1026       self.bucket_capacity_ = 0.0

  1027 

  1028   def has_bucket_capacity(self): return self.has_bucket_capacity_

  1029 

  1030   def user_specified_rate(self): return self.user_specified_rate_

  1031 

  1032   def set_user_specified_rate(self, x):

  1033     self.has_user_specified_rate_ = 1

  1034     self.user_specified_rate_ = x

  1035 

  1036   def clear_user_specified_rate(self):

  1037     if self.has_user_specified_rate_:

  1038       self.has_user_specified_rate_ = 0

  1039       self.user_specified_rate_ = ""

  1040 

  1041   def has_user_specified_rate(self): return self.has_user_specified_rate_

  1042 

  1043 

  1044   def MergeFrom(self, x):

  1045     assert x is not self

  1046     if (x.has_queue_name()): self.set_queue_name(x.queue_name())

  1047     if (x.has_bucket_refill_per_second()): self.set_bucket_refill_per_second(x.bucket_refill_per_second())

  1048     if (x.has_bucket_capacity()): self.set_bucket_capacity(x.bucket_capacity())

  1049     if (x.has_user_specified_rate()): self.set_user_specified_rate(x.user_specified_rate())

  1050 

  1051   def Equals(self, x):

  1052     if x is self: return 1

  1053     if self.has_queue_name_ != x.has_queue_name_: return 0

  1054     if self.has_queue_name_ and self.queue_name_ != x.queue_name_: return 0

  1055     if self.has_bucket_refill_per_second_ != x.has_bucket_refill_per_second_: return 0

  1056     if self.has_bucket_refill_per_second_ and self.bucket_refill_per_second_ != x.bucket_refill_per_second_: return 0

  1057     if self.has_bucket_capacity_ != x.has_bucket_capacity_: return 0

  1058     if self.has_bucket_capacity_ and self.bucket_capacity_ != x.bucket_capacity_: return 0

  1059     if self.has_user_specified_rate_ != x.has_user_specified_rate_: return 0

  1060     if self.has_user_specified_rate_ and self.user_specified_rate_ != x.user_specified_rate_: return 0

  1061     return 1

  1062 

  1063   def IsInitialized(self, debug_strs=None):

  1064     initialized = 1

  1065     if (not self.has_queue_name_):

  1066       initialized = 0

  1067       if debug_strs is not None:

  1068         debug_strs.append('Required field: queue_name not set.')

  1069     if (not self.has_bucket_refill_per_second_):

  1070       initialized = 0

  1071       if debug_strs is not None:

  1072         debug_strs.append('Required field: bucket_refill_per_second not set.')

  1073     if (not self.has_bucket_capacity_):

  1074       initialized = 0

  1075       if debug_strs is not None:

  1076         debug_strs.append('Required field: bucket_capacity not set.')

  1077     return initialized

  1078 

  1079   def ByteSize(self):

  1080     n = 0

  1081     n += self.lengthString(len(self.queue_name_))

  1082     if (self.has_user_specified_rate_): n += 1 + self.lengthString(len(self.user_specified_rate_))

  1083     return n + 19

  1084 

  1085   def Clear(self):

  1086     self.clear_queue_name()

  1087     self.clear_bucket_refill_per_second()

  1088     self.clear_bucket_capacity()

  1089     self.clear_user_specified_rate()

  1090 

  1091   def OutputUnchecked(self, out):

  1092     out.putVarInt32(18)

  1093     out.putPrefixedString(self.queue_name_)

  1094     out.putVarInt32(25)

  1095     out.putDouble(self.bucket_refill_per_second_)

  1096     out.putVarInt32(33)

  1097     out.putDouble(self.bucket_capacity_)

  1098     if (self.has_user_specified_rate_):

  1099       out.putVarInt32(42)

  1100       out.putPrefixedString(self.user_specified_rate_)

  1101 

  1102   def TryMerge(self, d):

  1103     while 1:

  1104       tt = d.getVarInt32()

  1105       if tt == 12: break

  1106       if tt == 18:

  1107         self.set_queue_name(d.getPrefixedString())

  1108         continue

  1109       if tt == 25:

  1110         self.set_bucket_refill_per_second(d.getDouble())

  1111         continue

  1112       if tt == 33:

  1113         self.set_bucket_capacity(d.getDouble())

  1114         continue

  1115       if tt == 42:

  1116         self.set_user_specified_rate(d.getPrefixedString())

  1117         continue

  1118       if (tt == 0): raise ProtocolBuffer.ProtocolBufferDecodeError

  1119       d.skipData(tt)

  1120 

  1121 

  1122   def __str__(self, prefix="", printElemNumber=0):

  1123     res=""

  1124     if self.has_queue_name_: res+=prefix+("queue_name: %s\n" % self.DebugFormatString(self.queue_name_))

  1125     if self.has_bucket_refill_per_second_: res+=prefix+("bucket_refill_per_second: %s\n" % self.DebugFormat(self.bucket_refill_per_second_))

  1126     if self.has_bucket_capacity_: res+=prefix+("bucket_capacity: %s\n" % self.DebugFormat(self.bucket_capacity_))

  1127     if self.has_user_specified_rate_: res+=prefix+("user_specified_rate: %s\n" % self.DebugFormatString(self.user_specified_rate_))

  1128     return res

  1129 

  1130 class TaskQueueFetchQueuesResponse(ProtocolBuffer.ProtocolMessage):

  1131 

  1132   def __init__(self, contents=None):

  1133     self.queue_ = []

  1134     if contents is not None: self.MergeFromString(contents)

  1135