def _process_service_descriptors(self, service_descriptors, metadata,
account):
brizo = BrizoProvider.get_brizo()
ddo_service_endpoint = self._get_aquarius().get_service_endpoint()
service_type_to_descriptor = {sd[0]: sd for sd in service_descriptors}
_service_descriptors = []
metadata_service_desc = service_type_to_descriptor.pop(
ServiceTypes.METADATA,
ServiceDescriptor.metadata_service_descriptor(
metadata, ddo_service_endpoint))
auth_service_desc = service_type_to_descriptor.pop(
ServiceTypes.AUTHORIZATION,
ServiceDescriptor.authorization_service_descriptor(
self._config.secret_store_url))
_service_descriptors = [metadata_service_desc, auth_service_desc]
# Always dafault to creating a ServiceTypes.ASSET_ACCESS service if no services are specified
access_service_descriptor = service_type_to_descriptor.pop(
ServiceTypes.ASSET_ACCESS,
ServiceDescriptor.access_service_descriptor(
self._build_access_service(metadata, account),
brizo.get_consume_endpoint(self._config),
self._keeper.escrow_access_secretstore_template.address))
compute_service_descriptor = service_type_to_descriptor.pop(
ServiceTypes.CLOUD_COMPUTE, None)
if access_service_descriptor:
_service_descriptors.append(access_service_descriptor)
if compute_service_descriptor:
_service_descriptors.append(compute_service_descriptor)
_service_descriptors.extend(service_type_to_descriptor.values())
return ServiceFactory.build_services(_service_descriptors)
def _process_service_descriptors(self, service_descriptors: list,
metadata: dict, provider_uri: str,
wallet: Wallet) -> list:
ddo_service_endpoint = self._get_aquarius().get_service_endpoint()
service_type_to_descriptor = {sd[0]: sd for sd in service_descriptors}
_service_descriptors = []
metadata_service_desc = service_type_to_descriptor.pop(
ServiceTypes.METADATA,
ServiceDescriptor.metadata_service_descriptor(
metadata, ddo_service_endpoint))
_service_descriptors = [
metadata_service_desc,
]
# Always dafault to creating a ServiceTypes.ASSET_ACCESS service if no services are specified
access_service_descriptor = service_type_to_descriptor.pop(
ServiceTypes.ASSET_ACCESS, None)
compute_service_descriptor = service_type_to_descriptor.pop(
ServiceTypes.CLOUD_COMPUTE, None)
# Make an access service only if no services are given by the user.
if not access_service_descriptor and not compute_service_descriptor:
access_service_descriptor = ServiceDescriptor.access_service_descriptor(
self._build_access_service(metadata, 1.0, wallet.address),
self._data_provider.get_url(self._config))
if access_service_descriptor:
_service_descriptors.append(access_service_descriptor)
if compute_service_descriptor:
_service_descriptors.append(compute_service_descriptor)
_service_descriptors.extend(service_type_to_descriptor.values())
return ServiceFactory.build_services(_service_descriptors)
def test_service_factory():
ddo = DDO(dictionary=_get_sample_ddo('ddo_sample1.json'))
type_to_service = {s.type: s for s in ddo.services}
metadata = ddo.metadata
md_descriptor = ServiceDescriptor.metadata_service_descriptor(metadata, type_to_service[ServiceTypes.METADATA].service_endpoint)
access_service = type_to_service[ServiceTypes.ASSET_ACCESS]
access_descriptor = ServiceDescriptor.access_service_descriptor(access_service.attributes, access_service.service_endpoint, access_service.template_id)
compute_descriptor = ServiceDescriptor.compute_service_descriptor(access_service.attributes, access_service.service_endpoint, access_service.template_id)
services = ServiceFactory.build_services([md_descriptor, access_descriptor, compute_descriptor])
assert len(services) == 3
assert services[0].type == ServiceTypes.METADATA
assert services[1].type == ServiceTypes.ASSET_ACCESS
assert services[2].type == ServiceTypes.CLOUD_COMPUTE
keeper = Keeper.get_instance()
name_to_address = {name: i.address for name, i in keeper.contract_name_to_instance.items()}
s = services[1]
s.init_conditions_values(ddo.did, name_to_address)
s = services[2]
s.init_conditions_values(ddo.did, name_to_address)
assert isinstance(services[1], ServiceAgreement)
assert isinstance(services[2], ServiceAgreement)
def create_asset(ocean, wallet, service_attributes, metadata, token_address):
service_endpoint = DataServiceProvider.get_url(ocean.config)
download_service = ServiceDescriptor.access_service_descriptor(
service_attributes, service_endpoint)
compute_attributes = trying_compute(wallet)
computer_service = ServiceDescriptor.compute_service_descriptor(
compute_attributes, service_endpoint)
print(download_service)
print(computer_service)
print("kjashdfkhaskdfhkjhasdjkfhkjasdhfjkasdhjkfhajkdshf")
asset = ocean.assets.create(metadata,
wallet,
service_descriptors=[download_service],
data_token_address=token_address)
return asset
def get_registered_ddo_with_compute_service(ocean_instance,
wallet,
provider_uri=None,
trusted_algorithms=None):
old_ddo = get_sample_ddo_with_compute_service()
metadata = old_ddo.metadata
metadata["main"]["files"][0]["checksum"] = str(uuid.uuid4())
service = old_ddo.get_service(ServiceTypes.CLOUD_COMPUTE)
compute_attributes = ocean_instance.compute.create_compute_service_attributes(
service.attributes["main"]["timeout"],
service.attributes["main"]["creator"],
service.attributes["main"]["datePublished"],
service.attributes["main"]["provider"],
privacy_attributes=ocean_instance.compute.
build_service_privacy_attributes(
trusted_algorithms,
allow_raw_algorithm=True,
allow_all_published_algorithms=not bool(trusted_algorithms),
),
)
compute_service = ServiceDescriptor.compute_service_descriptor(
compute_attributes, DataServiceProvider.get_url(ocean_instance.config))
return get_registered_ddo(ocean_instance,
metadata,
wallet,
compute_service,
provider_uri=provider_uri)
def test_create_asset_with_different_secret_store(publisher_ocean_instance):
ocn = publisher_ocean_instance
sample_ddo_path = get_resource_path('ddo', 'ddo_sa_sample.json')
assert sample_ddo_path.exists(), "{} does not exist!".format(
sample_ddo_path)
acct = ocn.main_account
aqua = AquariusProvider.get_aquarius(ocn.config.aquarius_url)
aqua.retire_all_assets()
asset = DDO(json_filename=sample_ddo_path)
my_secret_store = 'http://myownsecretstore.com'
auth_service = ServiceDescriptor.authorization_service_descriptor(
my_secret_store)
asset.metadata['main']['name'] += str(datetime.now().timestamp())
new_asset = ocn.assets.create(asset.metadata, acct, [auth_service])
assert new_asset.get_service(
ServiceTypes.AUTHORIZATION).service_endpoint == my_secret_store
assert new_asset.get_service(ServiceTypes.ASSET_ACCESS)
assert new_asset.get_service(ServiceTypes.METADATA)
publisher_ocean_instance.assets.retire(new_asset.did)
access_service = ServiceDescriptor.access_service_descriptor(
{
"main": {
"name": "dataAssetAccessServiceAgreement",
"creator": '0x1234',
"price": '1',
"timeout": 3600,
"datePublished": '2019-08-30T12:19:54Z'
}
}, 'service/endpoint', '0x0011001100110011')
asset.metadata['main']['name'] += str(datetime.now().timestamp())
new_asset = ocn.assets.create(asset.metadata, acct, [access_service])
assert new_asset.get_service(ServiceTypes.AUTHORIZATION)
assert new_asset.get_service(ServiceTypes.ASSET_ACCESS)
assert new_asset.get_service(ServiceTypes.METADATA)
publisher_ocean_instance.assets.retire(new_asset.did)
asset.metadata['main']['name'] += str(datetime.now().timestamp())
new_asset = ocn.assets.create(asset.metadata, acct)
assert new_asset.get_service(ServiceTypes.AUTHORIZATION)
assert new_asset.get_service(ServiceTypes.ASSET_ACCESS)
assert new_asset.get_service(ServiceTypes.METADATA)
publisher_ocean_instance.assets.retire(new_asset.did)
def create_asset(ocean, publisher):
sample_ddo_path = get_resource_path("ddo", "ddo_sa_sample.json")
assert sample_ddo_path.exists(), "{} does not exist!".format(sample_ddo_path)
asset = DDO(json_filename=sample_ddo_path)
asset.metadata["main"]["files"][0]["checksum"] = str(uuid.uuid4())
my_secret_store = "http://myownsecretstore.com"
auth_service = ServiceDescriptor.authorization_service_descriptor(my_secret_store)
return ocean.assets.create(asset.metadata, publisher, [auth_service])
def create_compute_service_descriptor(self, attributes):
"""
Return a service descriptor (tuple) for service of type ServiceTypes.CLOUD_COMPUTE
and having the required attributes and service endpoint.
:param attributes: dict as created in `create_compute_service_attributes`
"""
compute_endpoint = self._data_provider.get_url(self._config)
return ServiceDescriptor.compute_service_descriptor(
attributes=attributes, service_endpoint=compute_endpoint)
def get_access_service_descriptor(
ocean_instance, address, date_created, provider_uri=None, timeout=3600
):
if not provider_uri:
provider_uri = DataServiceProvider.get_url(ocean_instance.config)
return ServiceDescriptor.access_service_descriptor(
ocean_instance.assets.build_access_service(date_created, 1.0, address, timeout),
DataServiceProvider.build_download_endpoint(provider_uri)[1],
)
def get_registered_ddo(ocean_instance, wallet: Wallet):
metadata = get_metadata()
metadata["main"]["files"][0]["checksum"] = str(uuid.uuid4())
ServiceDescriptor.access_service_descriptor(
ocean_instance.assets._build_access_service(metadata, to_base_18(1),
wallet),
DataServiceProvider.get_url(ocean_instance.config),
)
block = ocean_instance.web3.eth.blockNumber
asset = ocean_instance.assets.create(metadata, wallet)
ddo_reg = ocean_instance.assets.ddo_registry()
log = ddo_reg.get_event_log(ddo_reg.EVENT_METADATA_CREATED, block,
asset.asset_id, 30)
assert log, "no ddo created event."
ddo = wait_for_ddo(ocean_instance, asset.did)
assert ddo, f"resolve did {asset.did} failed."
return asset
def create_access_service(attributes, service_endpoint):
"""
Publish an asset with an `Access` service according to the supplied attributes.
:param attributes: attributes of the access service, dict
:param service_endpoint: str URL for initiating service access request
:return: Service instance or None
"""
service = ServiceDescriptor.access_service_descriptor(
attributes, service_endpoint,
Keeper.get_instance().escrow_access_secretstore_template.address)
return service
def get_registered_ddo_with_compute_service(ocean_instance, wallet, provider_uri=None):
old_ddo = get_sample_ddo_with_compute_service()
metadata = old_ddo.metadata
metadata["main"]["files"][0]["checksum"] = str(uuid.uuid4())
service = old_ddo.get_service(ServiceTypes.CLOUD_COMPUTE)
compute_service = ServiceDescriptor.compute_service_descriptor(
service.attributes, DataServiceProvider.get_url(ocean_instance.config)
)
return get_registered_ddo(
ocean_instance, metadata, wallet, compute_service, provider_uri=provider_uri
)
def create_access_service(attributes, provider_uri=None):
"""Publish an asset with an `Access` service according to the supplied attributes.
:param attributes: attributes of the access service, dict
:param provider_uri: str URL of service provider. This will be used as base to
construct the serviceEndpoint for the `access` (download) service
:return: Service instance or None
"""
service_endpoint = provider_uri or DataServiceProvider.get_url(
ConfigProvider.get_config())
service = ServiceDescriptor.access_service_descriptor(
attributes, service_endpoint)
return service
def create_asset(publisher_ocean_instance):
ocn = publisher_ocean_instance
sample_ddo_path = get_resource_path('ddo', 'ddo_sa_sample.json')
assert sample_ddo_path.exists(), "{} does not exist!".format(
sample_ddo_path)
acct = ocn.main_account
asset = DDO(json_filename=sample_ddo_path)
my_secret_store = 'http://myownsecretstore.com'
auth_service = ServiceDescriptor.authorization_service_descriptor(
my_secret_store)
return ocn.assets.create(asset.metadata, acct, [auth_service])
def get_compute_service_descriptor(address, price, metadata):
compute_service_attributes = {
"main": {
"name": "dataAssetComputeServiceAgreement",
"creator": address,
"cost": price,
"timeout": 3600,
"datePublished": metadata[MetadataMain.KEY]['dateCreated']
}
}
return ServiceDescriptor.compute_service_descriptor(
compute_service_attributes,
f'http://localhost:8030{BaseURLs.ASSETS_URL}/compute')
def get_access_service_descriptor(address, metadata):
access_service_attributes = {
"main": {
"name": "dataAssetAccessServiceAgreement",
"creator": address,
"cost": metadata[MetadataMain.KEY]['cost'],
"timeout": 3600,
"datePublished": metadata[MetadataMain.KEY]['dateCreated']
}
}
return ServiceDescriptor.access_service_descriptor(
access_service_attributes,
f'http://localhost:8030{BaseURLs.ASSETS_URL}/download')
def create_compute_service_descriptor(self, attributes):
"""
:param attributes:
"""
brizo = BrizoProvider.get_brizo()
config = ConfigProvider.get_config()
compute_endpoint = brizo.get_compute_endpoint(config)
template_id = self._keeper.get_agreement_template_id(
ServiceTypes.CLOUD_COMPUTE)
return ServiceDescriptor.compute_service_descriptor(
attributes=attributes,
service_endpoint=compute_endpoint,
template_id=template_id)
def get_access_service_descriptor_different_provider(address, metadata):
access_service_attributes = {
"main": {
"name": "dataAssetAccessServiceAgreement",
"creator": address,
"cost": metadata[MetadataMain.KEY]["cost"],
"timeout": 3600,
"datePublished": metadata[MetadataMain.KEY]["dateCreated"],
}
}
return ServiceDescriptor.access_service_descriptor(
access_service_attributes,
f"http://some_different_provider{BaseURLs.ASSETS_URL}/download",
)
def get_access_service_descriptor(keeper, account, metadata):
template_name = keeper.template_manager.SERVICE_TO_TEMPLATE_NAME[
ServiceTypes.ASSET_ACCESS]
access_service_attributes = {
"main": {
"name": "dataAssetAccessServiceAgreement",
"creator": account.address,
"price": metadata[MetadataMain.KEY]['price'],
"timeout": 3600,
"datePublished": metadata[MetadataMain.KEY]['dateCreated']
}
}
return ServiceDescriptor.access_service_descriptor(
access_service_attributes,
f'http://localhost:8030{BaseURLs.ASSETS_URL}/consume',
keeper.template_manager.create_template_id(template_name))
def get_compute_service_descriptor(keeper, account, price, metadata):
template_name = keeper.template_manager.SERVICE_TO_TEMPLATE_NAME[
ServiceTypes.CLOUD_COMPUTE]
compute_service_attributes = {
"main": {
"name": "dataAssetComputeServiceAgreement",
"creator": account.address,
"price": price,
"timeout": 3600,
"datePublished": metadata[MetadataMain.KEY]['dateCreated']
}
}
return ServiceDescriptor.compute_service_descriptor(
compute_service_attributes,
f'http://localhost:8030{BaseURLs.ASSETS_URL}/compute',
keeper.template_manager.create_template_id(template_name))
def get_compute_service_descriptor_no_rawalgo(address, price, metadata):
compute_service_attributes = {
"main": {
"name": "dataAssetComputeServiceAgreement",
"creator": address,
"cost": price,
"privacy": {
"allowRawAlgorithm": False,
"trustedAlgorithms": [],
"allowNetworkAccess": True
},
"timeout": 3600,
"datePublished": metadata[MetadataMain.KEY]['dateCreated']
}
}
return ServiceDescriptor.compute_service_descriptor(
compute_service_attributes,
f'http://localhost:8030{BaseURLs.ASSETS_URL}/compute')
def test_create_asset_with_address(publisher_ocean_instance):
"""Tests that an asset can be created with specific DT address."""
ocn = publisher_ocean_instance
alice = get_publisher_wallet()
sample_ddo_path = get_resource_path("ddo", "ddo_sa_sample.json")
asset = DDO(json_filename=sample_ddo_path)
asset.metadata["main"]["files"][0]["checksum"] = str(uuid.uuid4())
my_secret_store = "http://myownsecretstore.com"
auth_service = ServiceDescriptor.authorization_service_descriptor(
my_secret_store)
token = ocn.create_data_token("DataToken1",
"DT1",
from_wallet=alice,
blob="foo_blob")
assert ocn.assets.create(asset.metadata,
alice, [auth_service],
data_token_address=token.address)
def get_compute_service_descriptor_specific_algo_dids(address, price, metadata,
algos):
compute_service_attributes = {
"main": {
"name": "dataAssetComputeServiceAgreement",
"creator": address,
"cost": price,
"privacy": {
"allowRawAlgorithm": False,
"allowAllPublishedAlgorithms": False,
"publisherTrustedAlgorithms": [],
"allowNetworkAccess": True,
},
"timeout": 3600,
"datePublished": metadata[MetadataMain.KEY]["dateCreated"],
}
}
for algo in algos:
service = algo.get_service(ServiceTypes.METADATA)
compute_service_attributes["main"]["privacy"][
"publisherTrustedAlgorithms"].append({
"did":
algo.did,
"filesChecksum":
hashlib.sha256(
(service.attributes["encryptedFiles"] +
json.dumps(service.main["files"], separators=(",", ":"))
).encode("utf-8")).hexdigest(),
"containerSectionChecksum":
hashlib.sha256((json.dumps(
service.main["algorithm"]["container"],
separators=(",", ":"),
)).encode("utf-8")).hexdigest(),
})
return ServiceDescriptor.compute_service_descriptor(
compute_service_attributes,
f"http://localhost:8030{BaseURLs.ASSETS_URL}/compute",
)
def get_compute_service_descriptor_specific_algo_dids(keeper, account, price,
metadata):
template_name = keeper.template_manager.SERVICE_TO_TEMPLATE_NAME[
ServiceTypes.CLOUD_COMPUTE]
compute_service_attributes = {
"main": {
"name": "dataAssetComputeServiceAgreement",
"creator": account.address,
"price": price,
"privacy": {
"allowRawAlgorithm": True,
"trustedAlgorithms": ['did:op:123', 'did:op:1234'],
"allowNetworkAccess": True
},
"timeout": 3600,
"datePublished": metadata[MetadataMain.KEY]['dateCreated']
}
}
return ServiceDescriptor.compute_service_descriptor(
compute_service_attributes,
f'http://localhost:8030{BaseURLs.ASSETS_URL}/compute',
keeper.template_manager.create_template_id(template_name))
def test_compute_flow():
######
# setup
pub_wallet = get_publisher_wallet()
p_ocean_instance = get_publisher_ocean_instance()
c_ocean_instance = get_consumer_ocean_instance()
cons_ocn = c_ocean_instance
consumer_wallet = get_consumer_wallet()
######
# Publish Assets
# Dataset with compute service
sample_ddo_path = get_resource_path('ddo', 'ddo_with_compute_service.json')
old_ddo = Asset(json_filename=sample_ddo_path)
metadata = old_ddo.metadata
metadata['main']['files'][0]['checksum'] = str(uuid.uuid4())
service = old_ddo.get_service(ServiceTypes.CLOUD_COMPUTE)
compute_service = ServiceDescriptor.compute_service_descriptor(
service.attributes,
DataServiceProvider.get_url(p_ocean_instance.config))
block = p_ocean_instance.web3.eth.blockNumber
compute_ddo = p_ocean_instance.assets.create(
metadata,
pub_wallet,
service_descriptors=[compute_service],
)
did = compute_ddo.did
ddo_reg = p_ocean_instance.assets.ddo_registry()
log = ddo_reg.get_event_log(ddo_reg.EVENT_METADATA_CREATED, block,
compute_ddo.asset_id, 30)
assert log, f'no ddo created event.'
ddo = wait_for_ddo(p_ocean_instance, compute_ddo.did)
assert ddo, f'resolve did {compute_ddo.did} failed.'
_compute_ddo = p_ocean_instance.assets.resolve(compute_ddo.did)
# algorithm with download service
algorithm_ddo_path = get_resource_path('ddo', 'ddo_sample_algorithm.json')
algo_main = Asset(json_filename=algorithm_ddo_path).metadata['main']
algo_meta_dict = algo_main['algorithm'].copy()
algo_meta_dict['url'] = algo_main['files'][0]['url']
algorithm_meta = AlgorithmMetadata(algo_meta_dict)
######
# Mint tokens for dataset and assign to publisher
dt = p_ocean_instance.get_data_token(compute_ddo.data_token_address)
mint_tokens_and_wait(dt, pub_wallet.address, pub_wallet)
######
# Give the consumer some datatokens so they can order the service
try:
tx_id = dt.transfer_tokens(consumer_wallet.address, 10, pub_wallet)
dt.verify_transfer_tx(tx_id, pub_wallet.address,
consumer_wallet.address)
except (AssertionError, Exception) as e:
print(e)
raise
######
# Order compute service from the dataset asset
order_requirements = cons_ocn.assets.order(
compute_ddo.did,
consumer_wallet.address,
service_type=ServiceTypes.CLOUD_COMPUTE)
######
# Start the order on-chain using the `order` requirements from previous step
service = compute_ddo.get_service(ServiceTypes.CLOUD_COMPUTE)
_order_tx_id = cons_ocn.assets.pay_for_service(
order_requirements.amount, order_requirements.data_token_address,
compute_ddo.did, service.index,
'0xF9f2DB837b3db03Be72252fAeD2f6E0b73E428b9', consumer_wallet)
######
job_id = cons_ocn.compute.start(did,
consumer_wallet,
_order_tx_id,
nonce=order_requirements.nonce,
algorithm_meta=algorithm_meta)
assert job_id, f'expected a job id, got {job_id}'
status = cons_ocn.compute.status(did, job_id, consumer_wallet)
print(f'got job status: {status}')
assert status and status[
'ok'], f'something not right about the compute job, got status: {status}'
status = cons_ocn.compute.stop(did, job_id, consumer_wallet)
print(f'got job status after requesting stop: {status}')
assert status, f'something not right about the compute job, got status: {status}'
def create_compute_service(attributes, provider_uri=None):
service_endpoint = provider_uri or DataServiceProvider.get_url(
ConfigProvider.get_config())
return ServiceDescriptor.compute_service_descriptor(
attributes, service_endpoint)
date_created = "2020-12-01T10:55:11Z"
service_attributes = {
"main": {
"name": "dataAssetAccessServiceAgreement",
"creator": wallet.address,
"timeout": 3600 * 24,
"datePublished": date_created,
"cost": 1.0, # <don't change, this is obsolete>
}
}
#service_endpoint = DataServiceProvider.get_url(ocean.config)
service_endpoint = DataServiceProvider.get_url(config)
download_service = ServiceDescriptor.access_service_descriptor(service_attributes, service_endpoint)
metadata = {
"main": {
"type": "dataset", "name": "S1Seven", "author": "Hannes",
"license": "CC0: Public Domain", "dateCreated": date_created,
"files": [
{ "index": 0, "contentType": "application/zip", "url": "https://s3.amazonaws.com/datacommons-seeding-us-east/10_Monkey_Species_Small/assets/training.zip"},
{ "index": 1, "contentType": "text/text", "url": "https://s3.amazonaws.com/datacommons-seeding-us-east/10_Monkey_Species_Small/assets/monkey_labels.txt"},
{ "index": 2, "contentType": "application/zip", "url": "https://s3.amazonaws.com/datacommons-seeding-us-east/10_Monkey_Species_Small/assets/validation.zip"}]}
}
#ocean.assets.create will encrypt URLs using Provider's encrypt service endpoint, and update asset before putting on-chain.
def get_registered_ddo(client, wallet, metadata, service_descriptor):
aqua = Aquarius('http://localhost:5000')
ddo_service_endpoint = aqua.get_service_endpoint()
metadata_store_url = json.dumps({'t': 1, 'url': ddo_service_endpoint})
# Create new data token contract
addresses = get_contracts_addresses(get_address_file())
dt_address = addresses.get(DTFactory.CONTRACT_NAME)
if dt_address:
factory_contract = DTFactory(dt_address)
else:
factory_contract = new_factory_contract()
ddo_contract_address = addresses.get(MetadataContract.CONTRACT_NAME)
metadata_contract = MetadataContract(ddo_contract_address)
tx_id = factory_contract.createToken(metadata_store_url, 'DataToken1',
'DT1', to_base_18(1000000), wallet)
dt_contract = DataToken(factory_contract.get_token_address(tx_id))
if not dt_contract:
raise AssertionError('Creation of data token contract failed.')
ddo = Asset()
ddo.data_token_address = dt_contract.address
metadata_service_desc = ServiceDescriptor.metadata_service_descriptor(
metadata, ddo_service_endpoint)
service_descriptors = list([
ServiceDescriptor.authorization_service_descriptor(
'http://localhost:12001')
])
service_descriptors.append(service_descriptor)
service_type = service_descriptor[0]
service_descriptors = [metadata_service_desc] + service_descriptors
services = ServiceFactory.build_services(service_descriptors)
checksums = dict()
for service in services:
checksums[str(service.index)] = checksum(service.main)
# Adding proof to the ddo.
ddo.add_proof(checksums, wallet)
did = ddo.assign_did(f'did:op:{remove_0x_prefix(ddo.data_token_address)}')
ddo_service_endpoint.replace('{did}', did)
services[0].set_service_endpoint(ddo_service_endpoint)
stype_to_service = {s.type: s for s in services}
_service = stype_to_service[service_type]
for service in services:
ddo.add_service(service)
# ddo.proof['signatureValue'] = ocean_lib.sign_hash(
# did_to_id_bytes(did), account)
ddo.add_public_key(did, wallet.address)
ddo.add_authentication(did, PUBLIC_KEY_TYPE_RSA)
# if not plecos.is_valid_dict_local(ddo.metadata):
# print(f'invalid metadata: {plecos.validate_dict_local(ddo.metadata)}')
# assert False, f'invalid metadata: {plecos.validate_dict_local(ddo.metadata)}'
files_list_str = json.dumps(metadata['main']['files'])
encrypted_files = encrypt_document(client, did, files_list_str, wallet)
# encrypted_files = do_encrypt(files_list_str, provider_wallet)
# only assign if the encryption worked
if encrypted_files:
index = 0
for file in metadata['main']['files']:
file['index'] = index
index = index + 1
del file['url']
metadata['encryptedFiles'] = encrypted_files
web3 = Web3Provider.get_web3()
block = web3.eth.blockNumber
try:
data = lzma.compress(web3.toBytes(text=ddo.as_text()))
tx_id = metadata_contract.create(ddo.asset_id, bytes([1]), data,
wallet)
if not metadata_contract.verify_tx(tx_id):
raise AssertionError(
f'create DDO on-chain failed, transaction status is 0. Transaction hash is {tx_id}'
)
except Exception as e:
print(f'error publishing ddo {ddo.did} in Aquarius: {e}')
raise
log = metadata_contract.get_event_log(
metadata_contract.EVENT_METADATA_CREATED, block, ddo.asset_id, 30)
assert log, f'no ddo created event.'
ddo = wait_for_ddo(aqua, ddo.did)
assert ddo, f'resolve did {ddo.did} failed.'
return ddo
def test_order(publisher_ocean_instance, consumer_ocean_instance):
consumer_account = consumer_ocean_instance.main_account
publisher_account = publisher_ocean_instance.main_account
keeper = publisher_ocean_instance.keeper
ocean = consumer_ocean_instance
BrizoProvider.set_brizo_class(Brizo)
SecretStoreProvider.set_secret_store_class(SecretStore)
sample_ddo_path = get_resource_path('ddo', 'ddo_with_compute_service.json')
old_ddo = DDO(json_filename=sample_ddo_path)
metadata = old_ddo.metadata
metadata['main']['files'][0]['checksum'] = str(uuid.uuid4())
template_name = keeper.template_manager.SERVICE_TO_TEMPLATE_NAME[ServiceTypes.CLOUD_COMPUTE]
service = old_ddo.get_service(ServiceTypes.CLOUD_COMPUTE)
brizo = BrizoProvider.get_brizo()
compute_service = ServiceDescriptor.compute_service_descriptor(
service.attributes,
brizo.get_compute_endpoint(ocean.config),
keeper.template_manager.create_template_id(template_name)
)
compute_ddo = publisher_ocean_instance.assets.create(
metadata,
publisher_account,
providers=[],
service_descriptors=[compute_service],
)
did = compute_ddo.did
_compute_ddo = publisher_ocean_instance.assets.resolve(compute_ddo.did)
algorithm_ddo_path = get_resource_path('ddo', 'ddo_sample_algorithm.json')
algo_main = DDO(json_filename=algorithm_ddo_path).metadata['main']
algo_meta_dict = algo_main['algorithm'].copy()
algo_meta_dict['url'] = algo_main['files'][0]['url']
algorithm_meta = AlgorithmMetadata(algo_meta_dict)
try:
ocean.accounts.request_tokens(publisher_account, 50*keeper.dispenser.get_scale())
except Exception as err:
print(f'Requesting tokens failed: {err}')
agreement_id = ocean.compute.order(
compute_ddo.did,
consumer_account,
None,
None
)
assert agreement_id, f'got agreementId {agreement_id}'
def fulfill_compute_execution(_, ocn_instance, agr_id, _did, cons_address, account):
ocn_instance.agreements.conditions.grant_compute(
agr_id, _did, cons_address, account)
event = keeper.lock_reward_condition.subscribe_condition_fulfilled(
agreement_id,
15,
fulfill_compute_execution,
(publisher_ocean_instance, agreement_id, compute_ddo.did,
consumer_account.address, publisher_account),
from_block=0,
wait=True
)
assert event, f'lock condition event is not found.'
print(f'processed agreement and got lockReward fulfilled: '
f'{agreement_id}, {compute_ddo.did}, ')
event = keeper.compute_execution_condition.subscribe_condition_fulfilled(
agreement_id,
20,
None,
(agreement_id, compute_ddo.did, consumer_account, None, algorithm_meta),
from_block=0,
wait=True
)
assert event, f'compute execution condition event is not found.'
job_id = consumer_ocean_instance.compute.start(agreement_id, consumer_account, algorithm_meta=algorithm_meta)
assert job_id, f'expected a job id, got {job_id}'
status = consumer_ocean_instance.compute.status(agreement_id, job_id, consumer_account)
print(f'got job status: {status}')
assert status and status['ok'], f'something not right about the compute job, got status: {status}'
status = consumer_ocean_instance.compute.stop(agreement_id, job_id, consumer_account)
print(f'got job status after requesting stop: {status}')
assert status, f'something not right about the compute job, got status: {status}'
def get_registered_ddo(account, providers=None):
keeper = keeper_instance()
aqua = Aquarius('http://localhost:5000')
for did in aqua.list_assets():
aqua.retire_asset_ddo(did)
metadata = get_sample_ddo()['service'][0]['attributes']
metadata['main']['files'][0]['checksum'] = str(uuid.uuid4())
ddo = DDO()
ddo_service_endpoint = aqua.get_service_endpoint()
metadata_service_desc = ServiceDescriptor.metadata_service_descriptor(
metadata, ddo_service_endpoint)
access_service_attributes = {
"main": {
"name": "dataAssetAccessServiceAgreement",
"creator": account.address,
"price": metadata[MetadataMain.KEY]['price'],
"timeout": 3600,
"datePublished": metadata[MetadataMain.KEY]['dateCreated']
}
}
service_descriptors = [
ServiceDescriptor.authorization_service_descriptor(
'http://localhost:12001')
]
service_descriptors += [
ServiceDescriptor.access_service_descriptor(
access_service_attributes, 'http://localhost:8030',
keeper.escrow_access_secretstore_template.address)
]
service_descriptors = [metadata_service_desc] + service_descriptors
services = ServiceFactory.build_services(service_descriptors)
checksums = dict()
for service in services:
checksums[str(service.index)] = checksum(service.main)
# Adding proof to the ddo.
ddo.add_proof(checksums, account)
did = ddo.assign_did(DID.did(ddo.proof['checksum']))
stype_to_service = {s.type: s for s in services}
access_service = stype_to_service[ServiceTypes.ASSET_ACCESS]
name_to_address = {
cname: cinst.address
for cname, cinst in keeper.contract_name_to_instance.items()
}
access_service.init_conditions_values(
did, contract_name_to_address=name_to_address)
ddo.add_service(access_service)
for service in services:
ddo.add_service(service)
ddo.proof['signatureValue'] = keeper.sign_hash(did_to_id_bytes(did),
account)
ddo.add_public_key(did, account.address)
ddo.add_authentication(did, PUBLIC_KEY_TYPE_RSA)
encrypted_files = do_secret_store_encrypt(
remove_0x_prefix(ddo.asset_id), json.dumps(metadata['main']['files']),
account, get_config())
_files = metadata['main']['files']
# only assign if the encryption worked
if encrypted_files:
index = 0
for file in metadata['main']['files']:
file['index'] = index
index = index + 1
del file['url']
metadata['encryptedFiles'] = encrypted_files
keeper_instance().did_registry.register(
ddo.asset_id,
checksum=web3().toBytes(hexstr=ddo.asset_id),
url=ddo_service_endpoint,
account=account,
providers=providers)
aqua.publish_asset_ddo(ddo)
return ddo