def consume(ocn, account, agreement_id, method='download'):
agreement = ocn.agreements.get(agreement_id)
did = id_to_did(agreement.did)
token = decrypt(ocn, account, did)
if method == 'download':
return consume_download(ocn, account, did, agreement_id, token)
elif method == 'get':
return consume_get(ocn, did, token)
def agreements_create_prepared(ctx, agreement_id, service_id, signature):
ocean, account = ctx.obj['ocean'], ctx.obj['account']
agreement = ocean.agreements.get(agreement_id)
result = ocean.agreements.create(id_to_did(agreement.did),
service_id, agreement_id,
signature, account.address, account)
echo({
"result": result
})
def consume_agreement(ocean, agreement_id, method):
agreement = ocean.agreements.get(agreement_id)
did = id_to_did(agreement.did)
service_endpoint, secret = credentials(ocean, did)
return consume(did,
agreement_id,
service_endpoint,
secret,
method,
ocean=ocean)
def handle_agreement_created(event=None,
agreement_id=None,
ocean=None,
*args,
**kwargs):
time.sleep(3)
consumer = event['args'].get('_accessConsumer', None)
provider = event['args'].get('_accessProvider', None)
if provider == ocean.account.address:
did = id_to_did(ocean.agreements.get(agreement_id).did)
return {'did': did, 'consumer': consumer, 'provider': provider}
def add_data(self, data, value):
"""
Add a resolved event data item to the list of resolved items
as this could be the last item in the chain.
:param data: dictionary of the DIDRegistry event data
:param value: formated value depending on the data['value_type'] string, bytes32
"""
self._items.append(data)
if data['value_type'] == VALUE_TYPE_DID:
self._value = id_to_did(value)
else:
self._value = value
def access(ocn, account, agreement_id, consumer):
if agreement_id == 'all':
response = False
for _agreement_id in list_agreements(ocn, account, account.address):
try:
response = access(ocn, account, _agreement_id, consumer)
except Exception as e:
print(e)
return response
ocean_conditions = OceanConditions(Keeper.get_instance())
agreement = ocn.agreements.get(agreement_id)
return ocean_conditions.grant_access(agreement_id,
id_to_did(agreement.did), consumer,
account)
def test_id_to_did():
test_id = '%s' % secrets.token_hex(32)
valid_did_text = 'did:op:{}'.format(test_id)
assert id_to_did(test_id) == valid_did_text
# accept hex string from Web3 py
assert id_to_did(Web3.toHex(hexstr=test_id)) == valid_did_text
# accepts binary value
assert id_to_did(Web3.toBytes(hexstr=test_id)) == valid_did_text
with pytest.raises(TypeError):
id_to_did(None)
with pytest.raises(TypeError):
id_to_did({'bad': 'value'})
assert id_to_did('') == 'did:op:0'
def list_assets(address=None, ocean=None):
did_list = [
id_to_did(Web3Provider.get_web3().toHex(_id)[2:]) for _id in
DIDRegistry.get_instance().contract_concise.getDIDRegisterIds()
]
if address:
if address == 'me':
address = ocean.account.address
result = []
for did in did_list:
try:
asset_owner = ocean.assets.resolve(
did).as_dictionary()['publicKey'][0]['owner']
if asset_owner == address:
result += [did]
except ValueError:
pass
return result
return did_list
def create_from_metadata(cls, metadata, service_endpoint):
"""return a new Asset object from a metadata dictionary"""
# calc the asset id
asset_id = hashlib.sha256(
json.dumps(metadata['base']).encode('utf-8')).hexdigest()
# generate a DID from an asset_id
new_did = id_to_did(asset_id)
# create a new DDO
new_ddo = DDO(new_did)
# add a signature
private_password = new_ddo.add_signature()
# add the service endpoint with the meta data
new_ddo.add_service(ServiceTypes.METADATA,
service_endpoint,
values={DDO_SERVICE_METADATA_KEY: metadata})
# add the static proof
new_ddo.add_proof(0, private_password)
# create the asset object
this_asset = cls(ddo=new_ddo)
logging.debug("Asset {} created from metadata {} ".format(
this_asset.asset_id, metadata))
return this_asset
def consume():
"""Allows download of asset data file.
---
tags:
- services
consumes:
- application/json
parameters:
- name: consumerAddress
in: query
description: The consumer address.
required: true
type: string
- name: serviceAgreementId
in: query
description: The ID of the service agreement.
required: true
type: string
- name: url
in: query
description: This URL is only valid if Brizo acts as a proxy.
Consumer can't download using the URL if it's not through Brizo.
required: true
type: string
responses:
200:
description: Redirect to valid asset url.
400:
description: One of the required attributes is missing.
401:
description: Invalid asset data.
500:
description: Error
"""
data = request.args
required_attributes = ['serviceAgreementId', 'consumerAddress']
msg, status = check_required_attributes(required_attributes, data,
'consume')
if msg:
return msg, status
if not (data.get('url') or (data.get('signature') and data.get('index'))):
return f'Either `url` or `signature and index` are required in the call to "consume".', 400
try:
provider_account = get_provider_account(ocn)
agreement_id = data.get('serviceAgreementId')
consumer_address = data.get('consumerAddress')
asset_id = ocn.agreements.get(agreement_id).did
did = id_to_did(asset_id)
if ocn.agreements.is_access_granted(agreement_id, did,
consumer_address):
logger.info('Connecting through Osmosis to generate the sign url.')
url = data.get('url')
try:
if not url:
signature = data.get('signature')
index = int(data.get('index'))
address = Keeper.get_instance().ec_recover(
agreement_id, signature)
if address.lower() != consumer_address.lower():
msg = f'Invalid signature {signature} for ' \
f'consumerAddress {consumer_address} and documentId {did}.'
raise ValueError(msg)
asset = ocn.assets.resolve(did)
urls_str = ocn.secret_store.decrypt(
asset_id, asset.encrypted_files, provider_account)
urls = json.loads(urls_str)
if index >= len(urls):
raise ValueError(f'url index "{index}"" is invalid.')
url = urls[index]['url']
osm = Osmosis(url, config_file)
download_url = osm.data_plugin.generate_url(url)
logger.debug("Osmosis generate the url: %s", download_url)
try:
if request.range:
headers = {"Range": request.headers.get('range')}
response = requests_session.get(download_url,
headers=headers,
stream=True)
else:
headers = {
"Content-Disposition":
f'attachment;filename={url.split("/")[-1]}'
}
response = requests_session.get(download_url,
headers=headers,
stream=True)
return Response(io.BytesIO(response.content).read(),
response.status_code,
headers=headers)
except Exception as e:
logger.error(e)
return "Error getting the url content: %s" % e, 401
except Exception as e:
logger.error(e)
return "Error generating url: %s" % e, 401
else:
msg = "Invalid consumer address and/or service agreement id, " \
"or consumer address does not have permission to consume this asset."
logger.warning(msg)
return msg, 401
except Exception as e:
logger.error("Error- " + str(e))
return "Error : " + str(e), 500
def get_agreement_from_id(ocn, agreement_id):
agreement = ocn.agreements.get(agreement_id)
did = id_to_did(agreement.did)
return get_agreement_from_did(ocn, did)
def consume_agreement(ocean, account, agreement_id, method):
agreement = ocean.agreements.get(agreement_id)
did = id_to_did(agreement.did)
service_endpoint, url, token = credentials(ocean, account, did)
return consume(ocean, account, did, agreement_id, service_endpoint, url,
token, method)
