def put(self, fh):
"""
Store some binary data in a Resource stored in Cassandra
"""
if not (hasattr(fh, 'read')):
data = fh
do = DataObject.create(data, compressed=radon.cfg.compress_do)
else:
chunk = fh.read(radon.cfg.chunk_size)
do = DataObject.create(chunk, compressed=radon.cfg.compress_do)
seq_num = 1
while True:
chunk = fh.read(radon.cfg.chunk_size)
if not chunk:
break
DataObject.append_chunk(do.uuid, seq_num, chunk,
radon.cfg.compress_do)
do.size += len(chunk)
seq_num += 1
self.obj = do
self.obj_id = do.uuid
self.url = do.get_url()
self.node.object_url = self.url
self.node.save()
return do
def test_update():
cfg.dse_keyspace = TEST_KEYSPACE
connect()
do = DataObject.create(TEST_CONTENT)
do.update(blob=TEST_CONTENT)
do = DataObject.find(do.uuid)
assert do.blob == TEST_CONTENT
do.delete()
def test_metadata():
coll_name = uuid.uuid4().hex
coll = Collection.create('/', coll_name)
myFactory = Faker()
content = myFactory.text()
chk = hashlib.sha224(content.encode()).hexdigest()
metadata = {"test": "val", "test_list": ['t', 'e', 's', 't']}
# Checksum passed at creation
do = DataObject.create(content.encode())
resc_name = uuid.uuid4().hex
resc = Resource.create(coll.path,
resc_name,
url="{}{}".format(cfg.protocol_cassandra, do.uuid),
metadata=metadata)
resc = Resource.find(resc.path)
meta_dict = resc.get_cdmi_user_meta()
assert meta_dict['test'] == metadata['test']
assert meta_dict['test_list'] == metadata['test_list']
sys_meta = resc.get_cdmi_sys_meta()
assert "radon_create_ts" in sys_meta
assert "radon_modify_ts" in sys_meta
resc.delete()
# Checksum passed at creation
do = DataObject.create(content.encode())
resc_name = uuid.uuid4().hex
resc = Resource.create(coll.path,
resc_name,
url="{}{}".format(cfg.protocol_cassandra, do.uuid),
mimetype="text/plain")
resc = Resource.find(resc.path)
assert resc.get_mimetype() == "text/plain"
resc.delete()
# Mimetype for a reference
resc = Resource.create(coll.path,
resc_name,
url="http://www.google.fr",
mimetype="text/plain")
resc = Resource.find(resc.path)
# Mimetype stored in the tree entry
assert resc.get_mimetype() == "text/plain"
resc.delete()
coll.delete()
def test_size():
coll_name = uuid.uuid4().hex
coll = Collection.create('/', coll_name)
myFactory = Faker()
content = myFactory.text()
chk = hashlib.sha224(content.encode()).hexdigest()
do = DataObject.create(content.encode())
resc_name = uuid.uuid4().hex
resc = Resource.create(coll.path,
resc_name,
url="{}{}".format(cfg.protocol_cassandra, do.uuid))
resc = Resource.find(resc.path)
assert resc.get_size() == len(content)
resc.obj = None
assert resc.get_size() == 0
resc.delete()
# Size for a reference
resc = Resource.create(coll.path,
resc_name,
url="http://www.google.fr",
mimetype="text/plain")
resc = Resource.find(resc.path)
# Size stored in the tree entry
assert resc.get_size() == 0
resc.delete()
coll.delete()
def test_dict():
coll_name = uuid.uuid4().hex
coll = Collection.create("/", coll_name)
myFactory = Faker()
content = myFactory.text()
# Read/Write resource stored in Cassandra
do = DataObject.create(content.encode())
resc_name = uuid.uuid4().hex
resc = Resource.create(coll.path,
resc_name,
url="{}{}".format(cfg.protocol_cassandra, do.uuid))
resc = Resource.find(resc.path)
resc_dict = resc.full_dict(User.find(USR1_NAME))
assert resc_dict['size'] == len(content)
assert resc_dict['can_read']
assert resc_dict['can_write']
assert resc_dict['uuid'] == resc.uuid
resc_dict = resc.simple_dict(User.find(USR1_NAME))
assert resc_dict['name'] == resc_name
assert resc_dict['is_reference'] == False
assert resc_dict['can_read']
assert resc_dict['can_write']
assert resc_dict['id'] == resc.uuid
assert resc.simple_dict() == resc.to_dict()
resc.delete()
coll.delete()
def test_chunk_content():
coll_name = uuid.uuid4().hex
coll = Collection.create("/", coll_name)
myFactory = Faker()
content = myFactory.text()
do = DataObject.create(content.encode())
resc_name = uuid.uuid4().hex
resc = Resource.create(coll.path,
resc_name,
url="{}{}".format(cfg.protocol_cassandra, do.uuid))
data = []
for chk in resc.chunk_content():
data.append(chk)
res = b"".join([s for s in data])
assert res == content.encode()
resc.obj = None
assert resc.chunk_content() == None
TEST_URL = "http://www.google.fr"
resc_name = uuid.uuid4().hex
resc = Resource.create(coll.path, resc_name, url=TEST_URL)
data = []
for chk in resc.chunk_content():
data.append(chk)
res = b"".join(data)
assert res
coll.delete()
def test_create():
do = DataObject.create(TEST_CONTENT)
data = []
for chk in do.chunk_content():
data.append(chk)
res = b"".join([s for s in data])
assert res == TEST_CONTENT
assert do.get_url() == cfg.protocol_cassandra + do.uuid
do.delete()
do = DataObject.create(TEST_CONTENT, compressed=True)
data = BytesIO(do.blob)
z = zipfile.ZipFile(data, "r")
content = z.read("data")
data.close()
z.close()
assert content == TEST_CONTENT
do.delete()
def __init__(self, node):
"""
Create the resource object based on the TreeNode row from Cassandra
:param node: The TreeNode row that corresponds to the resource
:type node: :class:`radon.model.TreeNode`
"""
Resource.__init__(self, node)
self.obj_id = self.url.replace(radon.cfg.protocol_cassandra, "")
self.obj = DataObject.find(self.obj_id)
def test_resource():
coll_name = uuid.uuid4().hex
with pytest.raises(NoSuchCollectionError):
resc = Resource.create("/{}".format(coll_name), uuid.uuid4().hex)
coll = Collection.create("/", coll_name)
do = create_data_object()
resc_name = uuid.uuid4().hex
resc = Resource.create(coll.path,
resc_name,
url="{}{}".format(cfg.protocol_cassandra, do.uuid))
assert str(resc) == resc.path
assert resc.get_name() == resc_name
with pytest.raises(ResourceConflictError):
resc = Resource.create(coll.path, resc_name)
resc.delete()
# Check resource is gone
resc = Resource.find(resc.path)
assert resc == None
do = create_data_object()
resc = Resource.create(coll.path,
resc_name,
url="{}{}".format(cfg.protocol_cassandra, do.uuid))
resc.delete()
resc = Resource.create(coll.path, resc_name, url="http://www.google.fr")
assert resc.get_name() == resc_name + '?'
resc.delete()
# Check deleting resource also deleted data object
do = DataObject.find(do.uuid)
assert do == None
do = create_data_object()
resc = Resource.create(coll.path,
resc_name,
url="{}{}".format(cfg.protocol_cassandra, do.uuid),
size=do.size)
assert resc.get_size() == do.size
resc.delete()
coll.delete()
def test_update():
coll_name = uuid.uuid4().hex
coll = Collection.create('/', coll_name)
myFactory = Faker()
content = myFactory.text()
chk = hashlib.sha224(content.encode()).hexdigest()
metadata = {"test": "val", "test_json": '["t", "e", "s", "t"]'}
# Simple update
do = DataObject.create(content.encode())
resc_name = uuid.uuid4().hex
resc = Resource.create(coll.path,
resc_name,
url="{}{}".format(cfg.protocol_cassandra, do.uuid))
resc.update(mimetype="text/plain")
resc = Resource.find(resc.path)
assert resc.get_mimetype() == "text/plain"
resc.delete()
# update with metadata and a username for notification
do = DataObject.create(content.encode())
resc_name = uuid.uuid4().hex
resc = Resource.create(coll.path,
resc_name,
url="{}{}".format(cfg.protocol_cassandra, do.uuid))
resc.update(username="******", metadata=metadata)
resc = Resource.find(resc.path)
assert resc.get_cdmi_user_meta()['test'] == metadata['test']
resc.delete()
# Update with a change of url (new dataObject)
do = DataObject.create(content.encode())
resc_name = uuid.uuid4().hex
resc = Resource.create(coll.path,
resc_name,
url="{}{}".format(cfg.protocol_cassandra, do.uuid))
DataObject.delete_id(do.uuid)
do = DataObject.create(content.encode())
resc.update(object_url="{}{}".format(cfg.protocol_cassandra, do.uuid))
resc = Resource.find(resc.path)
assert resc.get_size() == len(content)
resc.delete()
# Update for a reference
resc = Resource.create(coll.path, resc_name, url="http://www.google.fr")
resc.update(mimetype="text/plain")
resc = Resource.find(resc.path)
# Mimetype stored in the tree entry
assert resc.get_mimetype() == "text/plain"
resc.delete()
coll.delete()
def test_path():
coll_name = uuid.uuid4().hex
coll = Collection.create('/', coll_name)
myFactory = Faker()
content = myFactory.text()
chk = hashlib.sha224(content.encode()).hexdigest()
do = DataObject.create(content.encode())
resc_name = uuid.uuid4().hex
resc = Resource.create(coll.path,
resc_name,
url="{}{}".format(cfg.protocol_cassandra, do.uuid))
resc = Resource.find(resc.path)
assert resc.path == "{}{}".format(coll.path, resc_name)
assert resc.get_path() == "{}{}".format(coll.path, resc_name)
resc.delete()
coll.delete()
def test_user_can():
myFactory = Faker()
content = myFactory.text()
# Create a new resource with a random name
do = DataObject.create(content.encode())
resc_name = uuid.uuid4().hex
resc = Resource.create('/',
resc_name,
url="{}{}".format(cfg.protocol_cassandra, do.uuid))
usr1 = User.find(USR1_NAME)
usr2 = User.find(USR2_NAME)
# usr1 should be admin
assert resc.user_can(usr1, "read")
# usr2 should not be admin, on root collection, only read
assert resc.user_can(usr2, "read")
assert not resc.user_can(usr2, "write")
resc.delete()
def test_create_acl_fail(mocker):
list_read = [GRP1_NAME]
list_write = [GRP1_NAME]
myFactory = Faker()
content = myFactory.text()
# Create a new resource with a random name
do = DataObject.create(content.encode())
resc_name = uuid.uuid4().hex
resc = Resource.create('/',
resc_name,
url="{}{}".format(cfg.protocol_cassandra, do.uuid))
mocker.patch('radon.model.resource.acemask_to_str',
return_value="wrong_oper")
resc.create_acl_list(list_read, list_write)
resc = Resource.find('/{}'.format(resc_name))
# Test get_acl_list wrong operation name
acl_list = resc.get_acl_list()
assert acl_list == ([], [])
resc.delete()
def test_delete_id():
do = DataObject.create(TEST_CONTENT)
DataObject.delete_id(do.uuid)
do = DataObject.find(do.uuid)
assert do == None
def append_data_object(self, uuid, seq_num, raw_data):
"""Add a chunk of data in an existing data object"""
DataObject.append_chunk(uuid, raw_data, seq_num,
settings.COMPRESS_UPLOADS)
def test_acl():
list_read = [GRP1_NAME]
list_write = [GRP1_NAME]
coll_name = uuid.uuid4().hex
coll = Collection.create('/', coll_name)
myFactory = Faker()
content = myFactory.text()
# Read/Write resource stored in Cassandra
do = DataObject.create(content.encode())
resc_name = uuid.uuid4().hex
resc = Resource.create(coll.path,
resc_name,
url="{}{}".format(cfg.protocol_cassandra, do.uuid))
resc.create_acl_list(list_read, list_write)
resc = Resource.find(resc.path)
assert resc.get_acl_dict()[GRP1_NAME].acemask == 95 # read/write
assert resc.get_authorized_actions(
User.find(USR2_NAME)) == {'delete', 'read', 'edit', 'write'}
read_access, write_access = resc.get_acl_list()
assert read_access == [GRP1_NAME]
assert write_access == [GRP1_NAME]
cdmi_acl = resc.get_acl_metadata()
assert 'cdmi_acl' in cdmi_acl
cdmi_acl = [{
'identifier': GRP1_NAME,
'acetype': 'ALLOW',
'aceflags': "INHERITED",
'acemask': "READ"
}]
resc.update_acl_cdmi(cdmi_acl)
resc.delete()
# Read resource stored in Cassandra
do = DataObject.create(content.encode())
resc_name = uuid.uuid4().hex
resc = Resource.create(coll.path,
resc_name,
url="{}{}".format(cfg.protocol_cassandra, do.uuid))
resc.create_acl_list(list_read, [])
resc = Resource.find(resc.path)
assert resc.get_acl_dict()[GRP1_NAME].acemask == 9 # read
assert resc.get_authorized_actions(User.find(USR2_NAME)) == {'read'}
read_access, write_access = resc.get_acl_list()
assert read_access == [GRP1_NAME]
assert write_access == []
resc.delete()
# Write resource stored in Cassandra
do = DataObject.create(content.encode())
resc_name = uuid.uuid4().hex
resc = Resource.create(coll.path,
resc_name,
url="{}{}".format(cfg.protocol_cassandra, do.uuid))
resc.create_acl_list([], list_write)
resc = Resource.find(resc.path)
assert resc.get_acl_dict()[GRP1_NAME].acemask == 86 # write
assert resc.get_authorized_actions(
User.find(USR2_NAME)) == {'edit', 'delete', 'write'}
read_access, write_access = resc.get_acl_list()
assert read_access == []
assert write_access == [GRP1_NAME]
resc.delete()
# Resource stored in Cassandra, acl inherited from root
do = DataObject.create(content.encode())
resc_name = uuid.uuid4().hex
resc = Resource.create(coll.path,
resc_name,
url="{}{}".format(cfg.protocol_cassandra, do.uuid))
assert resc.get_authorized_actions(User.find(USR2_NAME)) == {"read"}
resc.delete()
# Read/Write resource stored as a reference
resc_name = uuid.uuid4().hex
resc = Resource.create(coll.path, resc_name, url="http://www.google.fr")
resc.create_acl_list(list_read, list_write)
resc = Resource.find(resc.path)
assert resc.get_acl_dict()[GRP1_NAME].acemask == 95
assert resc.get_authorized_actions(
User.find(USR2_NAME)) == {'delete', 'read', 'edit', 'write'}
resc.delete()
coll.delete()
def delete_data_objects(self):
"""
Delete all blobs of the corresponding uuid
"""
DataObject.delete_id(self.obj_id)
def create_empty_data_object(self):
"""Create an entry for a data object in the system"""
data_object = DataObject.create(None)
return data_object.uuid
def create_data_object():
myFactory = Faker()
content = myFactory.text()
do = DataObject.create(content.encode())
return do
def test_append():
do = DataObject.create(TEST_CONTENT1)
DataObject.append_chunk(do.uuid, 1, TEST_CONTENT2)
DataObject.append_chunk(do.uuid, 2, TEST_CONTENT3)
DataObject.append_chunk(do.uuid, 3, TEST_CONTENT4)
do = DataObject.find(do.uuid)
data = []
for chk in do.chunk_content():
data.append(chk)
assert b"".join(data) == b'This is a test.'
DataObject.delete_id(do.uuid)
do = DataObject.create(TEST_CONTENT1, compressed=True)
DataObject.append_chunk(do.uuid, 1, TEST_CONTENT2, True)
DataObject.append_chunk(do.uuid, 2, TEST_CONTENT3, True)
DataObject.append_chunk(do.uuid, 3, TEST_CONTENT4, True)
do = DataObject.find(do.uuid)
data = []
for chk in do.chunk_content():
data.append(chk)
assert b"".join(data) == b'This is a test.'
DataObject.delete_id(do.uuid)
def create_data_object(self, raw_data):
"""Put a new resource"""
data_object = DataObject.create(raw_data, settings.COMPRESS_UPLOADS)
return data_object.uuid
