Ejemplo n.º 1
0
  def test_simple(self):
    oid = self.createObject(RaleighSSet.TYPE)
    sset = RaleighSSet(self.client, oid)

    sset.insert('key-01', 'value-01')
    sset.insert('key-02', 'value-02')
    data = sset.get('key-01')
    self.assertEquals(data['value'], 'value-01')
    data = sset.get('key-02')
    self.assertEquals(data['value'], 'value-02')
    self.assertRaises(RaleighException, sset.get, 'key-03')

    data = sset.scan(2)
    self.assertEquals(data['keys'], ['key-01', 'key-02'])
    self.assertEquals(data['values'], ['value-01', 'value-02'])

    data = sset.pop('key-01')
    self.assertEquals(data['value'], 'value-01')
    self.assertRaises(RaleighException, sset.get, 'key-01')

    data = sset.scan(2)
    self.assertEquals(data['keys'], ['key-02'])
    self.assertEquals(data['values'], ['value-02'])

    data = sset.update('key-02', 'value-02b')
    self.assertEquals(data['old_value'], 'value-02')
    data = sset.get('key-02')
    self.assertEquals(data['value'], 'value-02b')
Ejemplo n.º 2
0
  def test_scanner(self):
    oid = self.createObject(RaleighSSet.TYPE)
    sset = RaleighSSet(self.client, oid)

    for i in xrange(10):
      sset.insert('key-%2d' % i, 'value-%2d' % i)

    for i, (key, value) in enumerate(sset.create_scanner()):
      self.assertEquals(key, 'key-%2d' % i)
      self.assertEquals(value, 'value-%2d' % i)
Ejemplo n.º 3
0
 def execute(self, client):
   sset = RaleighSSet(client, self.oid)
   nrequests = 0
   exception = None
   for i in xrange(self.NREQUESTS):
     x = randint(0, 9999999999)
     try:
       nrequests += 1
       sset.insert('Key-%010d' % x, 'Value-%010d' % x)
     except RaleighException as e:
       pass
     except Exception as e:
       exception = e
       break
   return nrequests, exception
Ejemplo n.º 4
0
  def test_txn_key_locked(self):
    oid = self.createObject(RaleighSSet.TYPE)
    sset = RaleighSSet(self.client, oid)

    txn_1 = RaleighTransaction(self.client)
    txn_1.begin()

    txn_2 = RaleighTransaction(self.client)
    txn_2.begin()

    sset.insert('key-01', 'value-01', txn_1.txn_id)
    self.assertRaises(RaleighException, sset.insert, 'key-01', 'value-02', txn_2.txn_id)

    txn_2.rollback()
    txn_1.commit()

    data = sset.get('key-01')
    self.assertEquals(data['value'], 'value-01')
Ejemplo n.º 5
0
  def test_txn_multi_obj(self):
      def _sset_get(sset, key, txn_id, expected):
        try:
          data = sset.get(key, txn_id)
          print sset, data
          assert data['value'] == expected, (data['value'] == expected)
        except Exception as e:
          print sset, e
          assert expected == None, expected

      oid_1 = self.createObject(RaleighSSet.TYPE)
      sset_1 = RaleighSSet(self.client, oid_1)

      oid_2 = self.createObject(RaleighSSet.TYPE)
      sset_2 = RaleighSSet(self.client, oid_2)

      key = 'key-01'
      value = 'value-01'

      # Test Rollback
      txn = RaleighTransaction(self.client)
      txn.begin()
      sset_1.insert(key, value, txn.txn_id)
      sset_2.insert(key, value, txn.txn_id)

      self.assertRaises(RaleighException, sset_1.get, key)
      self.assertRaises(RaleighException, sset_2.get, key)
      data = sset_1.get(key, txn.txn_id)
      self.assertEquals(data['value'], value)
      data = sset_2.get(key, txn.txn_id)
      self.assertEquals(data['value'], value)

      txn.rollback()

      self.assertRaises(RaleighException, sset_1.get, key)
      self.assertRaises(RaleighException, sset_2.get, key)

      # Test Commit
      txn = RaleighTransaction(self.client)
      txn.begin()
      sset_1.insert(key, value, txn.txn_id)
      sset_2.insert(key, value, txn.txn_id)
      self.assertRaises(RaleighException, sset_1.get, key)
      self.assertRaises(RaleighException, sset_2.get, key)
      data = sset_1.get(key, txn.txn_id)
      self.assertEquals(data['value'], value)
      data = sset_2.get(key, txn.txn_id)
      self.assertEquals(data['value'], value)
      txn.commit()

      data = sset_1.get(key)
      self.assertEquals(data['value'], value)
      data = sset_2.get(key)
      self.assertEquals(data['value'], value)
Ejemplo n.º 6
0
  def test_long_run(self):
    oid = self.createObject(RaleighSSet.TYPE)
    sset = RaleighSSet(self.client, oid)

    hkey = lambda x: sha1('%d' % x).hexdigest()
    hval = lambda x, v: sha1('%d-v%s' % (x, v)).hexdigest()
    NKEYS = (64 * 1024) / (20 + 40)
    VERIFY_MOD = 100

    class Data:
      def __init__(self):
        self.data = []
        self.rm_keys = set()

      def __len__(self):
        return len(self.data)

      def get(self, key):
        index = self._get_index(key)
        return index, self.data[index][1]

      def insert(self, key, value):
        insort(self.data, (key, value))

      def update(self, key, value):
        index = self._get_index(key)
        self.data[index] = (key, value)

      def remove(self, key):
        del self.data[self._get_index(key)]
        self.rm_keys.add(key)

      def is_removed(self, key):
        return key in self.rm_keys

      def _get_index(self, key):
        index = bisect_left(self.data, (key, None))
        if index != len(self.data) and self.data[index][0] == key:
          return index
        raise ValueError

    def _verify_sset_data(sset, test_data):
      for j in xrange(len(test_data)):
        key = hkey(j)
        if test_data.is_removed(key):
          self.assertRaises(RaleighException, sset.get, key)
        else:
          _, value = test_data.get(key)
          result = sset.get(key)
          self.assertEquals(result['value'], value)

      for j, (key, value) in enumerate(sset.create_scanner()):
        index, test_value = test_data.get(key)
        self.assertEquals(test_value, value)
        self.assertEquals(index, j)

    test_data = Data()

    # Insert and Verify
    for i in xrange(NKEYS):
      key, value = hkey(i), hval(i, 1)
      sset.insert(key, value)
      test_data.insert(key, value)
      if i % VERIFY_MOD == 0:
        _verify_sset_data(sset, test_data)
    _verify_sset_data(sset, test_data)

    # Update and Verify
    for i in xrange(0, NKEYS, 2):
      key, value = hkey(i), hval(i, 2)
      sset.update(key, value)
      test_data.update(key, value)
      if i % VERIFY_MOD == 0:
        _verify_sset_data(sset, test_data)
    _verify_sset_data(sset, test_data)

    # Delete and Verify
    for i in xrange(1, NKEYS, 2):
      key = hkey(i)
      sset.pop(key)
      test_data.remove(key)
      if i % VERIFY_MOD == 0:
        _verify_sset_data(sset, test_data)
    _verify_sset_data(sset, test_data)