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 from google.net.proto.RawMessage import RawMessage

    26 from google.appengine.datastore.datastore_pb import PutRequest

    27 from google.appengine.datastore.datastore_pb import DeleteRequest

    28 from google.appengine.datastore.entity_pb import Reference

    29 class Request(ProtocolBuffer.ProtocolMessage):

    30   has_service_name_ = 0

    31   service_name_ = ""

    32   has_method_ = 0

    33   method_ = ""

    34   has_request_ = 0

    35 

    36   def __init__(self, contents=None):

    37     self.request_ = RawMessage()

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

    39 

    40   def service_name(self): return self.service_name_

    41 

    42   def set_service_name(self, x):

    43     self.has_service_name_ = 1

    44     self.service_name_ = x

    45 

    46   def clear_service_name(self):

    47     self.has_service_name_ = 0

    48     self.service_name_ = ""

    49 

    50   def has_service_name(self): return self.has_service_name_

    51 

    52   def method(self): return self.method_

    53 

    54   def set_method(self, x):

    55     self.has_method_ = 1

    56     self.method_ = x

    57 

    58   def clear_method(self):

    59     self.has_method_ = 0

    60     self.method_ = ""

    61 

    62   def has_method(self): return self.has_method_

    63 

    64   def request(self): return self.request_

    65 

    66   def mutable_request(self): self.has_request_ = 1; return self.request_

    67 

    68   def clear_request(self):self.has_request_ = 0; self.request_.Clear()

    69 

    70   def has_request(self): return self.has_request_

    71 

    72 

    73   def MergeFrom(self, x):

    74     assert x is not self

    75     if (x.has_service_name()): self.set_service_name(x.service_name())

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

    77     if (x.has_request()): self.mutable_request().MergeFrom(x.request())

    78 

    79   def Equals(self, x):

    80     if x is self: return 1

    81     if self.has_service_name_ != x.has_service_name_: return 0

    82     if self.has_service_name_ and self.service_name_ != x.service_name_: return 0

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

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

    85     if self.has_request_ != x.has_request_: return 0

    86     if self.has_request_ and self.request_ != x.request_: return 0

    87     return 1

    88 

    89   def IsInitialized(self, debug_strs=None):

    90     initialized = 1

    91     if (not self.has_service_name_):

    92       initialized = 0

    93       if debug_strs is not None:

    94         debug_strs.append('Required field: service_name not set.')

    95     if (not self.has_method_):

    96       initialized = 0

    97       if debug_strs is not None:

    98         debug_strs.append('Required field: method not set.')

    99     if (not self.has_request_):

   100       initialized = 0

   101       if debug_strs is not None:

   102         debug_strs.append('Required field: request not set.')

   103     elif not self.request_.IsInitialized(debug_strs): initialized = 0

   104     return initialized

   105 

   106   def ByteSize(self):

   107     n = 0

   108     n += self.lengthString(len(self.service_name_))

   109     n += self.lengthString(len(self.method_))

   110     n += self.lengthString(self.request_.ByteSize())

   111     return n + 3

   112 

   113   def Clear(self):

   114     self.clear_service_name()

   115     self.clear_method()

   116     self.clear_request()

   117 

   118   def OutputUnchecked(self, out):

   119     out.putVarInt32(18)

   120     out.putPrefixedString(self.service_name_)

   121     out.putVarInt32(26)

   122     out.putPrefixedString(self.method_)

   123     out.putVarInt32(34)

   124     out.putVarInt32(self.request_.ByteSize())

   125     self.request_.OutputUnchecked(out)

   126 

   127   def TryMerge(self, d):

   128     while d.avail() > 0:

   129       tt = d.getVarInt32()

   130       if tt == 18:

   131         self.set_service_name(d.getPrefixedString())

   132         continue

   133       if tt == 26:

   134         self.set_method(d.getPrefixedString())

   135         continue

   136       if tt == 34:

   137         length = d.getVarInt32()

   138         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)

   139         d.skip(length)

   140         self.mutable_request().TryMerge(tmp)

   141         continue

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

   143       d.skipData(tt)

   144 

   145 

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

   147     res=""

   148     if self.has_service_name_: res+=prefix+("service_name: %s\n" % self.DebugFormatString(self.service_name_))

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

   150     if self.has_request_:

   151       res+=prefix+"request <\n"

   152       res+=self.request_.__str__(prefix + "  ", printElemNumber)

   153       res+=prefix+">\n"

   154     return res

   155 

   156   kservice_name = 2

   157   kmethod = 3

   158   krequest = 4

   159 

   160   _TEXT = (

   161    "ErrorCode",

   162    None,

   163    "service_name",

   164    "method",

   165    "request",

   166   )

   167 

   168   _TYPES = (

   169    ProtocolBuffer.Encoder.NUMERIC,

   170    ProtocolBuffer.Encoder.MAX_TYPE,

   171 

   172    ProtocolBuffer.Encoder.STRING,

   173 

   174    ProtocolBuffer.Encoder.STRING,

   175 

   176    ProtocolBuffer.Encoder.STRING,

   177 

   178   )

   179 

   180   _STYLE = """"""

   181   _STYLE_CONTENT_TYPE = """"""

   182 class Response(ProtocolBuffer.ProtocolMessage):

   183   has_response_ = 0

   184   response_ = None

   185   has_exception_ = 0

   186   exception_ = None

   187 

   188   def __init__(self, contents=None):

   189     self.lazy_init_lock_ = thread.allocate_lock()

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

   191 

   192   def response(self):

   193     if self.response_ is None:

   194       self.lazy_init_lock_.acquire()

   195       try:

   196         if self.response_ is None: self.response_ = RawMessage()

   197       finally:

   198         self.lazy_init_lock_.release()

   199     return self.response_

   200 

   201   def mutable_response(self): self.has_response_ = 1; return self.response()

   202 

   203   def clear_response(self):

   204     self.has_response_ = 0;

   205     if self.response_ is not None: self.response_.Clear()

   206 

   207   def has_response(self): return self.has_response_

   208 

   209   def exception(self):

   210     if self.exception_ is None:

   211       self.lazy_init_lock_.acquire()

   212       try:

   213         if self.exception_ is None: self.exception_ = RawMessage()

   214       finally:

   215         self.lazy_init_lock_.release()

   216     return self.exception_

   217 

   218   def mutable_exception(self): self.has_exception_ = 1; return self.exception()

   219 

   220   def clear_exception(self):

   221     self.has_exception_ = 0;

   222     if self.exception_ is not None: self.exception_.Clear()

   223 

   224   def has_exception(self): return self.has_exception_

   225 

   226 

   227   def MergeFrom(self, x):

   228     assert x is not self

   229     if (x.has_response()): self.mutable_response().MergeFrom(x.response())

   230     if (x.has_exception()): self.mutable_exception().MergeFrom(x.exception())

   231 

   232   def Equals(self, x):

   233     if x is self: return 1

   234     if self.has_response_ != x.has_response_: return 0

   235     if self.has_response_ and self.response_ != x.response_: return 0

   236     if self.has_exception_ != x.has_exception_: return 0

   237     if self.has_exception_ and self.exception_ != x.exception_: return 0

   238     return 1

   239 

   240   def IsInitialized(self, debug_strs=None):

   241     initialized = 1

   242     if (self.has_response_ and not self.response_.IsInitialized(debug_strs)): initialized = 0

   243     if (self.has_exception_ and not self.exception_.IsInitialized(debug_strs)): initialized = 0

   244     return initialized

   245 

   246   def ByteSize(self):

   247     n = 0

   248     if (self.has_response_): n += 1 + self.lengthString(self.response_.ByteSize())

   249     if (self.has_exception_): n += 1 + self.lengthString(self.exception_.ByteSize())

   250     return n + 0

   251 

   252   def Clear(self):

   253     self.clear_response()

   254     self.clear_exception()

   255 

   256   def OutputUnchecked(self, out):

   257     if (self.has_response_):

   258       out.putVarInt32(10)

   259       out.putVarInt32(self.response_.ByteSize())

   260       self.response_.OutputUnchecked(out)

   261     if (self.has_exception_):

   262       out.putVarInt32(18)

   263       out.putVarInt32(self.exception_.ByteSize())

   264       self.exception_.OutputUnchecked(out)

   265 

   266   def TryMerge(self, d):

   267     while d.avail() > 0:

   268       tt = d.getVarInt32()

   269       if tt == 10:

   270         length = d.getVarInt32()

   271         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)

   272         d.skip(length)

   273         self.mutable_response().TryMerge(tmp)

   274         continue

   275       if tt == 18:

   276         length = d.getVarInt32()

   277         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)

   278         d.skip(length)

   279         self.mutable_exception().TryMerge(tmp)

   280         continue

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

   282       d.skipData(tt)

   283 

   284 

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

   286     res=""

   287     if self.has_response_:

   288       res+=prefix+"response <\n"

   289       res+=self.response_.__str__(prefix + "  ", printElemNumber)

   290       res+=prefix+">\n"

   291     if self.has_exception_:

   292       res+=prefix+"exception <\n"

   293       res+=self.exception_.__str__(prefix + "  ", printElemNumber)

   294       res+=prefix+">\n"

   295     return res

   296 

   297   kresponse = 1

   298   kexception = 2

   299 

   300   _TEXT = (

   301    "ErrorCode",

   302    "response",

   303    "exception",

   304   )

   305 

   306   _TYPES = (

   307    ProtocolBuffer.Encoder.NUMERIC,

   308    ProtocolBuffer.Encoder.STRING,

   309 

   310    ProtocolBuffer.Encoder.STRING,

   311 

   312   )

   313 

   314   _STYLE = """"""

   315   _STYLE_CONTENT_TYPE = """"""

   316 class TransactionRequest_Precondition(ProtocolBuffer.ProtocolMessage):

   317   has_key_ = 0

   318   has_hash_ = 0

   319   hash_ = ""

   320 

   321   def __init__(self, contents=None):

   322     self.key_ = Reference()

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

   324 

   325   def key(self): return self.key_

   326 

   327   def mutable_key(self): self.has_key_ = 1; return self.key_

   328 

   329   def clear_key(self):self.has_key_ = 0; self.key_.Clear()

   330 

   331   def has_key(self): return self.has_key_

   332 

   333   def hash(self): return self.hash_

   334 

   335   def set_hash(self, x):

   336     self.has_hash_ = 1

   337     self.hash_ = x

   338 

   339   def clear_hash(self):

   340     self.has_hash_ = 0

   341     self.hash_ = ""

   342 

   343   def has_hash(self): return self.has_hash_

   344 

   345 

   346   def MergeFrom(self, x):

   347     assert x is not self

   348     if (x.has_key()): self.mutable_key().MergeFrom(x.key())

   349     if (x.has_hash()): self.set_hash(x.hash())

   350 

   351   def Equals(self, x):

   352     if x is self: return 1

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

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

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

   356     if self.has_hash_ and self.hash_ != x.hash_: return 0

   357     return 1

   358 

   359   def IsInitialized(self, debug_strs=None):

   360     initialized = 1

   361     if (not self.has_key_):

   362       initialized = 0

   363       if debug_strs is not None:

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

   365     elif not self.key_.IsInitialized(debug_strs): initialized = 0

   366     return initialized

   367 

   368   def ByteSize(self):

   369     n = 0

   370     n += self.lengthString(self.key_.ByteSize())

   371     if (self.has_hash_): n += 1 + self.lengthString(len(self.hash_))

   372     return n + 1

   373 

   374   def Clear(self):

   375     self.clear_key()

   376     self.clear_hash()

   377 

   378   def OutputUnchecked(self, out):

   379     out.putVarInt32(18)

   380     out.putVarInt32(self.key_.ByteSize())

   381     self.key_.OutputUnchecked(out)

   382     if (self.has_hash_):

   383       out.putVarInt32(26)

   384       out.putPrefixedString(self.hash_)

   385 

   386   def TryMerge(self, d):

   387     while 1:

   388       tt = d.getVarInt32()

   389       if tt == 12: break

   390       if tt == 18:

   391         length = d.getVarInt32()

   392         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)

   393         d.skip(length)

   394         self.mutable_key().TryMerge(tmp)

   395         continue

   396       if tt == 26:

   397         self.set_hash(d.getPrefixedString())

   398         continue

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

   400       d.skipData(tt)

   401 

   402 

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

   404     res=""

   405     if self.has_key_:

   406       res+=prefix+"key <\n"

   407       res+=self.key_.__str__(prefix + "  ", printElemNumber)

   408       res+=prefix+">\n"

   409     if self.has_hash_: res+=prefix+("hash: %s\n" % self.DebugFormatString(self.hash_))

   410     return res

   411 

   412 class TransactionRequest(ProtocolBuffer.ProtocolMessage):

   413   has_puts_ = 0

   414   puts_ = None

   415   has_deletes_ = 0

   416   deletes_ = None

   417 

   418   def __init__(self, contents=None):

   419     self.precondition_ = []

   420     self.lazy_init_lock_ = thread.allocate_lock()

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

   422 

   423   def precondition_size(self): return len(self.precondition_)

   424   def precondition_list(self): return self.precondition_

   425 

   426   def precondition(self, i):

   427     return self.precondition_[i]

   428 

   429   def mutable_precondition(self, i):

   430     return self.precondition_[i]

   431 

   432   def add_precondition(self):

   433     x = TransactionRequest_Precondition()

   434     self.precondition_.append(x)

   435     return x

   436 

   437   def clear_precondition(self):

   438     self.precondition_ = []

   439   def puts(self):

   440     if self.puts_ is None:

   441       self.lazy_init_lock_.acquire()

   442       try:

   443         if self.puts_ is None: self.puts_ = PutRequest()

   444       finally:

   445         self.lazy_init_lock_.release()

   446     return self.puts_

   447 

   448   def mutable_puts(self): self.has_puts_ = 1; return self.puts()

   449 

   450   def clear_puts(self):

   451     self.has_puts_ = 0;

   452     if self.puts_ is not None: self.puts_.Clear()

   453 

   454   def has_puts(self): return self.has_puts_

   455 

   456   def deletes(self):

   457     if self.deletes_ is None:

   458       self.lazy_init_lock_.acquire()

   459       try:

   460         if self.deletes_ is None: self.deletes_ = DeleteRequest()

   461       finally:

   462         self.lazy_init_lock_.release()

   463     return self.deletes_

   464 

   465   def mutable_deletes(self): self.has_deletes_ = 1; return self.deletes()

   466 

   467   def clear_deletes(self):

   468     self.has_deletes_ = 0;

   469     if self.deletes_ is not None: self.deletes_.Clear()

   470 

   471   def has_deletes(self): return self.has_deletes_

   472 

   473 

   474   def MergeFrom(self, x):

   475     assert x is not self

   476     for i in xrange(x.precondition_size()): self.add_precondition().CopyFrom(x.precondition(i))

   477     if (x.has_puts()): self.mutable_puts().MergeFrom(x.puts())

   478     if (x.has_deletes()): self.mutable_deletes().MergeFrom(x.deletes())

   479 

   480   def Equals(self, x):

   481     if x is self: return 1

   482     if len(self.precondition_) != len(x.precondition_): return 0

   483     for e1, e2 in zip(self.precondition_, x.precondition_):

   484       if e1 != e2: return 0

   485     if self.has_puts_ != x.has_puts_: return 0

   486     if self.has_puts_ and self.puts_ != x.puts_: return 0

   487     if self.has_deletes_ != x.has_deletes_: return 0

   488     if self.has_deletes_ and self.deletes_ != x.deletes_: return 0

   489     return 1

   490 

   491   def IsInitialized(self, debug_strs=None):

   492     initialized = 1

   493     for p in self.precondition_:

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

   495     if (self.has_puts_ and not self.puts_.IsInitialized(debug_strs)): initialized = 0

   496     if (self.has_deletes_ and not self.deletes_.IsInitialized(debug_strs)): initialized = 0

   497     return initialized

   498 

   499   def ByteSize(self):

   500     n = 0

   501     n += 2 * len(self.precondition_)

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

   503     if (self.has_puts_): n += 1 + self.lengthString(self.puts_.ByteSize())

   504     if (self.has_deletes_): n += 1 + self.lengthString(self.deletes_.ByteSize())

   505     return n + 0

   506 

   507   def Clear(self):

   508     self.clear_precondition()

   509     self.clear_puts()

   510     self.clear_deletes()

   511 

   512   def OutputUnchecked(self, out):

   513     for i in xrange(len(self.precondition_)):

   514       out.putVarInt32(11)

   515       self.precondition_[i].OutputUnchecked(out)

   516       out.putVarInt32(12)

   517     if (self.has_puts_):

   518       out.putVarInt32(34)

   519       out.putVarInt32(self.puts_.ByteSize())

   520       self.puts_.OutputUnchecked(out)

   521     if (self.has_deletes_):

   522       out.putVarInt32(42)

   523       out.putVarInt32(self.deletes_.ByteSize())

   524       self.deletes_.OutputUnchecked(out)

   525 

   526   def TryMerge(self, d):

   527     while d.avail() > 0:

   528       tt = d.getVarInt32()

   529       if tt == 11:

   530         self.add_precondition().TryMerge(d)

   531         continue

   532       if tt == 34:

   533         length = d.getVarInt32()

   534         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)

   535         d.skip(length)

   536         self.mutable_puts().TryMerge(tmp)

   537         continue

   538       if tt == 42:

   539         length = d.getVarInt32()

   540         tmp = ProtocolBuffer.Decoder(d.buffer(), d.pos(), d.pos() + length)

   541         d.skip(length)

   542         self.mutable_deletes().TryMerge(tmp)

   543         continue

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

   545       d.skipData(tt)

   546 

   547 

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

   549     res=""

   550     cnt=0

   551     for e in self.precondition_:

   552       elm=""

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

   554       res+=prefix+("Precondition%s {\n" % elm)

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

   556       res+=prefix+"}\n"

   557       cnt+=1

   558     if self.has_puts_:

   559       res+=prefix+"puts <\n"

   560       res+=self.puts_.__str__(prefix + "  ", printElemNumber)

   561       res+=prefix+">\n"

   562     if self.has_deletes_:

   563       res+=prefix+"deletes <\n"

   564       res+=self.deletes_.__str__(prefix + "  ", printElemNumber)

   565       res+=prefix+">\n"

   566     return res

   567 

   568   kPreconditionGroup = 1

   569   kPreconditionkey = 2

   570   kPreconditionhash = 3

   571   kputs = 4

   572   kdeletes = 5

   573 

   574   _TEXT = (

   575    "ErrorCode",

   576    "Precondition",

   577    "key",

   578    "hash",

   579    "puts",

   580    "deletes",

   581   )

   582 

   583   _TYPES = (

   584    ProtocolBuffer.Encoder.NUMERIC,

   585    ProtocolBuffer.Encoder.STARTGROUP,

   586 

   587    ProtocolBuffer.Encoder.STRING,

   588 

   589    ProtocolBuffer.Encoder.STRING,

   590 

   591    ProtocolBuffer.Encoder.STRING,

   592 

   593    ProtocolBuffer.Encoder.STRING,

   594 

   595   )

   596 

   597   _STYLE = """"""

   598   _STYLE_CONTENT_TYPE = """"""

   599 

   600 __all__ = ['Request','Response','TransactionRequest','TransactionRequest_Precondition']