def get_range_slices(self,
column_family=None,
start='',
finish='',
column_start='',
column_finish='',
names=None,
count=100,
column_count=100,
reverse=False,
use_tokens=False,
consistency=None,
super_column=None,
retries=None):
cp = self._getparent(column_family, super_column)
consistency = consistency or self.consistency
if not use_tokens:
krange = KeyRange(start_key=start, end_key=finish, count=count)
else:
krange = KeyRange(start_token=start, end_token=finish, count=count)
pred = self._mkpred(names, column_start, column_finish, reverse,
column_count)
req = ManagedThriftRequest('get_range_slices', cp, pred, krange,
consistency)
return self.manager.pushRequest(req, retries=retries)
def system_rename_column_family(self, oldname, newname, retries=None,
block=True):
if block:
self._wait_for_schema_agreement()
req = ManagedThriftRequest(
'system_rename_column_family', oldname, newname)
return self._push_system_request(req, retries=retries, block=block)
def batch_remove(self,
cfmap=None,
start='',
finish='',
count=100,
names=None,
reverse=False,
consistency=None,
timestamp=None,
supercolumn=None,
retries=None,
atomic=False):
timestamp = timestamp or self._time()
consistency = consistency or self.consistency
mutmap = defaultdict(dict)
for cf, keys in cfmap.iteritems():
pred = self._mkpred(names, start, finish, reverse, count)
for key in keys:
mutmap[key][cf] = [
ttypes.Mutation(
deletion=ttypes.Deletion(timestamp, supercolumn, pred))
]
method = 'atomic_batch_mutate' if atomic else 'batch_mutate'
req = ManagedThriftRequest(method, mutmap, consistency)
return self.manager.pushRequest(req, retries=retries)
def add(self, key=None, column_family=None, value=None, column=None,
super_column=None, consistency=None, retries=None):
cp = self._getparent(column_family, super_column)
consistency = consistency or self.consistency
req = ManagedThriftRequest(
'add', key, cp, ttypes.CounterColumn(column, value), consistency)
return self.manager.pushRequest(req, retries=retries)
def set_keyspace(self, keyspace):
"""
Change the keyspace which will be used for subsequent requests to this
CassandraClusterPool, and return a Deferred that will fire once it can
be verified that connections can successfully use that keyspace.
If something goes wrong trying to change a connection to that keyspace,
the Deferred will errback, and the keyspace to be used for future
requests will not be changed.
Requests made between the time this method is called and the time that
the returned Deferred is fired may be made in either the previous
keyspace or the new keyspace. If you may need to make use of multiple
keyspaces at the same time in the same app, consider using the
specialized CassandraKeyspaceConnection interface provided by the
keyspaceConnection method.
"""
# push a real set_keyspace on some (any) connection; the idea is that
# if it succeeds there, it is likely to succeed everywhere, and vice
# versa. don't bother waiting for all connections to change- some of
# them may be doing long blocking tasks and by the time they're done,
# the keyspace might be changed again anyway
d = self.pushRequest(ManagedThriftRequest('set_keyspace', keyspace))
def store_keyspace(_):
self.keyspace = keyspace
d.addCallback(store_keyspace)
return d
def batch_mutate(self,
mutationmap=None,
timestamp=None,
consistency=None,
retries=None,
ttl=None):
timestamp = timestamp or self._time()
consistency = consistency or self.consistency
mutmap = defaultdict(dict)
for key, cfmap in mutationmap.iteritems():
for cf, colmap in cfmap.iteritems():
cols_or_supers_or_deletions = self._mk_cols_or_supers(
colmap, timestamp, ttl, make_deletions=True)
muts = []
for c in cols_or_supers_or_deletions:
if isinstance(c, SuperColumn):
muts.append(
Mutation(ColumnOrSuperColumn(super_column=c)))
elif isinstance(c, Column):
muts.append(Mutation(ColumnOrSuperColumn(column=c)))
elif isinstance(c, Deletion):
muts.append(Mutation(deletion=c))
else:
muts.append(c)
mutmap[key][cf] = muts
req = ManagedThriftRequest('batch_mutate', mutmap, consistency)
return self.manager.pushRequest(req, retries=retries)
def get_count(self, key=None, column_family=None, super_column=None,
start='', finish='', consistency=None, retries=None):
cp = self._getparent(column_family, super_column)
pred = self._mkpred(None, start, finish, False, 2147483647)
consistency = consistency or self.consistency
req = ManagedThriftRequest('get_count', key, cp, pred, consistency)
return self.manager.pushRequest(req, retries=retries)
def system_rename_keyspace(self,
oldname,
newname,
retries=None,
block=True):
req = ManagedThriftRequest('system_rename_keyspace', oldname,
newname)
return self._push_system_request(req, retries=retries, block=block)
def get_slice(self, key=None, column_family=None, names=None, start='',
finish='', reverse=False, count=100, consistency=None,
super_column=None, retries=None):
cp = self._getparent(column_family, super_column)
consistency = consistency or self.consistency
pred = self._mkpred(names, start, finish, reverse, count)
req = ManagedThriftRequest('get_slice', key, cp, pred, consistency)
return self.manager.pushRequest(req, retries=retries)
def remove(self, key=None, column_family=None, column=None,
super_column=None, timestamp=None, consistency=None,
retries=None):
cp = self._getpath(column_family, column, super_column)
timestamp = timestamp or self._time()
consistency = consistency or self.consistency
req = ManagedThriftRequest('remove', key, cp, timestamp, consistency)
return self.manager.pushRequest(req, retries=retries)
def describe_splits(self,
cfName,
start_token,
end_token,
keys_per_split,
retries=None):
req = ManagedThriftRequest('describe_splits', cfName, start_token,
end_token, keys_per_split)
return self.manager.pushRequest(req, retries=retries)
def insert(self, key=None, column_family=None, value=None, column=None,
super_column=None, timestamp=None, consistency=None,
retries=None, ttl=None):
timestamp = timestamp or self._time()
cp = self._getparent(column_family, super_column)
consistency = consistency or self.consistency
req = ManagedThriftRequest(
'insert', key, cp, ttypes.Column(column, value, timestamp, ttl),
consistency)
return self.manager.pushRequest(req, retries=retries)
def get(self,
key=None,
column_family=None,
column=None,
super_column=None,
consistency=None,
retries=None):
cp = self._getpath(column_family, column, super_column)
consistency = consistency or self.consistency
req = ManagedThriftRequest('get', key, cp, consistency)
return self.manager.pushRequest(req, retries=retries)
def get_indexed_slices(self, column_family=None, expressions=None,
start_key='', column_start='', column_finish='',
names=None, count=100, column_count=100,
reverse=False, consistency=None, super_column=None,
retries=None):
idx_clause = ttypes.IndexClause(expressions, start_key, count)
cp = self._getparent(column_family, super_column)
consistency = consistency or self.consistency
pred = self._mkpred(
names, column_start, column_finish, reverse, column_count)
req = ManagedThriftRequest(
'get_indexed_slices', cp, idx_clause, pred, consistency)
return self.manager.pushRequest(req, retries=retries)
def my_describe_ring(self, keyspace=None):
if keyspace is None or keyspace == 'system':
d = self.my_pick_non_system_keyspace()
else:
d = defer.succeed(keyspace)
d.addCallback(
lambda k: self.execute(ManagedThriftRequest('describe_ring', k)))
def suppress_no_keyspaces_error(f):
f.trap(NoKeyspacesAvailable)
return ()
d.addErrback(suppress_no_keyspaces_error)
return d
def my_describe_ring(self, keyspace=None):
if keyspace is None or keyspace in SYSTEM_KEYSPACES:
d = self.my_pick_non_system_keyspace()
else:
d = defer.succeed(keyspace)
if not self.describe_lock.get_lock():
self.describe_lock.set_lock(d)
d.addCallback(lambda k: self.execute(
ManagedThriftRequest('describe_ring', k)))
def suppress_no_keyspaces_error(f):
f.trap(NoKeyspacesAvailable)
return ()
d.addCallback(self.done_describing)
d.addErrback(self.done_describing_err)
d.addErrback(suppress_no_keyspaces_error)
else:
d = self.describe_lock.get_lock()
return d
def system_update_column_family(self, cfDef, retries=None, block=True):
req = ManagedThriftRequest('system_update_column_family', cfDef)
return self._push_system_request(req, retries=retries, block=block)
def my_login(self, creds):
return self.execute(
ManagedThriftRequest('login',
AuthenticationRequest(credentials=creds)))
def my_set_keyspace(self, keyspace):
return self.execute(ManagedThriftRequest('set_keyspace', keyspace))
def describe_ring(self, keyspace, retries=None):
req = ManagedThriftRequest('describe_ring', keyspace)
return self.manager.pushRequest(req, retries=retries)
def describe_snitch(self, retries=None):
req = ManagedThriftRequest('describe_snitch')
return self.manager.pushRequest(req, retries=retries)
def system_update_keyspace(self, ksDef, retries=None, block=True):
req = ManagedThriftRequest('system_update_keyspace', ksDef)
return self._push_system_request(req, retries=retries, block=block)
def describe_version(self, retries=None):
req = ManagedThriftRequest('describe_version')
return self.manager.pushRequest(req, retries=retries)
def describe_partitioner(self, retries=None):
req = ManagedThriftRequest('describe_partitioner')
return self.manager.pushRequest(req, retries=retries)
def my_describe_version(self):
return self.execute(ManagedThriftRequest('describe_version'))
def system_drop_keyspace(self, keyspace, retries=None, block=True):
req = ManagedThriftRequest('system_drop_keyspace', keyspace)
return self._push_system_request(req, retries=retries, block=block)
def system_drop_column_family(self, cfName, retries=None, block=True):
req = ManagedThriftRequest('system_drop_column_family', cfName)
return self._push_system_request(req, retries=retries, block=block)
def truncate(self, cfName, retries=None):
req = ManagedThriftRequest('truncate', cfName)
return self.manager.pushRequest(req, retries=retries)
def my_describe_keyspaces(self):
return self.execute(ManagedThriftRequest('describe_keyspaces'))
def describe_cluster_name(self, retries=None):
req = ManagedThriftRequest('describe_cluster_name')
return self.manager.pushRequest(req, retries=retries)
