Metacat

Replaced the JiBXException by MarshallingException.

Add the check objectFormat is not null before we try to get the mediaType object from the object in the getObject method.

Merge the changes from the 2.6 branch into the trunk, fixing filename construction.

refs https://github.nceas.ucsb.edu/KNB/arctic-data/issues/151

Use the ServiceFailure to replace the InvalidRequest when it is the read-only mode (CN throws the exception).

In the replicate method, the checking of the read-only mode was moved from MNodeService class to the MNResourceHandler class since it is asynchronized.

The systemmetadataChanged method is asynchronized, so we put the read-only checking on the ResourceHandler class.

use idFilter for v2 getLogRecords() to match v2 API definition.

check for auth before doing asynch call to MN dirtySysMeta implementation

use request query string first when handling MN.query() method. https://redmine.dataone.org/issues/7384

Put a the systemMetadataChanged method into a queue, so it will not hold the block.

Use the key word "packages" to replace the "package".

Decode the string of the uri after we break the uri into parts base on the "/".

Fixed a possible null pointer exception bug. https://redmine.dataone.org/issues/7280

use objectFormat.extension in cases where we need to construct a filename for download. https://redmine.dataone.org/issues/3312

use MediaType from v2.SystemMetadata and v2.ObjectFormat to better determine mime-type, charset and filename for the get() method. https://redmine.dataone.org/issues/3309

add whoami endpoint to make debugging authn/authz easier as we use additional mechanisms for proving identity.

use singleton for getting JWT token - refactor in d1_portal project

Make the REST api work for views.

Add the code to handle the PUT method for meta url. See https://projects.ecoinformatics.org/ecoinfo/issues/6666.

Modify v1 and v2 calls to MultipartRequestResolver to use MAX_UPLOAD_SIZE from configuration.

include person's full name in the JWT returned from /token

add /token endpoint for annotatorJS/annotateIt.org integration. https://github.com/DataONEorg/sem-prov-design/issues/18

add support for v2 DataONE API.

remove leading '?' in the query parameter for MN.query() implementation. We want it to match CN behavior/expectations and comply with the DataONE specification for the interface. https://projects.ecoinformatics.org/ecoinfo/issues/6488

use consistent file names and zip content names. Opted for "-" separator so that the zip writer does not remove the unique part of the filename. https://projects.ecoinformatics.org/ecoinfo/issues/6054

include filename in the package download, though we can;t really use the PID because of all the potential characters in it that are not valid for filesystems.

include mn.publish() REST endpoint handling. https://projects.ecoinformatics.org/ecoinfo/issues/6024

implement the view service (uses existing skin-based dbtransform) - and include the REST endpoint. https://projects.ecoinformatics.org/ecoinfo/issues/6028

include GET /package/{pid} endpoint in MN service. https://projects.ecoinformatics.org/ecoinfo/issues/6027

use ContentTypeInputStream interface (and ByteArray implementation) to specify the desired content-type of the InputStream returned by MN.query().

Allow use of server-side XSLT for SOLR queries that include "wt=<qformat>". https://projects.ecoinformatics.org/ecoinfo/issues/5812

default replicaStatus (aka "show replicas in results") to true rather than false

simple autogen-based implementation of MN.generateIdentifier(). does not support DOIs, ARKs, etc. It does support including a fragment, returning an identifier like "<fragment>.2012113010215298206"

Implement MNQuery for "pathquery" engine. Optionally include guid in the pathquery results (https://redmine.dataone.org/issues/3083)

use ObjectFormatInfo libclient utility to look up mimeType and filename extension during get() calls. Configurable mapping file is deployed by default to /var/metacat/dataone where it can then be augmented as needed. This location is controlled in the metacat.properties file (which is injected into the DataONE Settings values during weapp intitialization)....

improve content type handling during the get() calls
https://redmine.dataone.org/issues/3070

use metacat.properties to specify the default checksum algorithm to use -- this way it will be easy for us to switch to whatever DataONE decrees.
https://redmine.dataone.org/issues/2834

use at least one thread on single-processor machines.
https://redmine.dataone.org/issues/2800

correct log about 'archive' being called

handle 'archive' rest calls
https://redmine.dataone.org/issues/2678

use a shared ExecutorService for replicate() calls.
https://redmine.dataone.org/issues/2623

remove extraneous pid and permission parameters from isAdminAuthorized() method and make public so that it can be called in other locations - namely before our asynchronous replicate() implementation on the MN.

change ordering of getLogRecords() parameter -- pidFilter is in the middle now

use 'formatId' for listObjects() parameter
https://redmine.dataone.org/issues/2550

upgrade to latest RC in libclient and common jars -- includes updated getLogRecords and new mn.generateIdentifier method

add logging statements when there is a problem calling setReplicationStatus

check for null session (public) calls to MN.replicate() before passing it to the asynchronous implementation

If PID is not part of the multipart params, we end up with a NullPointerException. Throw an InvalidRequest in this case rather than ServiceFailure resulting from the NPE.

serialize exception in header for describe response when there is a BaseException
https://redmine.dataone.org/issues/2440

handle both listing and getting checksums using the GET endpoint -- depends whether or not a pid is included in the URL
https://redmine.dataone.org/issues/2089

dataone configuration and registration enhancements:
-include flag to disable D1 services, currently only the MN side enforces this
-do not allow multiple registration attempts if we have just submitted and are awaiting Node verification by the CN.
-do not allow configuration "bypass" if D1 settings have been configured previously....

use plain String parameter for {pid} instead of XML serialization of it.

remove {pid} from POST URL on MN.create()
https://redmine.dataone.org/issues/2284

Ensure we have the object and sysmeta params for MN.create(). We were getting a fatal SAX parsing error encapsulated in a ServiceFailure when a science metadata object param was null. Cut it off at the pass after parsing the MMP entity.

new jars with many changes -- including new CN methods: ping, describe, listChecksumAlgorithm. Removed MN.setAccessPolicy. Refactored CN.setOwner() to CN.setRightsHolder().

Update the parameter names expected for listObjects() to reflect the MN API changes in the architecture docs.

include SerialVersion in describe response
https://redmine.dataone.org/issues/2135
NOTE: d1 jars should be replaced once all schema changes are finalized and the generate d1_common code is committed to svn

match documentation for the MN.describe() header
https://redmine.dataone.org/issues/1904

run replicate() in a separate thread so that we don't wait for potentially large data objects to be moved around the system.

Call replicate() asynchronously.

get params from multipart params for systemMetadataChanged call

get pid from normal params, not the URL -- the client should include them in the params -- and not as a serialized "object" since it is just a string value

Keep /dirtySystemMetadata as the REST endpoint for systemMetadataChanged() for now.

Fix getReplica() handling code for getReplica() and systemMetadataChanged(). Calls to getReplica() in MNode were calling get(), so the lack of resource handling was being missed.

move the DataONE 1.0.0-SNAPSHOT

The incoming source node param is just a string, not XML, so don't attempt to deserialize it. Rather, just make a new NodeReference object and set it's value to the value of the incoming param.

add User-Agent logging to support D1 requirements

MN.setAccess() is a PUT

correctly handle incoming "accessPolicy" parameters for the setAccess() method

swap the parameters for update: existing pid should be first, and then newPid

use "action" parameter instead of "permission"

include checksum algorithm when setting describe
https://redmine.dataone.org/issues/1799

correctly implement MN.describe
https://redmine.dataone.org/issues/1799

return Node not NodeList for getCapabilities
https://redmine.dataone.org/issues/1800

collect "message" param from multipart request for MN.synchronizationFailed method

use d1_common_java's date serialization utility for parsing parameters

only create ObjectFormatId when we actually have the parameter (downstream we rely on it being null or not when constructing the query)

changes for schema update (d1_common)

Update classes to use the DataONE 0.6.4 schema and types. Major changes involve using BigInteger vs long in SystemMetadata.size, and using ObjectFormatIdentifier rather than Object format.

use correct enum method

remove ServiceTypeUtil - replace with TypeMarshaller

use new "v1" types from DataONE

MNResourceHandler.getObject() was making a call to ObjectFormat.getFmtid() when an object format was null. Check that it is not null before trying getFmtid().

use objectFormatIdentifier for listObjects()
remove provisional system metadata indicator - Metacat will not implement reserveIdentifier()

Modify monitor() to accept new parameters for getOperationStatisics() (fromDate, toDate) instead of 'period'. Added getDateAsUTC() to parse incoming fromDate and toDate parameter strings.

Changed 'guid' to 'pid' to be in line with the D1 API.

simplify the MN rest servlet mapping to match CN mappings - also streamlined the handler code to share extra path info parsing

use monitor() return value when processing response

throw exceptions up the call stack and handle exception reporting/serialization centrally in the handle() method

use logging, not system.out

consolidate session management and parameter preparation in the superclass

consolidate multi part handling in the super class - subclasses need only call the appropriate helper to get access to the needed resources. superclass does some validation to make sure the files are in place in the request

cleaning up the handlers -- removing superclass methods.

refactor to use D1RestServlet and D1ResourceHandler for the D1 rest interface

MN rest servlet, handler and mappings