#!/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"""

from google.appengine.datastore.datastore_v3_pb import *

class TaskQueueServiceError(ProtocolBuffer.ProtocolMessage):

  OK           =    0

  UNKNOWN_QUEUE =    1

  TRANSIENT_ERROR =    2

  INTERNAL_ERROR =    3

  TASK_TOO_LARGE =    4

  INVALID_TASK_NAME =    5

  INVALID_QUEUE_NAME =    6

  INVALID_URL  =    7

  INVALID_QUEUE_RATE =    8

  PERMISSION_DENIED =    9

  TASK_ALREADY_EXISTS =   10

  TOMBSTONED_TASK =   11

  INVALID_ETA  =   12

  INVALID_REQUEST =   13

  UNKNOWN_TASK =   14

  DATASTORE_ERROR = 10000

  _ErrorCode_NAMES = {

    0: "OK",

    1: "UNKNOWN_QUEUE",

    2: "TRANSIENT_ERROR",

    3: "INTERNAL_ERROR",

    4: "TASK_TOO_LARGE",

    5: "INVALID_TASK_NAME",

    6: "INVALID_QUEUE_NAME",

    7: "INVALID_URL",

    8: "INVALID_QUEUE_RATE",

    9: "PERMISSION_DENIED",

    10: "TASK_ALREADY_EXISTS",

    11: "TOMBSTONED_TASK",

    12: "INVALID_ETA",

    13: "INVALID_REQUEST",

    14: "UNKNOWN_TASK",

    10000: "DATASTORE_ERROR",

  }

  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 + 0

  def Clear(self):

    pass

  def OutputUnchecked(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 = """"""

class TaskQueueAddRequest_Header(ProtocolBuffer.ProtocolMessage):

  has_key_ = 0

  key_ = ""

  has_value_ = 0

  value_ = ""

  def __init__(self, contents=None):

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

  def key(self): return self.key_

  def set_key(self, x):

    self.has_key_ = 1

    self.key_ = x

  def clear_key(self):

    if self.has_key_:

      self.has_key_ = 0

      self.key_ = ""

  def has_key(self): return self.has_key_

  def value(self): return self.value_

  def set_value(self, x):

    self.has_value_ = 1

    self.value_ = x

  def clear_value(self):

    if self.has_value_:

      self.has_value_ = 0

      self.value_ = ""

  def has_value(self): return self.has_value_

  def MergeFrom(self, x):

    assert x is not self

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

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

  def Equals(self, x):

    if x is self: return 1

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

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

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

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

    return 1

  def IsInitialized(self, debug_strs=None):

    initialized = 1

    if (not self.has_key_):

      initialized = 0

      if debug_strs is not None:

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

    if (not self.has_value_):

      initialized = 0

      if debug_strs is not None:

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

    return initialized

  def ByteSize(self):

    n = 0

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

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

    return n + 2

  def Clear(self):

    self.clear_key()

    self.clear_value()

  def OutputUnchecked(self, out):

    out.putVarInt32(58)

    out.putPrefixedString(self.key_)

    out.putVarInt32(66)

    out.putPrefixedString(self.value_)

  def TryMerge(self, d):

    while 1:

      tt = d.getVarInt32()

      if tt == 52: break

      if tt == 58:

        self.set_key(d.getPrefixedString())

        continue

      if tt == 66:

        self.set_value(d.getPrefixedString())

        continue

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

      d.skipData(tt)

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

    res=""

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

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

    return res

class TaskQueueAddRequest(ProtocolBuffer.ProtocolMessage):

  GET          =    1

  POST         =    2

  HEAD         =    3

  PUT          =    4

  DELETE       =    5

  _RequestMethod_NAMES = {

    1: "GET",

    2: "POST",

    3: "HEAD",

    4: "PUT",

    5: "DELETE",

  }

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

  RequestMethod_Name = classmethod(RequestMethod_Name)

  has_queue_name_ = 0

  queue_name_ = ""

  has_task_name_ = 0

  task_name_ = ""

  has_eta_usec_ = 0

  eta_usec_ = 0

  has_method_ = 0

  method_ = 2

  has_url_ = 0

  url_ = ""

  has_body_ = 0

  body_ = ""

  has_transaction_ = 0

  transaction_ = None

  def __init__(self, contents=None):

    self.header_ = []

    self.lazy_init_lock_ = thread.allocate_lock()

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

  def queue_name(self): return self.queue_name_

  def set_queue_name(self, x):

    self.has_queue_name_ = 1

    self.queue_name_ = x

  def clear_queue_name(self):

    if self.has_queue_name_:

      self.has_queue_name_ = 0

      self.queue_name_ = ""

  def has_queue_name(self): return self.has_queue_name_

  def task_name(self): return self.task_name_

  def set_task_name(self, x):

    self.has_task_name_ = 1

    self.task_name_ = x

  def clear_task_name(self):

    if self.has_task_name_:

      self.has_task_name_ = 0

      self.task_name_ = ""

  def has_task_name(self): return self.has_task_name_

  def eta_usec(self): return self.eta_usec_

  def set_eta_usec(self, x):

    self.has_eta_usec_ = 1

    self.eta_usec_ = x

  def clear_eta_usec(self):

    if self.has_eta_usec_:

      self.has_eta_usec_ = 0

      self.eta_usec_ = 0

  def has_eta_usec(self): return self.has_eta_usec_

  def method(self): return self.method_

  def set_method(self, x):

    self.has_method_ = 1

    self.method_ = x

  def clear_method(self):

    if self.has_method_:

      self.has_method_ = 0

      self.method_ = 2

  def has_method(self): return self.has_method_

  def url(self): return self.url_

  def set_url(self, x):

    self.has_url_ = 1

    self.url_ = x

  def clear_url(self):

    if self.has_url_:

      self.has_url_ = 0

      self.url_ = ""

  def has_url(self): return self.has_url_

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

  def header_list(self): return self.header_

  def header(self, i):

    return self.header_[i]

  def mutable_header(self, i):

    return self.header_[i]

  def add_header(self):

    x = TaskQueueAddRequest_Header()

    self.header_.append(x)

    return x

  def clear_header(self):

    self.header_ = []

  def body(self): return self.body_

  def set_body(self, x):

    self.has_body_ = 1

    self.body_ = x

  def clear_body(self):

    if self.has_body_:

      self.has_body_ = 0

      self.body_ = ""

  def has_body(self): return self.has_body_

  def transaction(self):

    if self.transaction_ is None:

      self.lazy_init_lock_.acquire()

      try:

        if self.transaction_ is None: self.transaction_ = Transaction()

      finally:

        self.lazy_init_lock_.release()

    return self.transaction_

  def mutable_transaction(self): self.has_transaction_ = 1; return self.transaction()

  def clear_transaction(self):

    if self.has_transaction_:

      self.has_transaction_ = 0;

      if self.transaction_ is not None: self.transaction_.Clear()

  def has_transaction(self): return self.has_transaction_

  def MergeFrom(self, x):

    assert x is not self

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

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

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

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

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

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

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

    if (x.has_transaction()): self.mutable_transaction().MergeFrom(x.transaction())

  def Equals(self, x):

    if x is self: return 1

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

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

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

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

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

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

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

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

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

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

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

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

      if e1 != e2: return 0

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

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

    if self.has_transaction_ != x.has_transaction_: return 0

    if self.has_transaction_ and self.transaction_ != x.transaction_: return 0

    return 1

  def IsInitialized(self, debug_strs=None):

    initialized = 1

    if (not self.has_queue_name_):

      initialized = 0

      if debug_strs is not None:

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

    if (not self.has_task_name_):

      initialized = 0

      if debug_strs is not None:

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

    if (not self.has_eta_usec_):

      initialized = 0

      if debug_strs is not None:

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

    if (not self.has_url_):

      initialized = 0

      if debug_strs is not None:

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

    for p in self.header_:

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

    if (self.has_transaction_ and not self.transaction_.IsInitialized(debug_strs)): initialized = 0

    return initialized

  def ByteSize(self):

    n = 0

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

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

    n += self.lengthVarInt64(self.eta_usec_)

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

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

    n += 2 * len(self.header_)

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

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

    if (self.has_transaction_): n += 1 + self.lengthString(self.transaction_.ByteSize())

    return n + 4

  def Clear(self):

    self.clear_queue_name()

    self.clear_task_name()

    self.clear_eta_usec()

    self.clear_method()

    self.clear_url()

    self.clear_header()

    self.clear_body()

    self.clear_transaction()

  def OutputUnchecked(self, out):

    out.putVarInt32(10)

    out.putPrefixedString(self.queue_name_)

    out.putVarInt32(18)

    out.putPrefixedString(self.task_name_)

    out.putVarInt32(24)

    out.putVarInt64(self.eta_usec_)

    out.putVarInt32(34)

    out.putPrefixedString(self.url_)

    if (self.has_method_):

      out.putVarInt32(40)

      out.putVarInt32(self.method_)

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

      out.putVarInt32(51)

      self.header_[i].OutputUnchecked(out)

      out.putVarInt32(52)

    if (self.has_body_):

      out.putVarInt32(74)

      out.putPrefixedString(self.body_)

    if (self.has_transaction_):

      out.putVarInt32(82)

      out.putVarInt32(self.transaction_.ByteSize())

      self.transaction_.OutputUnchecked(out)

  def TryMerge(self, d):

    while d.avail() > 0:

      tt = d.getVarInt32()

      if tt == 10:

        self.set_queue_name(d.getPrefixedString())

        continue

      if tt == 18:

        self.set_task_name(d.getPrefixedString())

        continue

      if tt == 24:

        self.set_eta_usec(d.getVarInt64())

        continue

      if tt == 34:

        self.set_url(d.getPrefixedString())

        continue

      if tt == 40:

        self.set_method(d.getVarInt32())

        continue

      if tt == 51:

        self.add_header().TryMerge(d)

        continue

      if tt == 74:

        self.set_body(d.getPrefixedString())

        continue

      if tt == 82:

        length = d.getVarInt32()

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

        d.skip(length)

        self.mutable_transaction().TryMerge(tmp)

        continue

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

      d.skipData(tt)

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

    res=""

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

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

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

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

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

    cnt=0

    for e in self.header_:

      elm=""

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

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

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

      res+=prefix+"}\n"

      cnt+=1

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

    if self.has_transaction_:

      res+=prefix+"transaction <\n"

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