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 )
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 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 test_service_factory(): """Tests ServiceFactory builds services.""" ddo = get_sample_ddo("ddo_algorithm.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 ) services = ServiceFactory.build_services([md_descriptor]) assert len(services) == 1 assert services[0].type == ServiceTypes.METADATA
def create_asset(ocean, publisher): """Helper function for asset creation based on ddo_sa_sample.json.""" 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 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 _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["main"]["dateCreated"], 1.0, wallet.address), self._data_provider.build_download_endpoint(provider_uri)[1], ) 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 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 test_create_asset_without_dt_address(publisher_ocean_instance): """Tests creation of the asset which has not the data token 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) assert ocn.assets.create(asset.metadata, alice, [auth_service], data_token_address=None)
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)