diff --git a/swh/deposit/injection/client.py b/swh/deposit/injection/client.py index 05670a1b..1669e20a 100644 --- a/swh/deposit/injection/client.py +++ b/swh/deposit/injection/client.py @@ -1,87 +1,127 @@ # Copyright (C) 2017 The Software Heritage developers # See the AUTHORS file at the top-level directory of this distribution # License: GNU General Public License version 3, or any later version # See top-level LICENSE file for more information """Module in charge of defining an swh-deposit client """ import requests +from swh.core.config import SWHConfig -class DepositClient: +class DepositClient(SWHConfig): """Deposit client to: - read archive - read metadata - update deposit's status """ - def read_archive_to(self, archive_update_url, archive_path, log=None): + CONFIG_BASE_FILENAME = 'deposit/client' + DEFAULT_CONFIG = {} + + def __init__(self, config=None): + if config is not None: + self.config = config + else: + super().__init__() + + # self._client = _client + + # if 'user' in self.config and 'password' in self.config: + # self.auth = (self.config['user'], self.config['pass']) + # else: + # self.auth = None + + _methods = {'get': requests.get, 'put': requests.put} + + _supported_methods = set(_methods.keys()) + + def do(self, method, *args, **kwargs): + """Internal method to deal with requests, possibly with basic http + authentication. + + Args: + method (str): supported http methods as in self._methods' keys + + Returns: + The request's execution + + """ + if method not in self._supported_methods: + raise ValueError('Development error, only methods %s supported' % ( + self._supported_methods)) + + # if self.auth: + # kwargs['auth'] = self.auth + return self._methods[method](*args, **kwargs) + + def archive_get(self, archive_update_url, archive_path, log=None): """Retrieve the archive from the deposit to a local directory. Args: archive_update_url (str): The full deposit archive(s)'s raw content to retrieve locally archive_path (str): the local archive's path where to store the raw content Returns: The archive path to the local archive to load. Or None if any problem arose. """ r = requests.get(archive_update_url, stream=True) if r.ok: with open(archive_path, 'wb') as f: for chunk in r.iter_content(): f.write(chunk) return archive_path msg = 'Problem when retrieving deposit archive at %s' % ( archive_update_url, ) if log: log.error(msg) raise ValueError(msg) - def read_metadata(self, metadata_url, log=None): + def metadata_get(self, metadata_url, log=None): """Retrieve the metadata information on a given deposit. Args: metadata_url (str): The full deposit metadata url to retrieve locally Returns: The dictionary of metadata for that deposit or None if any problem arose. """ r = requests.get(metadata_url) if r.ok: return r.json() msg = 'Problem when retrieving metadata at %s' % metadata_url if log: log.error(msg) raise ValueError(msg) - def update_status(self, update_status_url, status, + def status_update(self, update_status_url, status, revision_id=None): """Update the deposit's status. Args: update_status_url (str): the full deposit's archive status (str): The status to update the deposit with revision_id (str/None): the revision's identifier to update to """ payload = {'status': status} if revision_id: payload['revision_id'] = revision_id requests.put(update_status_url, json=payload) diff --git a/swh/deposit/injection/loader.py b/swh/deposit/injection/loader.py index b61fc2ab..a9c973cb 100644 --- a/swh/deposit/injection/loader.py +++ b/swh/deposit/injection/loader.py @@ -1,125 +1,125 @@ # Copyright (C) 2017 The Software Heritage developers # See the AUTHORS file at the top-level directory of this distribution # License: GNU General Public License version 3, or any later version # See top-level LICENSE file for more information import datetime import os import tempfile from swh.model import hashutil from swh.loader.tar import loader from swh.loader.core.loader import SWHLoader from .client import DepositClient class DepositLoader(loader.TarLoader): """Deposit loader implementation. This is a subclass of the :class:TarLoader as the main goal of this class is to first retrieve the deposit's tarball contents as one and its associated metadata. Then provide said tarball to be loaded by the TarLoader. This will: - retrieves the deposit's archive locally - provide the archive to be loaded by the tar loader - clean up the temporary location used to retrieve the archive locally - update the deposit's status accordingly """ def __init__(self, client=None): super().__init__() if client: self.client = client else: self.client = DepositClient() def load(self, *, archive_url, deposit_meta_url, deposit_update_url): SWHLoader.load( self, archive_url=archive_url, deposit_meta_url=deposit_meta_url, deposit_update_url=deposit_update_url) def prepare(self, *, archive_url, deposit_meta_url, deposit_update_url): """Prepare the injection by first retrieving the deposit's raw archive content. """ self.deposit_update_url = deposit_update_url temporary_directory = tempfile.TemporaryDirectory() self.temporary_directory = temporary_directory archive_path = os.path.join(temporary_directory.name, 'archive.zip') - archive = self.client.get_archive( + archive = self.client.archive_get( archive_url, archive_path, log=self.log) - metadata = self.client.get_metadata( + metadata = self.client.metadata_get( deposit_meta_url, log=self.log) origin = metadata['origin'] visit_date = datetime.datetime.now(tz=datetime.timezone.utc) revision = metadata['revision'] occurrence = metadata['occurrence'] self.origin_metadata = metadata['origin_metadata'] self.prepare_metadata() - self.client.update_deposit_status(deposit_update_url, 'injecting') + self.client.status_update(deposit_update_url, 'injecting') super().prepare(tar_path=archive, origin=origin, visit_date=visit_date, revision=revision, occurrences=[occurrence]) def store_metadata(self): """Storing the origin_metadata during the load processus. Provider_id and tool_id are resolved during the prepare() method. """ origin_id = self.origin_id visit_date = self.visit_date provider_id = self.origin_metadata['provider']['provider_id'] tool_id = self.origin_metadata['tool']['tool_id'] metadata = self.origin_metadata['metadata'] try: self.send_origin_metadata(origin_id, visit_date, provider_id, tool_id, metadata) except: self.log.exception('Problem when storing origin_metadata') raise def post_load(self, success=True): """Updating the deposit's status according to its loading status. If not successful, we update its status to failure. Otherwise, we update its status to 'success' and pass along its associated revision. """ try: if not success: - self.client.update_deposit_status(self.deposit_update_url, - status='failure') + self.client.status_update(self.deposit_update_url, + status='failure') return # first retrieve the new revision [rev_id] = self.objects['revision'].keys() if rev_id: rev_id_hex = hashutil.hash_to_hex(rev_id) # then update the deposit's status to success with its # revision-id - self.client.update_deposit_status(self.deposit_update_url, - status='success', - revision_id=rev_id_hex) + self.client.status_update(self.deposit_update_url, + status='success', + revision_id=rev_id_hex) except: self.log.exception( 'Problem when trying to update the deposit\'s status') def cleanup(self): """Clean up temporary directory where we retrieved the tarball. """ super().cleanup() self.temporary_directory.cleanup() diff --git a/swh/deposit/tests/injection/test_client.py b/swh/deposit/tests/injection/test_client.py index 526ca96d..6393c45f 100644 --- a/swh/deposit/tests/injection/test_client.py +++ b/swh/deposit/tests/injection/test_client.py @@ -1,176 +1,176 @@ # Copyright (C) 2017 The Software Heritage developers # See the AUTHORS file at the top-level directory of this distribution # License: GNU General Public License version 3, or any later version # See top-level LICENSE file for more information import os import shutil import tempfile import unittest from nose.plugins.attrib import attr from nose.tools import istest from unittest.mock import patch from swh.deposit.injection.client import DepositClient class StreamedResponse: """Streamed response facsimile """ def __init__(self, ok, stream): self.ok = ok self.stream = stream def iter_content(self): yield from self.stream @attr('fs') class DepositClientReadArchiveTest(unittest.TestCase): def setUp(self): super().setUp() - self.client = DepositClient() + self.client = DepositClient(config={}) self.temporary_directory = tempfile.mkdtemp(dir='/tmp') def tearDown(self): super().setUp() shutil.rmtree(self.temporary_directory) @patch('swh.deposit.injection.client.requests') @istest - def read_archive_to(self, mock_requests): + def archive_get(self, mock_requests): """Reading archive should write data in temporary directory """ stream_content = [b"some", b"streamed", b"response"] mock_requests.get.return_value = StreamedResponse( ok=True, stream=(s for s in stream_content)) archive_path = os.path.join(self.temporary_directory, 'test.archive') - archive_path = self.client.read_archive_to( + archive_path = self.client.archive_get( 'http://nowhere:9000/some/url', archive_path) self.assertTrue(os.path.exists(archive_path)) with open(archive_path, 'rb') as f: actual_content = f.read() self.assertEquals(actual_content, b''.join(stream_content)) @patch('swh.deposit.injection.client.requests') @istest - def read_archive_to_can_fail(self, mock_requests): + def archive_get_can_fail(self, mock_requests): """Reading archive can fail for some reasons """ mock_requests.get.return_value = StreamedResponse(ok=False, stream=None) url = 'http://nowhere:9001/some/url' with self.assertRaisesRegex( ValueError, 'Problem when retrieving deposit archive at %s' % url): - self.client.read_archive_to(url, 'some/path') + self.client.archive_get(url, 'some/path') class JsonResponse: """Json response facsimile """ def __init__(self, ok, response): self.ok = ok self.response = response def json(self): return self.response class DepositClientReadMetadataTest(unittest.TestCase): def setUp(self): super().setUp() - self.client = DepositClient() + self.client = DepositClient(config={}) @patch('swh.deposit.injection.client.requests') @istest - def read_metadata(self, mock_requests): + def metadata_get(self, mock_requests): """Reading archive should write data in temporary directory """ expected_response = {"some": "dict"} mock_requests.get.return_value = JsonResponse( ok=True, response=expected_response) - actual_metadata = self.client.read_metadata( + actual_metadata = self.client.metadata_get( 'http://nowhere:9000/metadata') self.assertEquals(actual_metadata, expected_response) @patch('swh.deposit.injection.client.requests') @istest - def read_metadata_can_fail(self, mock_requests): + def metadata_get_can_fail(self, mock_requests): """Reading metadata can fail for some reasons """ mock_requests.get.return_value = StreamedResponse(ok=False, stream=None) url = 'http://nowhere:9001/some/metadata' with self.assertRaisesRegex( ValueError, 'Problem when retrieving metadata at %s' % url): - self.client.read_metadata(url) + self.client.metadata_get(url) class DepositClientStatusUpdateTest(unittest.TestCase): def setUp(self): super().setUp() - self.client = DepositClient() + self.client = DepositClient(config={}) @patch('swh.deposit.injection.client.requests') @istest - def update_status(self, mock_requests): + def status_update(self, mock_requests): """Update status """ def side_effect(status_url, json): global actual_status_url, actual_json actual_status_url = status_url actual_json = json mock_requests.put.side_effect = side_effect - self.client.update_status('http://nowhere:9000/update/status', + self.client.status_update('http://nowhere:9000/update/status', 'success', revision_id='some-revision-id') self.assertEquals(actual_status_url, 'http://nowhere:9000/update/status') self.assertEquals(actual_json, { 'status': 'success', 'revision_id': 'some-revision-id', }) @patch('swh.deposit.injection.client.requests') @istest - def update_status_with_no_revision_id(self, mock_requests): + def status_update_with_no_revision_id(self, mock_requests): """Reading metadata can fail for some reasons """ def side_effect(status_url, json): global actual_status_url, actual_json actual_status_url = status_url actual_json = json mock_requests.put.side_effect = side_effect - self.client.update_status('http://nowhere:9000/update/status', + self.client.status_update('http://nowhere:9000/update/status', 'failure') self.assertEquals(actual_status_url, 'http://nowhere:9000/update/status') self.assertEquals(actual_json, { 'status': 'failure', }) diff --git a/swh/deposit/tests/injection/test_loader.py b/swh/deposit/tests/injection/test_loader.py index ed1bf37d..544721e4 100644 --- a/swh/deposit/tests/injection/test_loader.py +++ b/swh/deposit/tests/injection/test_loader.py @@ -1,319 +1,320 @@ # Copyright (C) 2016-2017 The Software Heritage developers # See the AUTHORS file at the top-level directory of this distribution # License: GNU General Public License version 3, or any later version # See top-level LICENSE file for more information import json import os import unittest import shutil from nose.tools import istest from nose.plugins.attrib import attr from rest_framework.test import APITestCase from swh.model import hashutil -from swh.deposit.injection.loader import DepositLoader, DepositClient +from swh.deposit.injection.loader import DepositLoader +from swh.deposit.injection.client import DepositClient from swh.deposit.config import PRIVATE_GET_RAW_CONTENT from swh.deposit.config import PRIVATE_GET_DEPOSIT_METADATA from swh.deposit.config import PRIVATE_PUT_DEPOSIT from django.core.urlresolvers import reverse from .. import TEST_LOADER_CONFIG from ..common import BasicTestCase, WithAuthTestCase, CommonCreationRoutine from ..common import FileSystemCreationRoutine TOOL_ID = 99 PROVIDER_ID = 12 class DepositLoaderInhibitsStorage: """Mixin class to inhibit the persistence and keep in memory the data sent for storage. cf. SWHDepositLoaderNoStorage """ def __init__(self): super().__init__() # typed data self.state = { 'origin': [], 'origin_visit': [], 'origin_metadata': [], 'content': [], 'directory': [], 'revision': [], 'release': [], 'occurrence': [], 'tool': [], 'provider': [] } def _add(self, type, l): """Add without duplicates and keeping the insertion order. Args: type (str): Type of objects concerned by the action l ([object]): List of 'type' object """ col = self.state[type] for o in l: if o in col: continue col.extend([o]) def send_origin(self, origin): origin.update({'id': 1}) self._add('origin', [origin]) return origin['id'] def send_origin_visit(self, origin_id, visit_date): origin_visit = { 'origin': origin_id, 'visit_date': visit_date, 'visit': 1, } self._add('origin_visit', [origin_visit]) return origin_visit def send_origin_metadata(self, origin_id, visit_date, provider_id, tool_id, metadata): origin_metadata = { 'origin_id': origin_id, 'visit_date': visit_date, 'provider_id': provider_id, 'tool_id': tool_id, 'metadata': metadata } self._add('origin_metadata', [origin_metadata]) return origin_metadata def send_tool(self, tool): tool = { 'tool_name': tool['tool_name'], 'tool_version': tool['tool_version'], 'tool_configuration': tool['tool_configuration'] } self._add('tool', [tool]) tool_id = TOOL_ID return tool_id def send_provider(self, provider): provider = { 'provider_name': provider['provider_name'], 'provider_type': provider['provider_type'], 'provider_url': provider['provider_url'], 'metadata': provider['metadata'] } self._add('provider', [provider]) provider_id = PROVIDER_ID return provider_id def maybe_load_contents(self, contents): self._add('content', contents) def maybe_load_directories(self, directories): self._add('directory', directories) def maybe_load_revisions(self, revisions): self._add('revision', revisions) def maybe_load_releases(self, releases): self._add('release', releases) def maybe_load_occurrences(self, occurrences): self._add('occurrence', occurrences) def open_fetch_history(self): pass def close_fetch_history_failure(self, fetch_history_id): pass def close_fetch_history_success(self, fetch_history_id): pass def update_origin_visit(self, origin_id, visit, status): self.status = status # Override to do nothing at the end def close_failure(self): pass def close_success(self): pass class TestLoaderUtils(unittest.TestCase): def assertRevisionsOk(self, expected_revisions): """Check the loader's revisions match the expected revisions. Expects self.loader to be instantiated and ready to be inspected (meaning the loading took place). Args: expected_revisions (dict): Dict with key revision id, value the targeted directory id. """ # The last revision being the one used later to start back from for rev in self.loader.state['revision']: rev_id = hashutil.hash_to_hex(rev['id']) directory_id = hashutil.hash_to_hex(rev['directory']) self.assertEquals(expected_revisions[rev_id], directory_id) class SWHDepositLoaderNoStorage(DepositLoaderInhibitsStorage, DepositLoader): """Loader to test. It inherits from the actual deposit loader to actually test its correct behavior. It also inherits from DepositLoaderInhibitsStorageLoader so that no persistence takes place. """ pass +class SWHDepositTestClient(DepositClient): + def __init__(self, client, config): + super().__init__(config=config) + self.client = client + + def archive_get(self, archive_update_url, archive_path, log=None): + r = self.client.get(archive_update_url) + # import os + # os.makedirs(os.path.dirname(archive_path), exist_ok=True) + with open(archive_path, 'wb') as f: + for chunk in r.streaming_content: + f.write(chunk) + + return archive_path + + def metadata_get(self, metadata_url, log=None): + r = self.client.get(metadata_url) + return json.loads(r.content.decode('utf-8')) + + def status_update(self, update_status_url, status, revision_id=None): + payload = {'status': status} + if revision_id: + payload['revision_id'] = revision_id + self.client.put(update_status_url, + content_type='application/json', + data=json.dumps(payload)) + + @attr('fs') class DepositLoaderScenarioTest(APITestCase, WithAuthTestCase, BasicTestCase, CommonCreationRoutine, FileSystemCreationRoutine, TestLoaderUtils): def setUp(self): super().setUp() # create the extraction dir used by the loader os.makedirs(TEST_LOADER_CONFIG['extraction_dir'], exist_ok=True) self.server = 'http://localhost/' # 1. create a deposit with archive and metadata self.deposit_id = self.create_simple_binary_deposit() - me = self - - class SWHDepositTestClient(DepositClient): - def get_archive(self, archive_update_url, archive_path, - log=None): - r = me.client.get(archive_update_url) - # import os - # os.makedirs(os.path.dirname(archive_path), exist_ok=True) - with open(archive_path, 'wb') as f: - for chunk in r.streaming_content: - f.write(chunk) - - return archive_path - - def get_metadata(self, metadata_url, log=None): - r = me.client.get(metadata_url) - return json.loads(r.content.decode('utf-8')) - - def update_deposit_status(self, update_status_url, status, - revision_id=None): - payload = {'status': status} - if revision_id: - payload['revision_id'] = revision_id - me.client.put(update_status_url, - content_type='application/json', - data=json.dumps(payload)) - - # 2. setup loader with no persistence + # 2. setup loader with no persistence and that client self.loader = SWHDepositLoaderNoStorage() - # and a basic client which accesses the data - # setuped in that test - self.loader.client = SWHDepositTestClient() + # 3. Sets a basic client which accesses the test data + self.loader.client = SWHDepositTestClient(self.client, config={}) def tearDown(self): super().tearDown() shutil.rmtree(TEST_LOADER_CONFIG['extraction_dir']) @istest def inject_deposit_ready(self): """Load a deposit which is ready """ args = [self.collection.name, self.deposit_id] archive_url = reverse(PRIVATE_GET_RAW_CONTENT, args=args) deposit_meta_url = reverse(PRIVATE_GET_DEPOSIT_METADATA, args=args) deposit_update_url = reverse(PRIVATE_PUT_DEPOSIT, args=args) # when self.loader.load(archive_url=archive_url, deposit_meta_url=deposit_meta_url, deposit_update_url=deposit_update_url) # then self.assertEquals(len(self.loader.state['content']), 1) self.assertEquals(len(self.loader.state['directory']), 1) self.assertEquals(len(self.loader.state['revision']), 1) self.assertEquals(len(self.loader.state['release']), 0) self.assertEquals(len(self.loader.state['occurrence']), 1) # FIXME enrich state introspection # expected_revisions = {} # self.assertRevisionsOk(expected_revisions) @istest def inject_deposit_verify_metadata(self): """Load a deposit with metadata, test metadata integrity """ self.deposit_metadata_id = self.add_metadata_to_deposit( self.deposit_id) args = [self.collection.name, self.deposit_metadata_id] archive_url = reverse(PRIVATE_GET_RAW_CONTENT, args=args) deposit_meta_url = reverse(PRIVATE_GET_DEPOSIT_METADATA, args=args) deposit_update_url = reverse(PRIVATE_PUT_DEPOSIT, args=args) # when self.loader.load(archive_url=archive_url, deposit_meta_url=deposit_meta_url, deposit_update_url=deposit_update_url) # then self.assertEquals(len(self.loader.state['content']), 1) self.assertEquals(len(self.loader.state['directory']), 1) self.assertEquals(len(self.loader.state['revision']), 1) self.assertEquals(len(self.loader.state['release']), 0) self.assertEquals(len(self.loader.state['occurrence']), 1) self.assertEquals(len(self.loader.state['origin_metadata']), 1) self.assertEquals(len(self.loader.state['tool']), 1) self.assertEquals(len(self.loader.state['provider']), 1) atom = '{http://www.w3.org/2005/Atom}' codemeta = '{https://doi.org/10.5063/SCHEMA/CODEMETA-2.0}' expected_origin_metadata = { atom + 'author': { atom + 'email': 'hal@ccsd.cnrs.fr', atom + 'name': 'HAL' }, codemeta + 'url': 'https://hal-test.archives-ouvertes.fr/hal-01243065', codemeta + 'runtimePlatform': 'phpstorm', codemeta + 'license': { codemeta + 'name': 'CeCILL Free Software License Agreement v1.1' }, codemeta + 'programmingLanguage': 'C', codemeta + 'applicationCategory': 'test', codemeta + 'dateCreated': '2017-05-03T16:08:47+02:00', codemeta + 'version': 1, atom + 'external_identifier': 'hal-01243065', atom + 'title': 'Composing a Web of Audio Applications', codemeta + 'description': 'this is the description', atom + 'id': 'hal-01243065', atom + 'client': 'hal', codemeta + 'keywords': 'DSP programming,Web', codemeta + 'developmentStatus': 'stable' } result = self.loader.state['origin_metadata'][0] self.assertEquals(result['metadata'], expected_origin_metadata) self.assertEquals(result['tool_id'], TOOL_ID) self.assertEquals(result['provider_id'], PROVIDER_ID)