Page MenuHomeSoftware Heritage
Files F9336852

No OneTemporary
Actions

View Options

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)

File Metadata

Mime Type
text/x-diff
Expires
Jul 4 2025, 7:46 AM (10 w, 6 d ago)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
3245834

Event Timeline

About · Developer information · Legal