Python Connection.add方法代码示例

# 需要导入模块: from connection import Connection [as 别名]
# 或者: from connection.Connection import add [as 别名]
class TestBinaryProtocol(unittest.TestCase):
    def setUp(self):
        servers = [("127.0.0.1",11211)]
        self.connection = Connection()
        self.connection.add_servers(servers)
    
    def test_delete_exception(self):
        self.assertRaises(ProtocolException, self.connection.delete, key="Hello")
    
    def test_add(self):
        self.assertTrue(self.connection.add("Hello", "World"))
        
    def test_get(self):
        self.assertTrue(self.connection.get("Hello"))
    
    def test_add_exception(self):
        self.assertRaises(ProtocolException, self.connection.add, key="Hello", value="World")
        
        
    def testAddUnicode(self):
        self.connection.add("Hello", u"łóść")
        
    def test_delete(self):
        self.assertTrue(self.connection.delete(key="Hello"))

# 需要导入模块: from connection import Connection [as 别名]
# 或者: from connection.Connection import add [as 别名]
def connection():
  from connection import Connection
  from session import Session
  from link import Sender, Receiver, link
  from protocol import Fragment, Linkage

  a = Connection(lambda n: Session(n, link))
  b = Connection(lambda n: Session(n, link))
  a.id = "A"
  a.tracing = set(["ops", "err"])
  b.id = "B"
  b.tracing = set(["ops", "err"])

  def pump():
    while a.pending() or b.pending():
      b.write(a.read())
      a.write(b.read())

  s = Session("test-ssn", link)
  a.add(s)
  s2 = Session("test-ssn2", link)
  a.add(s2)

  a.open(hostname="asdf")
  b.open()
  s.begin()
  s2.begin()
  l = Sender("qwer", local=Linkage("S", "T"))
  s.add(l)
  l.attach()

  pump()

  bssn = [x for x in b.incoming.values() if x.name == "test-ssn"][0]
  bssn.begin()
  bl = bssn.links["qwer"]
  bl.attach()
  bl.flow(10)

  pump()

  l.settle(l.send(fragments=Fragment(True, True, 0, 0, "asdf")))
  tag = l.send(delivery_tag="blah", fragments=Fragment(True, True, 0, 0, "asdf"))

  pump()

  ln = bssn.links["qwer"]
  x = ln.get()
  print "INCOMING XFR:", x
  ln.disposition(x.delivery_tag, "ACCEPTED")

  xfr = ln.get()
  print "INCOMING XFR:", xfr
  ln.disposition(xfr.delivery_tag, "ASDF")

  print "--"

  pump()

  print "--"

  print "DISPOSITION", l.get_remote(modified=True)
  l.settle(tag)

  l.detach()
  bl.detach()

  pump()

  s.end(True)
  pump()
  bssn.end(True)
  s2.end(True)
  a.close()
  b.close()

  pump()

# 需要导入模块: from connection import Connection [as 别名]
# 或者: from connection.Connection import add [as 别名]
def session():
  from connection import Connection
  from session import Session
  from link import link, Sender, Receiver
  from protocol import Fragment, Linkage

  a = Connection(lambda n: Session(n, link))
  a.tracing = set(["ops", "err"])
  a.id = "A"
  b = Connection(lambda n: Session(n, link))
  b.tracing = set(["err"])
  b.id = "B"
  ssn = Session("test", link)
  a.add(ssn)
  ssn.begin()
#  nss = Session("test", link)
#  b.add(nss)

  def pump():
    a.tick()
    b.tick()
    b.write(a.read())
    a.write(b.read())

  pump()

  nss = [s for s in b.incoming.values() if s.name == "test"][0]
  nss.begin()

  snd = Sender("L", "S", "T")
  ssn.add(snd)
  rcv = Receiver("L", "S", "T")
  nss.add(rcv)

  snd.attach()
  rcv.attach()
  rcv.flow(10)

  pump()

  snd.send(fragments=Fragment(True, True, 0, 0, "m1"))
  snd.send(fragments=Fragment(True, True, 0, 0, "m2"))
  dt3 = snd.send(fragments=Fragment(True, True, 0, 0, "m3"))

  pump()

  print "PENDING", rcv.pending()

  pump()

  snd.send(fragments=Fragment(True, True, 0, 0, "m4"))

  pump()

  xfrs = []
  while rcv.pending():
    x = rcv.get()
    xfrs.append(x)
    print "XFR", x

  rcv.disposition(xfrs[-1].delivery_tag, "ACCEPTED")

  pump()

  snd.send(fragments=Fragment(True, True, 0, 0, "m5"))

  pump()

  rcv.disposition(xfrs[0].delivery_tag, "ACCEPTED")

  print "----------"
  pump()
  print "----------"

  print "ssn.outgoing:", ssn.outgoing
  print "snd.unsettled:", snd.unsettled
  for xfr in xfrs[1:-1]:
    rcv.disposition(xfr.delivery_tag, "ACCEPTED")
  print "rcv.unsettled", rcv.unsettled
  print "rcv.pending()", rcv.pending()
  rcv.disposition(rcv.get().delivery_tag)

  pump()
  print "----------"

  print "ssn.outgoing:", ssn.outgoing
  print "snd.unsettled:", snd.unsettled

  print "settling:", dt3
  snd.settle(dt3)

  print "ssn.outgoing:", ssn.outgoing
  print "snd.unsettled:", snd.unsettled

  for dt in list(snd.unsettled):
    snd.settle(dt)

  snd.detach()
  rcv.detach()

#.........这里部分代码省略.........

# 需要导入模块: from connection import Connection [as 别名]
# 或者: from connection.Connection import add [as 别名]
class Connection:

  def __init__(self, auth=False):
    self.proto = ProtoConnection(self.session)
    self.auth = auth
    if self.auth:
      self.sasl = SASL(self.proto)
    else:
      self.sasl = self.proto
    self._lock = RLock()
    self.condition = Condition(self._lock)
    self.waiter = Waiter(self.condition)
    self.selector = Selector.default()
    self.timeout = 120

  def tracing(self, *args, **kwargs):
    self.proto.tracing(*args, **kwargs)
    self.sasl.tracing(*args, **kwargs)

  def trace(self, *args, **kwargs):
    self.proto.trace(*args, **kwargs)

  @synchronized
  def connect(self, host, port):
    sock = socket.socket()
    sock.connect((host, port))
    sock.setblocking(0)
    self.selector.register(ConnectionSelectable(sock, self, self.tick))

  @synchronized
  def pending(self):
    return self.sasl.pending()

  @synchronized
  def peek(self, n=None):
    return self.sasl.peek(n)

  @synchronized
  def read(self, n=None):
    return self.sasl.read(n)

  @synchronized
  def write(self, bytes):
    self.sasl.write(bytes)

  @synchronized
  def closed(self):
    self.sasl.closed()

  @synchronized
  def error(self, exc):
    self.sasl.error(exc)

  @synchronized
  def tick(self, connection):
    self.proto.tick()
    self.sasl.tick()
    self.waiter.notify()

  @synchronized
  def open(self, **kwargs):
    if not kwargs.get("container_id"):
      kwargs["container_id"] = str(uuid4())
    if "channel_max" not in kwargs:
      kwargs["channel_max"] = 65535
    mechanism = kwargs.pop("mechanism", "ANONYMOUS")
    username = kwargs.pop("username", None)
    password = kwargs.pop("password", None)
    if self.auth:
      self.sasl.client(mechanism=mechanism, username=username,
                       password=password)
    self.proto.open(**kwargs)
    if self.auth:
      self.wait(lambda: self.sasl.outcome is not None)
      if self.sasl.outcome != 0:
        raise Exception("authentication failed: %s" % self.sasl.outcome)

  def wait(self, predicate, timeout=DEFAULT):
    if timeout is DEFAULT:
      timeout = self.timeout
    self.selector.wakeup()
    if not self.waiter.wait(predicate, timeout):
      raise Timeout()

  @synchronized
  def session(self):
    ssn = Session(self)
    self.proto.add(ssn.proto)
    return ssn

  @synchronized
  def close(self):
    self.proto.close()
    self.wait(lambda: self.proto.close_rcvd)